]> 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 after 1.3.24 update
[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
1713 int wxCaret_GetBlinkTime() {
1714 return wxCaret::GetBlinkTime();
1715 }
1716
1717 void wxCaret_SetBlinkTime(int milliseconds) {
1718 wxCaret::SetBlinkTime(milliseconds);
1719 }
1720
1721
1722 #include <wx/snglinst.h>
1723
1724
1725 #ifdef __WXMSW__
1726 #include <wx/msw/private.h>
1727 #include <wx/dynload.h>
1728 #endif
1729
1730
1731
1732 void wxDrawWindowOnDC(wxWindow* window, const wxDC& dc, int method)
1733 {
1734 #ifdef __WXMSW__
1735
1736 switch (method)
1737 {
1738 case 1:
1739 // This one only partially works. Appears to be an undocumented
1740 // "standard" convention that not all widgets adhear to. For
1741 // example, for some widgets backgrounds or non-client areas may
1742 // not be painted.
1743 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1744 break;
1745
1746 case 2:
1747 // This one works much better, except for on XP. On Win2k nearly
1748 // all widgets and their children are captured correctly[**]. On
1749 // XP with Themes activated most native widgets draw only
1750 // partially, if at all. Without themes it works just like on
1751 // Win2k.
1752 //
1753 // ** For example the radio buttons in a wxRadioBox are not its
1754 // children by default, but you can capture it via the panel
1755 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1756 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1757 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1758 PRF_ERASEBKGND | PRF_OWNED );
1759 break;
1760
1761 case 3:
1762 // This one is only defined in the latest SDK and is only
1763 // available on XP. MSDN says it is similar to sending WM_PRINT
1764 // so I expect that it will work similar to the above. Since it
1765 // is avaialble only on XP, it can't be compiled like this and
1766 // will have to be loaded dynamically.
1767 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1768
1769 // fall through
1770
1771 case 4:
1772 // Use PrintWindow if available, or fallback to WM_PRINT
1773 // otherwise. Unfortunately using PrintWindow is even worse than
1774 // WM_PRINT. For most native widgets nothing is drawn to the dc
1775 // at all, with or without Themes.
1776 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1777 static bool s_triedToLoad = false;
1778 static PrintWindow_t pfnPrintWindow = NULL;
1779 if ( !s_triedToLoad )
1780 {
1781
1782 s_triedToLoad = true;
1783 wxDynamicLibrary dllUser32(_T("user32.dll"));
1784 if ( dllUser32.IsLoaded() )
1785 {
1786 wxLogNull nolog; // Don't report errors here
1787 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1788 }
1789 }
1790 if (pfnPrintWindow)
1791 {
1792 printf("Using PrintWindow\n");
1793 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1794 }
1795 else
1796 {
1797 printf("Using WM_PRINT\n");
1798 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1799 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN | PRF_ERASEBKGND | PRF_OWNED );
1800 }
1801 }
1802 #endif
1803 }
1804
1805
1806
1807 #include <wx/tipdlg.h>
1808
1809
1810 class wxPyTipProvider : public wxTipProvider {
1811 public:
1812 wxPyTipProvider(size_t currentTip)
1813 : wxTipProvider(currentTip) {}
1814
1815 DEC_PYCALLBACK_STRING__pure(GetTip);
1816 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1817 PYPRIVATE;
1818 };
1819
1820 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1821 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1822
1823
1824 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1825
1826 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1827
1828 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1829 : wxTimer(owner, id)
1830 {
1831 if (owner == NULL) SetOwner(this);
1832 }
1833
1834
1835 void wxPyTimer::Notify() {
1836 bool found;
1837 bool blocked = wxPyBeginBlockThreads();
1838 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1839 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1840 wxPyEndBlockThreads(blocked);
1841 if (! found)
1842 wxTimer::Notify();
1843 }
1844 void wxPyTimer::base_Notify() {
1845 wxTimer::Notify();
1846 }
1847
1848
1849
1850 SWIGINTERN PyObject *
1851 SWIG_FromCharPtr(const char* cptr)
1852 {
1853 if (cptr) {
1854 size_t size = strlen(cptr);
1855 if (size > INT_MAX) {
1856 return SWIG_NewPointerObj((char*)(cptr),
1857 SWIG_TypeQuery("char *"), 0);
1858 } else {
1859 if (size != 0) {
1860 return PyString_FromStringAndSize(cptr, size);
1861 } else {
1862 return PyString_FromString(cptr);
1863 }
1864 }
1865 }
1866 Py_INCREF(Py_None);
1867 return Py_None;
1868 }
1869
1870
1871 SWIGINTERNSHORT int
1872 SWIG_CheckUnsignedLongInRange(unsigned long value,
1873 unsigned long max_value,
1874 const char *errmsg)
1875 {
1876 if (value > max_value) {
1877 if (errmsg) {
1878 PyErr_Format(PyExc_OverflowError,
1879 "value %lu is greater than '%s' minimum %lu",
1880 value, errmsg, max_value);
1881 }
1882 return 0;
1883 }
1884 return 1;
1885 }
1886
1887
1888 #if UINT_MAX != ULONG_MAX
1889 SWIGINTERN int
1890 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1891 {
1892 const char* errmsg = val ? "unsigned int" : (char*)0;
1893 unsigned long v;
1894 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1895 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1896 if (val) *val = (unsigned int)(v);
1897 return 1;
1898 }
1899 } else {
1900 PyErr_Clear();
1901 }
1902 if (val) {
1903 SWIG_type_error(errmsg, obj);
1904 }
1905 return 0;
1906 }
1907 #else
1908 SWIGINTERNSHORT unsigned int
1909 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1910 {
1911 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1912 }
1913 #endif
1914
1915
1916 SWIGINTERNSHORT unsigned int
1917 SWIG_As_unsigned_SS_int(PyObject* obj)
1918 {
1919 unsigned int v;
1920 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1921 /*
1922 this is needed to make valgrind/purify happier.
1923 */
1924 memset((void*)&v, 0, sizeof(unsigned int));
1925 }
1926 return v;
1927 }
1928
1929
1930 SWIGINTERNSHORT int
1931 SWIG_Check_unsigned_SS_int(PyObject* obj)
1932 {
1933 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1934 }
1935
1936 static wxString Log_TimeStamp(){
1937 wxString msg;
1938 wxLog::TimeStamp(&msg);
1939 return msg;
1940 }
1941 static void wxLog_Destroy(wxLog *self){ delete self; }
1942 // Make somce wrappers that double any % signs so they are 'escaped'
1943 void wxPyLogFatalError(const wxString& msg)
1944 {
1945 wxString m(msg);
1946 m.Replace(wxT("%"), wxT("%%"));
1947 wxLogFatalError(m);
1948 }
1949
1950 void wxPyLogError(const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogError(m);
1955 }
1956
1957 void wxPyLogWarning(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogWarning(m);
1962 }
1963
1964 void wxPyLogMessage(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogMessage(m);
1969 }
1970
1971 void wxPyLogInfo(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogInfo(m);
1976 }
1977
1978 void wxPyLogDebug(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogDebug(m);
1983 }
1984
1985 void wxPyLogVerbose(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogVerbose(m);
1990 }
1991
1992 void wxPyLogStatus(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogStatus(m);
1997 }
1998
1999 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogStatus(pFrame, m);
2004 }
2005
2006 void wxPyLogSysError(const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogSysError(m);
2011 }
2012
2013 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogGeneric(level, m);
2018 }
2019
2020 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogTrace(mask, m);
2025 }
2026
2027 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogTrace(mask, m);
2032 }
2033
2034
2035
2036 // A wxLog class that can be derived from in wxPython
2037 class wxPyLog : public wxLog {
2038 public:
2039 wxPyLog() : wxLog() {}
2040
2041 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2042 bool found;
2043 bool blocked = wxPyBeginBlockThreads();
2044 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2045 PyObject* s = wx2PyString(szString);
2046 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2047 Py_DECREF(s);
2048 }
2049 wxPyEndBlockThreads(blocked);
2050 if (! found)
2051 wxLog::DoLog(level, szString, t);
2052 }
2053
2054 virtual void DoLogString(const wxChar *szString, time_t t) {
2055 bool found;
2056 bool blocked = wxPyBeginBlockThreads();
2057 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2058 PyObject* s = wx2PyString(szString);
2059 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2060 Py_DECREF(s);
2061 }
2062 wxPyEndBlockThreads(blocked);
2063 if (! found)
2064 wxLog::DoLogString(szString, t);
2065 }
2066
2067 PYPRIVATE;
2068 };
2069
2070
2071
2072
2073 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2074
2075
2076 #include <wx/joystick.h>
2077
2078
2079 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2080 // A C++ stub class for wxJoystick for platforms that don't have it.
2081 class wxJoystick : public wxObject {
2082 public:
2083 wxJoystick(int joystick = wxJOYSTICK1) {
2084 bool blocked = wxPyBeginBlockThreads();
2085 PyErr_SetString(PyExc_NotImplementedError,
2086 "wxJoystick is not available on this platform.");
2087 wxPyEndBlockThreads(blocked);
2088 }
2089 wxPoint GetPosition() { return wxPoint(-1,-1); }
2090 int GetZPosition() { return -1; }
2091 int GetButtonState() { return -1; }
2092 int GetPOVPosition() { return -1; }
2093 int GetPOVCTSPosition() { return -1; }
2094 int GetRudderPosition() { return -1; }
2095 int GetUPosition() { return -1; }
2096 int GetVPosition() { return -1; }
2097 int GetMovementThreshold() { return -1; }
2098 void SetMovementThreshold(int threshold) {}
2099
2100 bool IsOk(void) { return false; }
2101 int GetNumberJoysticks() { return -1; }
2102 int GetManufacturerId() { return -1; }
2103 int GetProductId() { return -1; }
2104 wxString GetProductName() { return wxEmptyString; }
2105 int GetXMin() { return -1; }
2106 int GetYMin() { return -1; }
2107 int GetZMin() { return -1; }
2108 int GetXMax() { return -1; }
2109 int GetYMax() { return -1; }
2110 int GetZMax() { return -1; }
2111 int GetNumberButtons() { return -1; }
2112 int GetNumberAxes() { return -1; }
2113 int GetMaxButtons() { return -1; }
2114 int GetMaxAxes() { return -1; }
2115 int GetPollingMin() { return -1; }
2116 int GetPollingMax() { return -1; }
2117 int GetRudderMin() { return -1; }
2118 int GetRudderMax() { return -1; }
2119 int GetUMin() { return -1; }
2120 int GetUMax() { return -1; }
2121 int GetVMin() { return -1; }
2122 int GetVMax() { return -1; }
2123
2124 bool HasRudder() { return false; }
2125 bool HasZ() { return false; }
2126 bool HasU() { return false; }
2127 bool HasV() { return false; }
2128 bool HasPOV() { return false; }
2129 bool HasPOV4Dir() { return false; }
2130 bool HasPOVCTS() { return false; }
2131
2132 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2133 bool ReleaseCapture() { return false; }
2134 };
2135 #endif
2136
2137
2138 #include <wx/sound.h>
2139
2140
2141 #if !wxUSE_SOUND
2142 // A C++ stub class for wxWave for platforms that don't have it.
2143 class wxSound : public wxObject
2144 {
2145 public:
2146 wxSound() {
2147 bool blocked = wxPyBeginBlockThreads();
2148 PyErr_SetString(PyExc_NotImplementedError,
2149 "wxSound is not available on this platform.");
2150 wxPyEndBlockThreads(blocked);
2151 }
2152 wxSound(const wxString&/*, bool*/) {
2153 bool blocked = wxPyBeginBlockThreads();
2154 PyErr_SetString(PyExc_NotImplementedError,
2155 "wxSound is not available on this platform.");
2156 wxPyEndBlockThreads(blocked);
2157 }
2158 wxSound(int, const wxByte*) {
2159 bool blocked = wxPyBeginBlockThreads();
2160 PyErr_SetString(PyExc_NotImplementedError,
2161 "wxSound is not available on this platform.");
2162 wxPyEndBlockThreads(blocked);
2163 }
2164
2165 ~wxSound() {};
2166
2167 bool Create(const wxString&/*, bool*/) { return false; }
2168 bool Create(int, const wxByte*) { return false; };
2169 bool IsOk() { return false; };
2170 bool Play(unsigned) const { return false; }
2171 static bool Play(const wxString&, unsigned) { return false; }
2172 static void Stop() {}
2173 };
2174
2175 #endif
2176
2177 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2178 if (fileName.Length() == 0)
2179 return new wxSound;
2180 else
2181 return new wxSound(fileName);
2182 }
2183 static wxSound *new_wxSound(PyObject *data){
2184 unsigned char* buffer; int size;
2185 wxSound *sound = NULL;
2186
2187 bool blocked = wxPyBeginBlockThreads();
2188 if (!PyArg_Parse(data, "t#", &buffer, &size))
2189 goto done;
2190 sound = new wxSound(size, buffer);
2191 done:
2192 wxPyEndBlockThreads(blocked);
2193 return sound;
2194 }
2195 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2196 #ifndef __WXMAC__
2197 unsigned char* buffer;
2198 int size;
2199 bool rv = false;
2200
2201 bool blocked = wxPyBeginBlockThreads();
2202 if (!PyArg_Parse(data, "t#", &buffer, &size))
2203 goto done;
2204 rv = self->Create(size, buffer);
2205 done:
2206 wxPyEndBlockThreads(blocked);
2207 return rv;
2208 #else
2209 bool blocked = wxPyBeginBlockThreads();
2210 PyErr_SetString(PyExc_NotImplementedError,
2211 "Create from data is not available on this platform.");
2212 wxPyEndBlockThreads(blocked);
2213 return false;
2214 #endif
2215 }
2216
2217 #include <wx/mimetype.h>
2218
2219 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2220 wxString str;
2221 if (self->GetMimeType(&str))
2222 return wx2PyString(str);
2223 else
2224 RETURN_NONE();
2225 }
2226 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2227 wxArrayString arr;
2228 if (self->GetMimeTypes(arr))
2229 return wxArrayString2PyList_helper(arr);
2230 else
2231 RETURN_NONE();
2232 }
2233 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2234 wxArrayString arr;
2235 if (self->GetExtensions(arr))
2236 return wxArrayString2PyList_helper(arr);
2237 else
2238 RETURN_NONE();
2239 }
2240 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2241 wxIconLocation loc;
2242 if (self->GetIcon(&loc))
2243 return new wxIcon(loc);
2244 else
2245 return NULL;
2246 }
2247 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2248 wxIconLocation loc;
2249 if (self->GetIcon(&loc)) {
2250 wxString iconFile = loc.GetFileName();
2251 int iconIndex = -1;
2252
2253 iconIndex = loc.GetIndex();
2254
2255 // Make a tuple and put the values in it
2256 bool blocked = wxPyBeginBlockThreads();
2257 PyObject* tuple = PyTuple_New(3);
2258 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2259 wxT("wxIcon"), true));
2260 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2261 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2262 wxPyEndBlockThreads(blocked);
2263 return tuple;
2264 }
2265 else
2266 RETURN_NONE();
2267 }
2268 static PyObject *wxFileType_GetDescription(wxFileType *self){
2269 wxString str;
2270 if (self->GetDescription(&str))
2271 return wx2PyString(str);
2272 else
2273 RETURN_NONE();
2274 }
2275 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2276 wxString str;
2277 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2278 return wx2PyString(str);
2279 else
2280 RETURN_NONE();
2281 }
2282 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2283 wxString str;
2284 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2285 return wx2PyString(str);
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2290 wxArrayString verbs;
2291 wxArrayString commands;
2292 if (self->GetAllCommands(&verbs, &commands,
2293 wxFileType::MessageParameters(filename, mimetype))) {
2294 bool blocked = wxPyBeginBlockThreads();
2295 PyObject* tuple = PyTuple_New(2);
2296 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2297 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2298 wxPyEndBlockThreads(blocked);
2299 return tuple;
2300 }
2301 else
2302 RETURN_NONE();
2303 }
2304 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2305 return wxFileType::ExpandCommand(command,
2306 wxFileType::MessageParameters(filename, mimetype));
2307 }
2308 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2309 wxArrayString arr;
2310 self->EnumAllFileTypes(arr);
2311 return wxArrayString2PyList_helper(arr);
2312 }
2313
2314 #include <wx/artprov.h>
2315
2316 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2317 static const wxString wxPyART_MENU(wxART_MENU);
2318 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2319 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2320 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2321 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2322 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2323 static const wxString wxPyART_OTHER(wxART_OTHER);
2324 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2325 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2326 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2327 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2328 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2329 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2330 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2331 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2332 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2333 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2334 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2335 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2336 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2337 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2338 static const wxString wxPyART_PRINT(wxART_PRINT);
2339 static const wxString wxPyART_HELP(wxART_HELP);
2340 static const wxString wxPyART_TIP(wxART_TIP);
2341 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2342 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2343 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2344 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2345 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2346 static const wxString wxPyART_CDROM(wxART_CDROM);
2347 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2348 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2349 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2350 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2351 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2352 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2353 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2354 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2355 static const wxString wxPyART_ERROR(wxART_ERROR);
2356 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2357 static const wxString wxPyART_WARNING(wxART_WARNING);
2358 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2359 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2360 // Python aware wxArtProvider
2361 class wxPyArtProvider : public wxArtProvider {
2362 public:
2363
2364 virtual wxBitmap CreateBitmap(const wxArtID& id,
2365 const wxArtClient& client,
2366 const wxSize& size) {
2367 wxBitmap rval = wxNullBitmap;
2368 bool blocked = wxPyBeginBlockThreads();
2369 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2370 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2371 PyObject* ro;
2372 wxBitmap* ptr;
2373 PyObject* s1, *s2;
2374 s1 = wx2PyString(id);
2375 s2 = wx2PyString(client);
2376 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2377 Py_DECREF(so);
2378 Py_DECREF(s1);
2379 Py_DECREF(s2);
2380 if (ro) {
2381 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2382 rval = *ptr;
2383 Py_DECREF(ro);
2384 }
2385 }
2386 wxPyEndBlockThreads(blocked);
2387 return rval;
2388 }
2389
2390 PYPRIVATE;
2391 };
2392
2393 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2394
2395
2396
2397 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2398 PyObject* ret = PyTuple_New(3);
2399 if (ret) {
2400 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2401 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2402 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2403 }
2404 return ret;
2405 }
2406
2407 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2408 bool cont;
2409 long index = 0;
2410 wxString value;
2411
2412 cont = self->GetFirstGroup(value, index);
2413 return __EnumerationHelper(cont, value, index);
2414 }
2415 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2416 bool cont;
2417 wxString value;
2418
2419 cont = self->GetNextGroup(value, index);
2420 return __EnumerationHelper(cont, value, index);
2421 }
2422 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2423 bool cont;
2424 long index = 0;
2425 wxString value;
2426
2427 cont = self->GetFirstEntry(value, index);
2428 return __EnumerationHelper(cont, value, index);
2429 }
2430 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2431 bool cont;
2432 wxString value;
2433
2434 cont = self->GetNextEntry(value, index);
2435 return __EnumerationHelper(cont, value, index);
2436 }
2437 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2438 long rv;
2439 self->Read(key, &rv, defaultVal);
2440 return rv;
2441 }
2442
2443 SWIGINTERN int
2444 SWIG_AsVal_double(PyObject *obj, double* val)
2445 {
2446 if (PyNumber_Check(obj)) {
2447 if (val) *val = PyFloat_AsDouble(obj);
2448 return 1;
2449 }
2450 else {
2451 SWIG_type_error("number", obj);
2452 }
2453 return 0;
2454 }
2455
2456
2457 SWIGINTERNSHORT double
2458 SWIG_As_double(PyObject* obj)
2459 {
2460 double v;
2461 if (!SWIG_AsVal_double(obj, &v)) {
2462 /*
2463 this is needed to make valgrind/purify happier.
2464 */
2465 memset((void*)&v, 0, sizeof(double));
2466 }
2467 return v;
2468 }
2469
2470
2471 SWIGINTERNSHORT int
2472 SWIG_Check_double(PyObject* obj)
2473 {
2474 return SWIG_AsVal_double(obj, (double*)0);
2475 }
2476
2477 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2478 double rv;
2479 self->Read(key, &rv, defaultVal);
2480 return rv;
2481 }
2482
2483 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2484 #define SWIG_From_double PyFloat_FromDouble
2485 /*@@*/
2486
2487 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2488 bool rv;
2489 self->Read(key, &rv, defaultVal);
2490 return rv;
2491 }
2492
2493 #include <wx/datetime.h>
2494
2495
2496 static const wxString wxPyDateFormatStr(wxT("%c"));
2497 static const wxString wxPyTimeSpanFormatStr(wxT("%H:%M:%S"));
2498
2499 #define LOCAL_TZ wxDateTime::Local
2500
2501
2502 #if UINT_MAX < LONG_MAX
2503 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2504 #define SWIG_From_unsigned_SS_int SWIG_From_long
2505 /*@@*/
2506 #else
2507 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2508 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2509 /*@@*/
2510 #endif
2511
2512 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2513 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2514 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2515 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2516 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2517 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2518 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2519 return (*self < *other);
2520 }
2521 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2522 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2523 return (*self <= *other);
2524 }
2525 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2526 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2527 return (*self > *other);
2528 }
2529 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2530 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2531 return (*self >= *other);
2532 }
2533 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2534 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2535 return (*self == *other);
2536 }
2537 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2538 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2539 return (*self != *other);
2540 }
2541 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2542 const wxChar* rv;
2543 const wxChar* _date = date;
2544 rv = self->ParseRfc822Date(_date);
2545 if (rv == NULL) return -1;
2546 return rv - _date;
2547 }
2548 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDateFormatStr,wxDateTime const &dateDef=wxDefaultDateTime){
2549 const wxChar* rv;
2550 const wxChar* _date = date;
2551 rv = self->ParseFormat(_date, format, dateDef);
2552 if (rv == NULL) return -1;
2553 return rv - _date;
2554 }
2555 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2556 const wxChar* rv;
2557 const wxChar* _datetime = datetime;
2558 rv = self->ParseDateTime(_datetime);
2559 if (rv == NULL) return -1;
2560 return rv - _datetime;
2561 }
2562 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2563 const wxChar* rv;
2564 const wxChar* _date = date;
2565 rv = self->ParseDate(_date);
2566 if (rv == NULL) return -1;
2567 return rv - _date;
2568 }
2569 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2570 const wxChar* rv;
2571 const wxChar* _time = time;
2572 rv = self->ParseTime(_time);
2573 if (rv == NULL) return -1;
2574 return rv - _time;
2575 }
2576 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2577 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2578 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2579 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2580 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2581 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2582 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2583 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2584 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2585 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2586 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2587 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2588 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2589 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2590 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2591 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2592
2593 #include <wx/dataobj.h>
2594
2595 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2596 size_t count = self->GetFormatCount(dir);
2597 wxDataFormat* formats = new wxDataFormat[count];
2598 self->GetAllFormats(formats, dir);
2599
2600 bool blocked = wxPyBeginBlockThreads();
2601 PyObject* list = PyList_New(count);
2602 for (size_t i=0; i<count; i++) {
2603 wxDataFormat* format = new wxDataFormat(formats[i]);
2604 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2605 PyList_Append(list, obj);
2606 Py_DECREF(obj);
2607 }
2608 wxPyEndBlockThreads(blocked);
2609 delete [] formats;
2610 return list;
2611 }
2612 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2613 PyObject* rval = NULL;
2614 size_t size = self->GetDataSize(format);
2615 bool blocked = wxPyBeginBlockThreads();
2616 if (size) {
2617 char* buf = new char[size];
2618 if (self->GetDataHere(format, buf))
2619 rval = PyString_FromStringAndSize(buf, size);
2620 delete [] buf;
2621 }
2622 if (! rval) {
2623 rval = Py_None;
2624 Py_INCREF(rval);
2625 }
2626 wxPyEndBlockThreads(blocked);
2627 return rval;
2628 }
2629 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2630 bool rval;
2631 bool blocked = wxPyBeginBlockThreads();
2632 if (PyString_Check(data)) {
2633 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2634 }
2635 else {
2636 // raise a TypeError if not a string
2637 PyErr_SetString(PyExc_TypeError, "String expected.");
2638 rval = false;
2639 }
2640 wxPyEndBlockThreads(blocked);
2641 return rval;
2642 }
2643 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2644 PyObject* rval = NULL;
2645 size_t size = self->GetDataSize();
2646 bool blocked = wxPyBeginBlockThreads();
2647 if (size) {
2648 char* buf = new char[size];
2649 if (self->GetDataHere(buf))
2650 rval = PyString_FromStringAndSize(buf, size);
2651 delete [] buf;
2652 }
2653 if (! rval) {
2654 rval = Py_None;
2655 Py_INCREF(rval);
2656 }
2657 wxPyEndBlockThreads(blocked);
2658 return rval;
2659 }
2660 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2661 bool rval;
2662 bool blocked = wxPyBeginBlockThreads();
2663 if (PyString_Check(data)) {
2664 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2665 }
2666 else {
2667 // raise a TypeError if not a string
2668 PyErr_SetString(PyExc_TypeError, "String expected.");
2669 rval = false;
2670 }
2671 wxPyEndBlockThreads(blocked);
2672 return rval;
2673 }
2674 // Create a new class for wxPython to use
2675 class wxPyDataObjectSimple : public wxDataObjectSimple {
2676 public:
2677 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2678 : wxDataObjectSimple(format) {}
2679
2680 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2681 bool GetDataHere(void *buf) const;
2682 bool SetData(size_t len, const void *buf) const;
2683 PYPRIVATE;
2684 };
2685
2686 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2687
2688 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2689 // We need to get the data for this object and write it to buf. I think
2690 // the best way to do this for wxPython is to have the Python method
2691 // return either a string or None and then act appropriately with the
2692 // C++ version.
2693
2694 bool rval = false;
2695 bool blocked = wxPyBeginBlockThreads();
2696 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2697 PyObject* ro;
2698 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2699 if (ro) {
2700 rval = (ro != Py_None && PyString_Check(ro));
2701 if (rval)
2702 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2703 Py_DECREF(ro);
2704 }
2705 }
2706 wxPyEndBlockThreads(blocked);
2707 return rval;
2708 }
2709
2710 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2711 // For this one we simply need to make a string from buf and len
2712 // and send it to the Python method.
2713 bool rval = false;
2714 bool blocked = wxPyBeginBlockThreads();
2715 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2716 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2717 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2718 Py_DECREF(data);
2719 }
2720 wxPyEndBlockThreads(blocked);
2721 return rval;
2722 }
2723
2724 // Create a new class for wxPython to use
2725 class wxPyTextDataObject : public wxTextDataObject {
2726 public:
2727 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2728 : wxTextDataObject(text) {}
2729
2730 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2731 DEC_PYCALLBACK_STRING__const(GetText);
2732 DEC_PYCALLBACK__STRING(SetText);
2733 PYPRIVATE;
2734 };
2735
2736 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2737 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2738 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2739
2740
2741 // Create a new class for wxPython to use
2742 class wxPyBitmapDataObject : public wxBitmapDataObject {
2743 public:
2744 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2745 : wxBitmapDataObject(bitmap) {}
2746
2747 wxBitmap GetBitmap() const;
2748 void SetBitmap(const wxBitmap& bitmap);
2749 PYPRIVATE;
2750 };
2751
2752 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2753 wxBitmap* rval = &wxNullBitmap;
2754 bool blocked = wxPyBeginBlockThreads();
2755 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2756 PyObject* ro;
2757 wxBitmap* ptr;
2758 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2759 if (ro) {
2760 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2761 rval = ptr;
2762 Py_DECREF(ro);
2763 }
2764 }
2765 wxPyEndBlockThreads(blocked);
2766 return *rval;
2767 }
2768
2769 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2770 bool blocked = wxPyBeginBlockThreads();
2771 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2772 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2773 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2774 Py_DECREF(bo);
2775 }
2776 wxPyEndBlockThreads(blocked);
2777 }
2778
2779 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2780 bool rval;
2781 bool blocked = wxPyBeginBlockThreads();
2782 if (PyString_Check(data)) {
2783 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2784 }
2785 else {
2786 // raise a TypeError if not a string
2787 PyErr_SetString(PyExc_TypeError, "String expected.");
2788 rval = false;
2789 }
2790 wxPyEndBlockThreads(blocked);
2791 return rval;
2792 }
2793 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2794 PyObject* obj;
2795 bool blocked = wxPyBeginBlockThreads();
2796 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2797 wxPyEndBlockThreads(blocked);
2798 return obj;
2799 }
2800
2801 #include <wx/metafile.h>
2802
2803
2804 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2805
2806
2807 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2808 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2809 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2810 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2811 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2812
2813
2814 class wxPyTextDropTarget : public wxTextDropTarget {
2815 public:
2816 wxPyTextDropTarget() {}
2817
2818 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2819
2820 DEC_PYCALLBACK__(OnLeave);
2821 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2822 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2823 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2824 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2825
2826 PYPRIVATE;
2827 };
2828
2829 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2830 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2831 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2832 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2833 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2834 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2835
2836
2837
2838 class wxPyFileDropTarget : public wxFileDropTarget {
2839 public:
2840 wxPyFileDropTarget() {}
2841
2842 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2843
2844 DEC_PYCALLBACK__(OnLeave);
2845 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2846 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2847 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2848 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2849
2850 PYPRIVATE;
2851 };
2852
2853 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2854 const wxArrayString& filenames) {
2855 bool rval = false;
2856 bool blocked = wxPyBeginBlockThreads();
2857 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2858 PyObject* list = wxArrayString2PyList_helper(filenames);
2859 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2860 Py_DECREF(list);
2861 }
2862 wxPyEndBlockThreads(blocked);
2863 return rval;
2864 }
2865
2866
2867
2868 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2869 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2870 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2871 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2872 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2873
2874
2875
2876
2877 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2878
2879 #include <wx/display.h>
2880
2881 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2882 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2883
2884 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2885 #if !wxUSE_DISPLAY
2886 #include <wx/dynarray.h>
2887 #include <wx/vidmode.h>
2888
2889 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2890 #include "wx/arrimpl.cpp"
2891 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2892 const wxVideoMode wxDefaultVideoMode;
2893
2894 class wxDisplay
2895 {
2896 public:
2897 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2898 ~wxDisplay() {}
2899
2900 static size_t GetCount()
2901 { wxPyRaiseNotImplemented(); return 0; }
2902
2903 static int GetFromPoint(const wxPoint& pt)
2904 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2905 static int GetFromWindow(wxWindow *window)
2906 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2907
2908 virtual bool IsOk() const { return false; }
2909 virtual wxRect GetGeometry() const { wxRect r; return r; }
2910 virtual wxString GetName() const { return wxEmptyString; }
2911 bool IsPrimary() const { return false; }
2912
2913 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2914 { wxArrayVideoModes a; return a; }
2915
2916 virtual wxVideoMode GetCurrentMode() const
2917 { return wxDefaultVideoMode; }
2918
2919 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2920 { return false; }
2921
2922 void ResetMode() {}
2923 };
2924 #endif
2925
2926 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2927 PyObject* pyList = NULL;
2928 wxArrayVideoModes arr = self->GetModes(mode);
2929 bool blocked = wxPyBeginBlockThreads();
2930 pyList = PyList_New(0);
2931 for (int i=0; i < arr.GetCount(); i++) {
2932 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2933 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2934 PyList_Append(pyList, pyObj);
2935 Py_DECREF(pyObj);
2936 }
2937 wxPyEndBlockThreads(blocked);
2938 return pyList;
2939 }
2940
2941 #include <wx/stdpaths.h>
2942
2943 static wxStandardPaths *StandardPaths_Get(){
2944 return (wxStandardPaths*) &wxStandardPaths::Get();
2945 }
2946 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2947 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2948 #ifdef __cplusplus
2949 extern "C" {
2950 #endif
2951 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2952 PyObject *resultobj;
2953 wxSystemColour arg1 ;
2954 wxColour result;
2955 PyObject * obj0 = 0 ;
2956 char *kwnames[] = {
2957 (char *) "index", NULL
2958 };
2959
2960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2961 {
2962 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2963 if (SWIG_arg_fail(1)) SWIG_fail;
2964 }
2965 {
2966 if (!wxPyCheckForApp()) SWIG_fail;
2967 PyThreadState* __tstate = wxPyBeginAllowThreads();
2968 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2969
2970 wxPyEndAllowThreads(__tstate);
2971 if (PyErr_Occurred()) SWIG_fail;
2972 }
2973 {
2974 wxColour * resultptr;
2975 resultptr = new wxColour((wxColour &)(result));
2976 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2977 }
2978 return resultobj;
2979 fail:
2980 return NULL;
2981 }
2982
2983
2984 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2985 PyObject *resultobj;
2986 wxSystemFont arg1 ;
2987 wxFont result;
2988 PyObject * obj0 = 0 ;
2989 char *kwnames[] = {
2990 (char *) "index", NULL
2991 };
2992
2993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2994 {
2995 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2996 if (SWIG_arg_fail(1)) SWIG_fail;
2997 }
2998 {
2999 if (!wxPyCheckForApp()) SWIG_fail;
3000 PyThreadState* __tstate = wxPyBeginAllowThreads();
3001 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3002
3003 wxPyEndAllowThreads(__tstate);
3004 if (PyErr_Occurred()) SWIG_fail;
3005 }
3006 {
3007 wxFont * resultptr;
3008 resultptr = new wxFont((wxFont &)(result));
3009 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3010 }
3011 return resultobj;
3012 fail:
3013 return NULL;
3014 }
3015
3016
3017 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3018 PyObject *resultobj;
3019 wxSystemMetric arg1 ;
3020 int result;
3021 PyObject * obj0 = 0 ;
3022 char *kwnames[] = {
3023 (char *) "index", NULL
3024 };
3025
3026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3027 {
3028 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3029 if (SWIG_arg_fail(1)) SWIG_fail;
3030 }
3031 {
3032 if (!wxPyCheckForApp()) SWIG_fail;
3033 PyThreadState* __tstate = wxPyBeginAllowThreads();
3034 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3035
3036 wxPyEndAllowThreads(__tstate);
3037 if (PyErr_Occurred()) SWIG_fail;
3038 }
3039 {
3040 resultobj = SWIG_From_int((int)(result));
3041 }
3042 return resultobj;
3043 fail:
3044 return NULL;
3045 }
3046
3047
3048 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3049 PyObject *resultobj;
3050 wxSystemFeature arg1 ;
3051 bool result;
3052 PyObject * obj0 = 0 ;
3053 char *kwnames[] = {
3054 (char *) "index", NULL
3055 };
3056
3057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3058 {
3059 arg1 = (wxSystemFeature)(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 = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3066
3067 wxPyEndAllowThreads(__tstate);
3068 if (PyErr_Occurred()) SWIG_fail;
3069 }
3070 {
3071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3072 }
3073 return resultobj;
3074 fail:
3075 return NULL;
3076 }
3077
3078
3079 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3080 PyObject *resultobj;
3081 wxSystemScreenType result;
3082 char *kwnames[] = {
3083 NULL
3084 };
3085
3086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3087 {
3088 if (!wxPyCheckForApp()) SWIG_fail;
3089 PyThreadState* __tstate = wxPyBeginAllowThreads();
3090 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3091
3092 wxPyEndAllowThreads(__tstate);
3093 if (PyErr_Occurred()) SWIG_fail;
3094 }
3095 resultobj = SWIG_From_int((result));
3096 return resultobj;
3097 fail:
3098 return NULL;
3099 }
3100
3101
3102 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3103 PyObject *resultobj;
3104 wxSystemScreenType arg1 ;
3105 PyObject * obj0 = 0 ;
3106 char *kwnames[] = {
3107 (char *) "screen", NULL
3108 };
3109
3110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3111 {
3112 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3113 if (SWIG_arg_fail(1)) SWIG_fail;
3114 }
3115 {
3116 if (!wxPyCheckForApp()) SWIG_fail;
3117 PyThreadState* __tstate = wxPyBeginAllowThreads();
3118 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3119
3120 wxPyEndAllowThreads(__tstate);
3121 if (PyErr_Occurred()) SWIG_fail;
3122 }
3123 Py_INCREF(Py_None); resultobj = Py_None;
3124 return resultobj;
3125 fail:
3126 return NULL;
3127 }
3128
3129
3130 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3131 PyObject *obj;
3132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3133 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3134 Py_INCREF(obj);
3135 return Py_BuildValue((char *)"");
3136 }
3137 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3138 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3139 return 1;
3140 }
3141
3142
3143 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3144 PyObject *pyobj;
3145
3146 {
3147 #if wxUSE_UNICODE
3148 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3149 #else
3150 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3151 #endif
3152 }
3153 return pyobj;
3154 }
3155
3156
3157 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3158 PyObject *resultobj;
3159 wxSystemOptions *result;
3160 char *kwnames[] = {
3161 NULL
3162 };
3163
3164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3165 {
3166 PyThreadState* __tstate = wxPyBeginAllowThreads();
3167 result = (wxSystemOptions *)new wxSystemOptions();
3168
3169 wxPyEndAllowThreads(__tstate);
3170 if (PyErr_Occurred()) SWIG_fail;
3171 }
3172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3173 return resultobj;
3174 fail:
3175 return NULL;
3176 }
3177
3178
3179 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3180 PyObject *resultobj;
3181 wxString *arg1 = 0 ;
3182 wxString *arg2 = 0 ;
3183 bool temp1 = false ;
3184 bool temp2 = false ;
3185 PyObject * obj0 = 0 ;
3186 PyObject * obj1 = 0 ;
3187 char *kwnames[] = {
3188 (char *) "name",(char *) "value", NULL
3189 };
3190
3191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3192 {
3193 arg1 = wxString_in_helper(obj0);
3194 if (arg1 == NULL) SWIG_fail;
3195 temp1 = true;
3196 }
3197 {
3198 arg2 = wxString_in_helper(obj1);
3199 if (arg2 == NULL) SWIG_fail;
3200 temp2 = true;
3201 }
3202 {
3203 PyThreadState* __tstate = wxPyBeginAllowThreads();
3204 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3205
3206 wxPyEndAllowThreads(__tstate);
3207 if (PyErr_Occurred()) SWIG_fail;
3208 }
3209 Py_INCREF(Py_None); resultobj = Py_None;
3210 {
3211 if (temp1)
3212 delete arg1;
3213 }
3214 {
3215 if (temp2)
3216 delete arg2;
3217 }
3218 return resultobj;
3219 fail:
3220 {
3221 if (temp1)
3222 delete arg1;
3223 }
3224 {
3225 if (temp2)
3226 delete arg2;
3227 }
3228 return NULL;
3229 }
3230
3231
3232 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3233 PyObject *resultobj;
3234 wxString *arg1 = 0 ;
3235 int arg2 ;
3236 bool temp1 = false ;
3237 PyObject * obj0 = 0 ;
3238 PyObject * obj1 = 0 ;
3239 char *kwnames[] = {
3240 (char *) "name",(char *) "value", NULL
3241 };
3242
3243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3244 {
3245 arg1 = wxString_in_helper(obj0);
3246 if (arg1 == NULL) SWIG_fail;
3247 temp1 = true;
3248 }
3249 {
3250 arg2 = (int)(SWIG_As_int(obj1));
3251 if (SWIG_arg_fail(2)) SWIG_fail;
3252 }
3253 {
3254 PyThreadState* __tstate = wxPyBeginAllowThreads();
3255 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3256
3257 wxPyEndAllowThreads(__tstate);
3258 if (PyErr_Occurred()) SWIG_fail;
3259 }
3260 Py_INCREF(Py_None); resultobj = Py_None;
3261 {
3262 if (temp1)
3263 delete arg1;
3264 }
3265 return resultobj;
3266 fail:
3267 {
3268 if (temp1)
3269 delete arg1;
3270 }
3271 return NULL;
3272 }
3273
3274
3275 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3276 PyObject *resultobj;
3277 wxString *arg1 = 0 ;
3278 wxString result;
3279 bool temp1 = false ;
3280 PyObject * obj0 = 0 ;
3281 char *kwnames[] = {
3282 (char *) "name", NULL
3283 };
3284
3285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3286 {
3287 arg1 = wxString_in_helper(obj0);
3288 if (arg1 == NULL) SWIG_fail;
3289 temp1 = true;
3290 }
3291 {
3292 PyThreadState* __tstate = wxPyBeginAllowThreads();
3293 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3294
3295 wxPyEndAllowThreads(__tstate);
3296 if (PyErr_Occurred()) SWIG_fail;
3297 }
3298 {
3299 #if wxUSE_UNICODE
3300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3301 #else
3302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3303 #endif
3304 }
3305 {
3306 if (temp1)
3307 delete arg1;
3308 }
3309 return resultobj;
3310 fail:
3311 {
3312 if (temp1)
3313 delete arg1;
3314 }
3315 return NULL;
3316 }
3317
3318
3319 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3320 PyObject *resultobj;
3321 wxString *arg1 = 0 ;
3322 int result;
3323 bool temp1 = false ;
3324 PyObject * obj0 = 0 ;
3325 char *kwnames[] = {
3326 (char *) "name", NULL
3327 };
3328
3329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3330 {
3331 arg1 = wxString_in_helper(obj0);
3332 if (arg1 == NULL) SWIG_fail;
3333 temp1 = true;
3334 }
3335 {
3336 PyThreadState* __tstate = wxPyBeginAllowThreads();
3337 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3338
3339 wxPyEndAllowThreads(__tstate);
3340 if (PyErr_Occurred()) SWIG_fail;
3341 }
3342 {
3343 resultobj = SWIG_From_int((int)(result));
3344 }
3345 {
3346 if (temp1)
3347 delete arg1;
3348 }
3349 return resultobj;
3350 fail:
3351 {
3352 if (temp1)
3353 delete arg1;
3354 }
3355 return NULL;
3356 }
3357
3358
3359 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3360 PyObject *resultobj;
3361 wxString *arg1 = 0 ;
3362 bool result;
3363 bool temp1 = false ;
3364 PyObject * obj0 = 0 ;
3365 char *kwnames[] = {
3366 (char *) "name", NULL
3367 };
3368
3369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3370 {
3371 arg1 = wxString_in_helper(obj0);
3372 if (arg1 == NULL) SWIG_fail;
3373 temp1 = true;
3374 }
3375 {
3376 PyThreadState* __tstate = wxPyBeginAllowThreads();
3377 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3378
3379 wxPyEndAllowThreads(__tstate);
3380 if (PyErr_Occurred()) SWIG_fail;
3381 }
3382 {
3383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3384 }
3385 {
3386 if (temp1)
3387 delete arg1;
3388 }
3389 return resultobj;
3390 fail:
3391 {
3392 if (temp1)
3393 delete arg1;
3394 }
3395 return NULL;
3396 }
3397
3398
3399 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3400 PyObject *obj;
3401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3402 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3403 Py_INCREF(obj);
3404 return Py_BuildValue((char *)"");
3405 }
3406 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3407 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3408 return 1;
3409 }
3410
3411
3412 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3413 PyObject *pyobj;
3414
3415 {
3416 #if wxUSE_UNICODE
3417 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3418 #else
3419 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3420 #endif
3421 }
3422 return pyobj;
3423 }
3424
3425
3426 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3427 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3428 return 1;
3429 }
3430
3431
3432 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3433 PyObject *pyobj;
3434
3435 {
3436 #if wxUSE_UNICODE
3437 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3438 #else
3439 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3440 #endif
3441 }
3442 return pyobj;
3443 }
3444
3445
3446 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3447 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3448 return 1;
3449 }
3450
3451
3452 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3453 PyObject *pyobj;
3454
3455 {
3456 #if wxUSE_UNICODE
3457 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3458 #else
3459 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3460 #endif
3461 }
3462 return pyobj;
3463 }
3464
3465
3466 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3467 PyObject *resultobj;
3468 long result;
3469 char *kwnames[] = {
3470 NULL
3471 };
3472
3473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3474 {
3475 PyThreadState* __tstate = wxPyBeginAllowThreads();
3476 result = (long)wxNewId();
3477
3478 wxPyEndAllowThreads(__tstate);
3479 if (PyErr_Occurred()) SWIG_fail;
3480 }
3481 {
3482 resultobj = SWIG_From_long((long)(result));
3483 }
3484 return resultobj;
3485 fail:
3486 return NULL;
3487 }
3488
3489
3490 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3491 PyObject *resultobj;
3492 long arg1 ;
3493 PyObject * obj0 = 0 ;
3494 char *kwnames[] = {
3495 (char *) "id", NULL
3496 };
3497
3498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3499 {
3500 arg1 = (long)(SWIG_As_long(obj0));
3501 if (SWIG_arg_fail(1)) SWIG_fail;
3502 }
3503 {
3504 PyThreadState* __tstate = wxPyBeginAllowThreads();
3505 wxRegisterId(arg1);
3506
3507 wxPyEndAllowThreads(__tstate);
3508 if (PyErr_Occurred()) SWIG_fail;
3509 }
3510 Py_INCREF(Py_None); resultobj = Py_None;
3511 return resultobj;
3512 fail:
3513 return NULL;
3514 }
3515
3516
3517 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3518 PyObject *resultobj;
3519 long result;
3520 char *kwnames[] = {
3521 NULL
3522 };
3523
3524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3525 {
3526 PyThreadState* __tstate = wxPyBeginAllowThreads();
3527 result = (long)wxGetCurrentId();
3528
3529 wxPyEndAllowThreads(__tstate);
3530 if (PyErr_Occurred()) SWIG_fail;
3531 }
3532 {
3533 resultobj = SWIG_From_long((long)(result));
3534 }
3535 return resultobj;
3536 fail:
3537 return NULL;
3538 }
3539
3540
3541 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3542 PyObject *resultobj;
3543 int arg1 ;
3544 bool result;
3545 PyObject * obj0 = 0 ;
3546 char *kwnames[] = {
3547 (char *) "id", NULL
3548 };
3549
3550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3551 {
3552 arg1 = (int)(SWIG_As_int(obj0));
3553 if (SWIG_arg_fail(1)) SWIG_fail;
3554 }
3555 {
3556 PyThreadState* __tstate = wxPyBeginAllowThreads();
3557 result = (bool)wxIsStockID(arg1);
3558
3559 wxPyEndAllowThreads(__tstate);
3560 if (PyErr_Occurred()) SWIG_fail;
3561 }
3562 {
3563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3564 }
3565 return resultobj;
3566 fail:
3567 return NULL;
3568 }
3569
3570
3571 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3572 PyObject *resultobj;
3573 int arg1 ;
3574 wxString *arg2 = 0 ;
3575 bool result;
3576 bool temp2 = false ;
3577 PyObject * obj0 = 0 ;
3578 PyObject * obj1 = 0 ;
3579 char *kwnames[] = {
3580 (char *) "id",(char *) "label", NULL
3581 };
3582
3583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3584 {
3585 arg1 = (int)(SWIG_As_int(obj0));
3586 if (SWIG_arg_fail(1)) SWIG_fail;
3587 }
3588 {
3589 arg2 = wxString_in_helper(obj1);
3590 if (arg2 == NULL) SWIG_fail;
3591 temp2 = true;
3592 }
3593 {
3594 PyThreadState* __tstate = wxPyBeginAllowThreads();
3595 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3596
3597 wxPyEndAllowThreads(__tstate);
3598 if (PyErr_Occurred()) SWIG_fail;
3599 }
3600 {
3601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3602 }
3603 {
3604 if (temp2)
3605 delete arg2;
3606 }
3607 return resultobj;
3608 fail:
3609 {
3610 if (temp2)
3611 delete arg2;
3612 }
3613 return NULL;
3614 }
3615
3616
3617 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3618 PyObject *resultobj;
3619 int arg1 ;
3620 wxString result;
3621 PyObject * obj0 = 0 ;
3622 char *kwnames[] = {
3623 (char *) "id", NULL
3624 };
3625
3626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetStockLabel",kwnames,&obj0)) goto fail;
3627 {
3628 arg1 = (int)(SWIG_As_int(obj0));
3629 if (SWIG_arg_fail(1)) SWIG_fail;
3630 }
3631 {
3632 PyThreadState* __tstate = wxPyBeginAllowThreads();
3633 result = wxGetStockLabel(arg1);
3634
3635 wxPyEndAllowThreads(__tstate);
3636 if (PyErr_Occurred()) SWIG_fail;
3637 }
3638 {
3639 #if wxUSE_UNICODE
3640 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3641 #else
3642 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3643 #endif
3644 }
3645 return resultobj;
3646 fail:
3647 return NULL;
3648 }
3649
3650
3651 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3652 PyObject *resultobj;
3653 char *kwnames[] = {
3654 NULL
3655 };
3656
3657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3658 {
3659 if (!wxPyCheckForApp()) SWIG_fail;
3660 PyThreadState* __tstate = wxPyBeginAllowThreads();
3661 wxBell();
3662
3663 wxPyEndAllowThreads(__tstate);
3664 if (PyErr_Occurred()) SWIG_fail;
3665 }
3666 Py_INCREF(Py_None); resultobj = Py_None;
3667 return resultobj;
3668 fail:
3669 return NULL;
3670 }
3671
3672
3673 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3674 PyObject *resultobj;
3675 char *kwnames[] = {
3676 NULL
3677 };
3678
3679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3680 {
3681 if (!wxPyCheckForApp()) SWIG_fail;
3682 PyThreadState* __tstate = wxPyBeginAllowThreads();
3683 wxEndBusyCursor();
3684
3685 wxPyEndAllowThreads(__tstate);
3686 if (PyErr_Occurred()) SWIG_fail;
3687 }
3688 Py_INCREF(Py_None); resultobj = Py_None;
3689 return resultobj;
3690 fail:
3691 return NULL;
3692 }
3693
3694
3695 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3696 PyObject *resultobj;
3697 bool arg1 = (bool) true ;
3698 long result;
3699 PyObject * obj0 = 0 ;
3700 char *kwnames[] = {
3701 (char *) "resetTimer", NULL
3702 };
3703
3704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3705 if (obj0) {
3706 {
3707 arg1 = (bool)(SWIG_As_bool(obj0));
3708 if (SWIG_arg_fail(1)) SWIG_fail;
3709 }
3710 }
3711 {
3712 PyThreadState* __tstate = wxPyBeginAllowThreads();
3713 result = (long)wxGetElapsedTime(arg1);
3714
3715 wxPyEndAllowThreads(__tstate);
3716 if (PyErr_Occurred()) SWIG_fail;
3717 }
3718 {
3719 resultobj = SWIG_From_long((long)(result));
3720 }
3721 return resultobj;
3722 fail:
3723 return NULL;
3724 }
3725
3726
3727 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3728 PyObject *resultobj;
3729 int *arg1 = (int *) 0 ;
3730 int *arg2 = (int *) 0 ;
3731 int temp1 ;
3732 int res1 = 0 ;
3733 int temp2 ;
3734 int res2 = 0 ;
3735 char *kwnames[] = {
3736 NULL
3737 };
3738
3739 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3740 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3742 {
3743 if (!wxPyCheckForApp()) SWIG_fail;
3744 PyThreadState* __tstate = wxPyBeginAllowThreads();
3745 wxGetMousePosition(arg1,arg2);
3746
3747 wxPyEndAllowThreads(__tstate);
3748 if (PyErr_Occurred()) SWIG_fail;
3749 }
3750 Py_INCREF(Py_None); resultobj = Py_None;
3751 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3752 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3753 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3754 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3755 return resultobj;
3756 fail:
3757 return NULL;
3758 }
3759
3760
3761 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3762 PyObject *resultobj;
3763 bool result;
3764 char *kwnames[] = {
3765 NULL
3766 };
3767
3768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3769 {
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 result = (bool)wxIsBusy();
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 {
3777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3778 }
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
3785 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj;
3787 wxString result;
3788 char *kwnames[] = {
3789 NULL
3790 };
3791
3792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3793 {
3794 PyThreadState* __tstate = wxPyBeginAllowThreads();
3795 result = wxNow();
3796
3797 wxPyEndAllowThreads(__tstate);
3798 if (PyErr_Occurred()) SWIG_fail;
3799 }
3800 {
3801 #if wxUSE_UNICODE
3802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3803 #else
3804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3805 #endif
3806 }
3807 return resultobj;
3808 fail:
3809 return NULL;
3810 }
3811
3812
3813 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3814 PyObject *resultobj;
3815 wxString const &arg1_defvalue = wxPyEmptyString ;
3816 wxString *arg1 = (wxString *) &arg1_defvalue ;
3817 bool result;
3818 bool temp1 = false ;
3819 PyObject * obj0 = 0 ;
3820 char *kwnames[] = {
3821 (char *) "command", NULL
3822 };
3823
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3825 if (obj0) {
3826 {
3827 arg1 = wxString_in_helper(obj0);
3828 if (arg1 == NULL) SWIG_fail;
3829 temp1 = true;
3830 }
3831 }
3832 {
3833 PyThreadState* __tstate = wxPyBeginAllowThreads();
3834 result = (bool)wxShell((wxString const &)*arg1);
3835
3836 wxPyEndAllowThreads(__tstate);
3837 if (PyErr_Occurred()) SWIG_fail;
3838 }
3839 {
3840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3841 }
3842 {
3843 if (temp1)
3844 delete arg1;
3845 }
3846 return resultobj;
3847 fail:
3848 {
3849 if (temp1)
3850 delete arg1;
3851 }
3852 return NULL;
3853 }
3854
3855
3856 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3857 PyObject *resultobj;
3858 char *kwnames[] = {
3859 NULL
3860 };
3861
3862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3863 {
3864 PyThreadState* __tstate = wxPyBeginAllowThreads();
3865 wxStartTimer();
3866
3867 wxPyEndAllowThreads(__tstate);
3868 if (PyErr_Occurred()) SWIG_fail;
3869 }
3870 Py_INCREF(Py_None); resultobj = Py_None;
3871 return resultobj;
3872 fail:
3873 return NULL;
3874 }
3875
3876
3877 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3878 PyObject *resultobj;
3879 int *arg1 = (int *) 0 ;
3880 int *arg2 = (int *) 0 ;
3881 int result;
3882 int temp1 ;
3883 int res1 = 0 ;
3884 int temp2 ;
3885 int res2 = 0 ;
3886 char *kwnames[] = {
3887 NULL
3888 };
3889
3890 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3891 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3893 {
3894 PyThreadState* __tstate = wxPyBeginAllowThreads();
3895 result = (int)wxGetOsVersion(arg1,arg2);
3896
3897 wxPyEndAllowThreads(__tstate);
3898 if (PyErr_Occurred()) SWIG_fail;
3899 }
3900 {
3901 resultobj = SWIG_From_int((int)(result));
3902 }
3903 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3904 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3905 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3906 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3907 return resultobj;
3908 fail:
3909 return NULL;
3910 }
3911
3912
3913 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3914 PyObject *resultobj;
3915 wxString result;
3916 char *kwnames[] = {
3917 NULL
3918 };
3919
3920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3921 {
3922 PyThreadState* __tstate = wxPyBeginAllowThreads();
3923 result = wxGetOsDescription();
3924
3925 wxPyEndAllowThreads(__tstate);
3926 if (PyErr_Occurred()) SWIG_fail;
3927 }
3928 {
3929 #if wxUSE_UNICODE
3930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3931 #else
3932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3933 #endif
3934 }
3935 return resultobj;
3936 fail:
3937 return NULL;
3938 }
3939
3940
3941 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3942 PyObject *resultobj;
3943 long result;
3944 char *kwnames[] = {
3945 NULL
3946 };
3947
3948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3949 {
3950 PyThreadState* __tstate = wxPyBeginAllowThreads();
3951 result = (long)wxGetFreeMemory();
3952
3953 wxPyEndAllowThreads(__tstate);
3954 if (PyErr_Occurred()) SWIG_fail;
3955 }
3956 {
3957 resultobj = SWIG_From_long((long)(result));
3958 }
3959 return resultobj;
3960 fail:
3961 return NULL;
3962 }
3963
3964
3965 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3966 PyObject *resultobj;
3967 wxShutdownFlags arg1 ;
3968 bool result;
3969 PyObject * obj0 = 0 ;
3970 char *kwnames[] = {
3971 (char *) "wFlags", NULL
3972 };
3973
3974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3975 {
3976 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3977 if (SWIG_arg_fail(1)) SWIG_fail;
3978 }
3979 {
3980 if (!wxPyCheckForApp()) SWIG_fail;
3981 PyThreadState* __tstate = wxPyBeginAllowThreads();
3982 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3983
3984 wxPyEndAllowThreads(__tstate);
3985 if (PyErr_Occurred()) SWIG_fail;
3986 }
3987 {
3988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3989 }
3990 return resultobj;
3991 fail:
3992 return NULL;
3993 }
3994
3995
3996 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3997 PyObject *resultobj;
3998 int arg1 ;
3999 PyObject * obj0 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "secs", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4005 {
4006 arg1 = (int)(SWIG_As_int(obj0));
4007 if (SWIG_arg_fail(1)) SWIG_fail;
4008 }
4009 {
4010 PyThreadState* __tstate = wxPyBeginAllowThreads();
4011 wxSleep(arg1);
4012
4013 wxPyEndAllowThreads(__tstate);
4014 if (PyErr_Occurred()) SWIG_fail;
4015 }
4016 Py_INCREF(Py_None); resultobj = Py_None;
4017 return resultobj;
4018 fail:
4019 return NULL;
4020 }
4021
4022
4023 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4024 PyObject *resultobj;
4025 unsigned long arg1 ;
4026 PyObject * obj0 = 0 ;
4027 char *kwnames[] = {
4028 (char *) "milliseconds", NULL
4029 };
4030
4031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4032 {
4033 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4034 if (SWIG_arg_fail(1)) SWIG_fail;
4035 }
4036 {
4037 PyThreadState* __tstate = wxPyBeginAllowThreads();
4038 wxMilliSleep(arg1);
4039
4040 wxPyEndAllowThreads(__tstate);
4041 if (PyErr_Occurred()) SWIG_fail;
4042 }
4043 Py_INCREF(Py_None); resultobj = Py_None;
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 unsigned long arg1 ;
4053 PyObject * obj0 = 0 ;
4054 char *kwnames[] = {
4055 (char *) "microseconds", NULL
4056 };
4057
4058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4059 {
4060 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4061 if (SWIG_arg_fail(1)) SWIG_fail;
4062 }
4063 {
4064 PyThreadState* __tstate = wxPyBeginAllowThreads();
4065 wxMicroSleep(arg1);
4066
4067 wxPyEndAllowThreads(__tstate);
4068 if (PyErr_Occurred()) SWIG_fail;
4069 }
4070 Py_INCREF(Py_None); resultobj = Py_None;
4071 return resultobj;
4072 fail:
4073 return NULL;
4074 }
4075
4076
4077 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4078 PyObject *resultobj;
4079 bool arg1 ;
4080 PyObject * obj0 = 0 ;
4081 char *kwnames[] = {
4082 (char *) "enable", NULL
4083 };
4084
4085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4086 {
4087 arg1 = (bool)(SWIG_As_bool(obj0));
4088 if (SWIG_arg_fail(1)) SWIG_fail;
4089 }
4090 {
4091 PyThreadState* __tstate = wxPyBeginAllowThreads();
4092 wxEnableTopLevelWindows(arg1);
4093
4094 wxPyEndAllowThreads(__tstate);
4095 if (PyErr_Occurred()) SWIG_fail;
4096 }
4097 Py_INCREF(Py_None); resultobj = Py_None;
4098 return resultobj;
4099 fail:
4100 return NULL;
4101 }
4102
4103
4104 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4105 PyObject *resultobj;
4106 wxString *arg1 = 0 ;
4107 wxString result;
4108 bool temp1 = false ;
4109 PyObject * obj0 = 0 ;
4110 char *kwnames[] = {
4111 (char *) "in", NULL
4112 };
4113
4114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4115 {
4116 arg1 = wxString_in_helper(obj0);
4117 if (arg1 == NULL) SWIG_fail;
4118 temp1 = true;
4119 }
4120 {
4121 PyThreadState* __tstate = wxPyBeginAllowThreads();
4122 result = wxStripMenuCodes((wxString const &)*arg1);
4123
4124 wxPyEndAllowThreads(__tstate);
4125 if (PyErr_Occurred()) SWIG_fail;
4126 }
4127 {
4128 #if wxUSE_UNICODE
4129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4130 #else
4131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4132 #endif
4133 }
4134 {
4135 if (temp1)
4136 delete arg1;
4137 }
4138 return resultobj;
4139 fail:
4140 {
4141 if (temp1)
4142 delete arg1;
4143 }
4144 return NULL;
4145 }
4146
4147
4148 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj;
4150 wxString result;
4151 char *kwnames[] = {
4152 NULL
4153 };
4154
4155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4156 {
4157 PyThreadState* __tstate = wxPyBeginAllowThreads();
4158 result = wxGetEmailAddress();
4159
4160 wxPyEndAllowThreads(__tstate);
4161 if (PyErr_Occurred()) SWIG_fail;
4162 }
4163 {
4164 #if wxUSE_UNICODE
4165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4166 #else
4167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4168 #endif
4169 }
4170 return resultobj;
4171 fail:
4172 return NULL;
4173 }
4174
4175
4176 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4177 PyObject *resultobj;
4178 wxString result;
4179 char *kwnames[] = {
4180 NULL
4181 };
4182
4183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4184 {
4185 PyThreadState* __tstate = wxPyBeginAllowThreads();
4186 result = wxGetHostName();
4187
4188 wxPyEndAllowThreads(__tstate);
4189 if (PyErr_Occurred()) SWIG_fail;
4190 }
4191 {
4192 #if wxUSE_UNICODE
4193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4194 #else
4195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4196 #endif
4197 }
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
4204 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4205 PyObject *resultobj;
4206 wxString result;
4207 char *kwnames[] = {
4208 NULL
4209 };
4210
4211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4212 {
4213 PyThreadState* __tstate = wxPyBeginAllowThreads();
4214 result = wxGetFullHostName();
4215
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 {
4220 #if wxUSE_UNICODE
4221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4222 #else
4223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4224 #endif
4225 }
4226 return resultobj;
4227 fail:
4228 return NULL;
4229 }
4230
4231
4232 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4233 PyObject *resultobj;
4234 wxString result;
4235 char *kwnames[] = {
4236 NULL
4237 };
4238
4239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4240 {
4241 PyThreadState* __tstate = wxPyBeginAllowThreads();
4242 result = wxGetUserId();
4243
4244 wxPyEndAllowThreads(__tstate);
4245 if (PyErr_Occurred()) SWIG_fail;
4246 }
4247 {
4248 #if wxUSE_UNICODE
4249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4250 #else
4251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4252 #endif
4253 }
4254 return resultobj;
4255 fail:
4256 return NULL;
4257 }
4258
4259
4260 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4261 PyObject *resultobj;
4262 wxString result;
4263 char *kwnames[] = {
4264 NULL
4265 };
4266
4267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 result = wxGetUserName();
4271
4272 wxPyEndAllowThreads(__tstate);
4273 if (PyErr_Occurred()) SWIG_fail;
4274 }
4275 {
4276 #if wxUSE_UNICODE
4277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4278 #else
4279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4280 #endif
4281 }
4282 return resultobj;
4283 fail:
4284 return NULL;
4285 }
4286
4287
4288 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4289 PyObject *resultobj;
4290 wxString result;
4291 char *kwnames[] = {
4292 NULL
4293 };
4294
4295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4296 {
4297 PyThreadState* __tstate = wxPyBeginAllowThreads();
4298 result = wxGetHomeDir();
4299
4300 wxPyEndAllowThreads(__tstate);
4301 if (PyErr_Occurred()) SWIG_fail;
4302 }
4303 {
4304 #if wxUSE_UNICODE
4305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4306 #else
4307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4308 #endif
4309 }
4310 return resultobj;
4311 fail:
4312 return NULL;
4313 }
4314
4315
4316 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4317 PyObject *resultobj;
4318 wxString const &arg1_defvalue = wxPyEmptyString ;
4319 wxString *arg1 = (wxString *) &arg1_defvalue ;
4320 wxString result;
4321 bool temp1 = false ;
4322 PyObject * obj0 = 0 ;
4323 char *kwnames[] = {
4324 (char *) "user", NULL
4325 };
4326
4327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4328 if (obj0) {
4329 {
4330 arg1 = wxString_in_helper(obj0);
4331 if (arg1 == NULL) SWIG_fail;
4332 temp1 = true;
4333 }
4334 }
4335 {
4336 PyThreadState* __tstate = wxPyBeginAllowThreads();
4337 result = wxGetUserHome((wxString const &)*arg1);
4338
4339 wxPyEndAllowThreads(__tstate);
4340 if (PyErr_Occurred()) SWIG_fail;
4341 }
4342 {
4343 #if wxUSE_UNICODE
4344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4345 #else
4346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4347 #endif
4348 }
4349 {
4350 if (temp1)
4351 delete arg1;
4352 }
4353 return resultobj;
4354 fail:
4355 {
4356 if (temp1)
4357 delete arg1;
4358 }
4359 return NULL;
4360 }
4361
4362
4363 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4364 PyObject *resultobj;
4365 unsigned long result;
4366 char *kwnames[] = {
4367 NULL
4368 };
4369
4370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4371 {
4372 PyThreadState* __tstate = wxPyBeginAllowThreads();
4373 result = (unsigned long)wxGetProcessId();
4374
4375 wxPyEndAllowThreads(__tstate);
4376 if (PyErr_Occurred()) SWIG_fail;
4377 }
4378 {
4379 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4380 }
4381 return resultobj;
4382 fail:
4383 return NULL;
4384 }
4385
4386
4387 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4388 PyObject *resultobj;
4389 char *kwnames[] = {
4390 NULL
4391 };
4392
4393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4394 {
4395 PyThreadState* __tstate = wxPyBeginAllowThreads();
4396 wxTrap();
4397
4398 wxPyEndAllowThreads(__tstate);
4399 if (PyErr_Occurred()) SWIG_fail;
4400 }
4401 Py_INCREF(Py_None); resultobj = Py_None;
4402 return resultobj;
4403 fail:
4404 return NULL;
4405 }
4406
4407
4408 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4409 PyObject *resultobj;
4410 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4411 wxString *arg1 = (wxString *) &arg1_defvalue ;
4412 wxString const &arg2_defvalue = wxPyEmptyString ;
4413 wxString *arg2 = (wxString *) &arg2_defvalue ;
4414 wxString const &arg3_defvalue = wxPyEmptyString ;
4415 wxString *arg3 = (wxString *) &arg3_defvalue ;
4416 wxString const &arg4_defvalue = wxPyEmptyString ;
4417 wxString *arg4 = (wxString *) &arg4_defvalue ;
4418 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4419 wxString *arg5 = (wxString *) &arg5_defvalue ;
4420 int arg6 = (int) 0 ;
4421 wxWindow *arg7 = (wxWindow *) NULL ;
4422 int arg8 = (int) -1 ;
4423 int arg9 = (int) -1 ;
4424 wxString result;
4425 bool temp1 = false ;
4426 bool temp2 = false ;
4427 bool temp3 = false ;
4428 bool temp4 = false ;
4429 bool temp5 = false ;
4430 PyObject * obj0 = 0 ;
4431 PyObject * obj1 = 0 ;
4432 PyObject * obj2 = 0 ;
4433 PyObject * obj3 = 0 ;
4434 PyObject * obj4 = 0 ;
4435 PyObject * obj5 = 0 ;
4436 PyObject * obj6 = 0 ;
4437 PyObject * obj7 = 0 ;
4438 PyObject * obj8 = 0 ;
4439 char *kwnames[] = {
4440 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4441 };
4442
4443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4444 if (obj0) {
4445 {
4446 arg1 = wxString_in_helper(obj0);
4447 if (arg1 == NULL) SWIG_fail;
4448 temp1 = true;
4449 }
4450 }
4451 if (obj1) {
4452 {
4453 arg2 = wxString_in_helper(obj1);
4454 if (arg2 == NULL) SWIG_fail;
4455 temp2 = true;
4456 }
4457 }
4458 if (obj2) {
4459 {
4460 arg3 = wxString_in_helper(obj2);
4461 if (arg3 == NULL) SWIG_fail;
4462 temp3 = true;
4463 }
4464 }
4465 if (obj3) {
4466 {
4467 arg4 = wxString_in_helper(obj3);
4468 if (arg4 == NULL) SWIG_fail;
4469 temp4 = true;
4470 }
4471 }
4472 if (obj4) {
4473 {
4474 arg5 = wxString_in_helper(obj4);
4475 if (arg5 == NULL) SWIG_fail;
4476 temp5 = true;
4477 }
4478 }
4479 if (obj5) {
4480 {
4481 arg6 = (int)(SWIG_As_int(obj5));
4482 if (SWIG_arg_fail(6)) SWIG_fail;
4483 }
4484 }
4485 if (obj6) {
4486 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4487 if (SWIG_arg_fail(7)) SWIG_fail;
4488 }
4489 if (obj7) {
4490 {
4491 arg8 = (int)(SWIG_As_int(obj7));
4492 if (SWIG_arg_fail(8)) SWIG_fail;
4493 }
4494 }
4495 if (obj8) {
4496 {
4497 arg9 = (int)(SWIG_As_int(obj8));
4498 if (SWIG_arg_fail(9)) SWIG_fail;
4499 }
4500 }
4501 {
4502 if (!wxPyCheckForApp()) SWIG_fail;
4503 PyThreadState* __tstate = wxPyBeginAllowThreads();
4504 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4505
4506 wxPyEndAllowThreads(__tstate);
4507 if (PyErr_Occurred()) SWIG_fail;
4508 }
4509 {
4510 #if wxUSE_UNICODE
4511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4512 #else
4513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4514 #endif
4515 }
4516 {
4517 if (temp1)
4518 delete arg1;
4519 }
4520 {
4521 if (temp2)
4522 delete arg2;
4523 }
4524 {
4525 if (temp3)
4526 delete arg3;
4527 }
4528 {
4529 if (temp4)
4530 delete arg4;
4531 }
4532 {
4533 if (temp5)
4534 delete arg5;
4535 }
4536 return resultobj;
4537 fail:
4538 {
4539 if (temp1)
4540 delete arg1;
4541 }
4542 {
4543 if (temp2)
4544 delete arg2;
4545 }
4546 {
4547 if (temp3)
4548 delete arg3;
4549 }
4550 {
4551 if (temp4)
4552 delete arg4;
4553 }
4554 {
4555 if (temp5)
4556 delete arg5;
4557 }
4558 return NULL;
4559 }
4560
4561
4562 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4563 PyObject *resultobj;
4564 wxString *arg1 = 0 ;
4565 wxString *arg2 = 0 ;
4566 wxString const &arg3_defvalue = wxPyEmptyString ;
4567 wxString *arg3 = (wxString *) &arg3_defvalue ;
4568 wxWindow *arg4 = (wxWindow *) NULL ;
4569 wxString result;
4570 bool temp1 = false ;
4571 bool temp2 = false ;
4572 bool temp3 = false ;
4573 PyObject * obj0 = 0 ;
4574 PyObject * obj1 = 0 ;
4575 PyObject * obj2 = 0 ;
4576 PyObject * obj3 = 0 ;
4577 char *kwnames[] = {
4578 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4579 };
4580
4581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4582 {
4583 arg1 = wxString_in_helper(obj0);
4584 if (arg1 == NULL) SWIG_fail;
4585 temp1 = true;
4586 }
4587 {
4588 arg2 = wxString_in_helper(obj1);
4589 if (arg2 == NULL) SWIG_fail;
4590 temp2 = true;
4591 }
4592 if (obj2) {
4593 {
4594 arg3 = wxString_in_helper(obj2);
4595 if (arg3 == NULL) SWIG_fail;
4596 temp3 = true;
4597 }
4598 }
4599 if (obj3) {
4600 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4601 if (SWIG_arg_fail(4)) SWIG_fail;
4602 }
4603 {
4604 if (!wxPyCheckForApp()) SWIG_fail;
4605 PyThreadState* __tstate = wxPyBeginAllowThreads();
4606 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4607
4608 wxPyEndAllowThreads(__tstate);
4609 if (PyErr_Occurred()) SWIG_fail;
4610 }
4611 {
4612 #if wxUSE_UNICODE
4613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4614 #else
4615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4616 #endif
4617 }
4618 {
4619 if (temp1)
4620 delete arg1;
4621 }
4622 {
4623 if (temp2)
4624 delete arg2;
4625 }
4626 {
4627 if (temp3)
4628 delete arg3;
4629 }
4630 return resultobj;
4631 fail:
4632 {
4633 if (temp1)
4634 delete arg1;
4635 }
4636 {
4637 if (temp2)
4638 delete arg2;
4639 }
4640 {
4641 if (temp3)
4642 delete arg3;
4643 }
4644 return NULL;
4645 }
4646
4647
4648 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4649 PyObject *resultobj;
4650 wxString *arg1 = 0 ;
4651 wxString *arg2 = 0 ;
4652 wxString const &arg3_defvalue = wxPyEmptyString ;
4653 wxString *arg3 = (wxString *) &arg3_defvalue ;
4654 wxWindow *arg4 = (wxWindow *) NULL ;
4655 wxString result;
4656 bool temp1 = false ;
4657 bool temp2 = false ;
4658 bool temp3 = false ;
4659 PyObject * obj0 = 0 ;
4660 PyObject * obj1 = 0 ;
4661 PyObject * obj2 = 0 ;
4662 PyObject * obj3 = 0 ;
4663 char *kwnames[] = {
4664 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4665 };
4666
4667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4668 {
4669 arg1 = wxString_in_helper(obj0);
4670 if (arg1 == NULL) SWIG_fail;
4671 temp1 = true;
4672 }
4673 {
4674 arg2 = wxString_in_helper(obj1);
4675 if (arg2 == NULL) SWIG_fail;
4676 temp2 = true;
4677 }
4678 if (obj2) {
4679 {
4680 arg3 = wxString_in_helper(obj2);
4681 if (arg3 == NULL) SWIG_fail;
4682 temp3 = true;
4683 }
4684 }
4685 if (obj3) {
4686 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4687 if (SWIG_arg_fail(4)) SWIG_fail;
4688 }
4689 {
4690 if (!wxPyCheckForApp()) SWIG_fail;
4691 PyThreadState* __tstate = wxPyBeginAllowThreads();
4692 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4693
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 {
4698 #if wxUSE_UNICODE
4699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4700 #else
4701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4702 #endif
4703 }
4704 {
4705 if (temp1)
4706 delete arg1;
4707 }
4708 {
4709 if (temp2)
4710 delete arg2;
4711 }
4712 {
4713 if (temp3)
4714 delete arg3;
4715 }
4716 return resultobj;
4717 fail:
4718 {
4719 if (temp1)
4720 delete arg1;
4721 }
4722 {
4723 if (temp2)
4724 delete arg2;
4725 }
4726 {
4727 if (temp3)
4728 delete arg3;
4729 }
4730 return NULL;
4731 }
4732
4733
4734 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4735 PyObject *resultobj;
4736 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4737 wxString *arg1 = (wxString *) &arg1_defvalue ;
4738 wxString const &arg2_defvalue = wxPyEmptyString ;
4739 wxString *arg2 = (wxString *) &arg2_defvalue ;
4740 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4741 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4742 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4743 wxWindow *arg5 = (wxWindow *) NULL ;
4744 wxString result;
4745 bool temp1 = false ;
4746 bool temp2 = false ;
4747 wxPoint temp4 ;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 PyObject * obj2 = 0 ;
4751 PyObject * obj3 = 0 ;
4752 PyObject * obj4 = 0 ;
4753 char *kwnames[] = {
4754 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4755 };
4756
4757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4758 if (obj0) {
4759 {
4760 arg1 = wxString_in_helper(obj0);
4761 if (arg1 == NULL) SWIG_fail;
4762 temp1 = true;
4763 }
4764 }
4765 if (obj1) {
4766 {
4767 arg2 = wxString_in_helper(obj1);
4768 if (arg2 == NULL) SWIG_fail;
4769 temp2 = true;
4770 }
4771 }
4772 if (obj2) {
4773 {
4774 arg3 = (long)(SWIG_As_long(obj2));
4775 if (SWIG_arg_fail(3)) SWIG_fail;
4776 }
4777 }
4778 if (obj3) {
4779 {
4780 arg4 = &temp4;
4781 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4782 }
4783 }
4784 if (obj4) {
4785 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4786 if (SWIG_arg_fail(5)) SWIG_fail;
4787 }
4788 {
4789 if (!wxPyCheckForApp()) SWIG_fail;
4790 PyThreadState* __tstate = wxPyBeginAllowThreads();
4791 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4792
4793 wxPyEndAllowThreads(__tstate);
4794 if (PyErr_Occurred()) SWIG_fail;
4795 }
4796 {
4797 #if wxUSE_UNICODE
4798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4799 #else
4800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4801 #endif
4802 }
4803 {
4804 if (temp1)
4805 delete arg1;
4806 }
4807 {
4808 if (temp2)
4809 delete arg2;
4810 }
4811 return resultobj;
4812 fail:
4813 {
4814 if (temp1)
4815 delete arg1;
4816 }
4817 {
4818 if (temp2)
4819 delete arg2;
4820 }
4821 return NULL;
4822 }
4823
4824
4825 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4826 PyObject *resultobj;
4827 wxString *arg1 = 0 ;
4828 wxString const &arg2_defvalue = wxPyEmptyString ;
4829 wxString *arg2 = (wxString *) &arg2_defvalue ;
4830 wxString const &arg3_defvalue = wxPyEmptyString ;
4831 wxString *arg3 = (wxString *) &arg3_defvalue ;
4832 wxWindow *arg4 = (wxWindow *) NULL ;
4833 int arg5 = (int) -1 ;
4834 int arg6 = (int) -1 ;
4835 bool arg7 = (bool) true ;
4836 wxString result;
4837 bool temp1 = false ;
4838 bool temp2 = false ;
4839 bool temp3 = false ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 PyObject * obj2 = 0 ;
4843 PyObject * obj3 = 0 ;
4844 PyObject * obj4 = 0 ;
4845 PyObject * obj5 = 0 ;
4846 PyObject * obj6 = 0 ;
4847 char *kwnames[] = {
4848 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4849 };
4850
4851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4852 {
4853 arg1 = wxString_in_helper(obj0);
4854 if (arg1 == NULL) SWIG_fail;
4855 temp1 = true;
4856 }
4857 if (obj1) {
4858 {
4859 arg2 = wxString_in_helper(obj1);
4860 if (arg2 == NULL) SWIG_fail;
4861 temp2 = true;
4862 }
4863 }
4864 if (obj2) {
4865 {
4866 arg3 = wxString_in_helper(obj2);
4867 if (arg3 == NULL) SWIG_fail;
4868 temp3 = true;
4869 }
4870 }
4871 if (obj3) {
4872 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4873 if (SWIG_arg_fail(4)) SWIG_fail;
4874 }
4875 if (obj4) {
4876 {
4877 arg5 = (int)(SWIG_As_int(obj4));
4878 if (SWIG_arg_fail(5)) SWIG_fail;
4879 }
4880 }
4881 if (obj5) {
4882 {
4883 arg6 = (int)(SWIG_As_int(obj5));
4884 if (SWIG_arg_fail(6)) SWIG_fail;
4885 }
4886 }
4887 if (obj6) {
4888 {
4889 arg7 = (bool)(SWIG_As_bool(obj6));
4890 if (SWIG_arg_fail(7)) SWIG_fail;
4891 }
4892 }
4893 {
4894 if (!wxPyCheckForApp()) SWIG_fail;
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4897
4898 wxPyEndAllowThreads(__tstate);
4899 if (PyErr_Occurred()) SWIG_fail;
4900 }
4901 {
4902 #if wxUSE_UNICODE
4903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4904 #else
4905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4906 #endif
4907 }
4908 {
4909 if (temp1)
4910 delete arg1;
4911 }
4912 {
4913 if (temp2)
4914 delete arg2;
4915 }
4916 {
4917 if (temp3)
4918 delete arg3;
4919 }
4920 return resultobj;
4921 fail:
4922 {
4923 if (temp1)
4924 delete arg1;
4925 }
4926 {
4927 if (temp2)
4928 delete arg2;
4929 }
4930 {
4931 if (temp3)
4932 delete arg3;
4933 }
4934 return NULL;
4935 }
4936
4937
4938 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4939 PyObject *resultobj;
4940 wxString *arg1 = 0 ;
4941 wxString const &arg2_defvalue = wxPyEmptyString ;
4942 wxString *arg2 = (wxString *) &arg2_defvalue ;
4943 wxString const &arg3_defvalue = wxPyEmptyString ;
4944 wxString *arg3 = (wxString *) &arg3_defvalue ;
4945 wxWindow *arg4 = (wxWindow *) NULL ;
4946 wxString result;
4947 bool temp1 = false ;
4948 bool temp2 = false ;
4949 bool temp3 = false ;
4950 PyObject * obj0 = 0 ;
4951 PyObject * obj1 = 0 ;
4952 PyObject * obj2 = 0 ;
4953 PyObject * obj3 = 0 ;
4954 char *kwnames[] = {
4955 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4956 };
4957
4958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4959 {
4960 arg1 = wxString_in_helper(obj0);
4961 if (arg1 == NULL) SWIG_fail;
4962 temp1 = true;
4963 }
4964 if (obj1) {
4965 {
4966 arg2 = wxString_in_helper(obj1);
4967 if (arg2 == NULL) SWIG_fail;
4968 temp2 = true;
4969 }
4970 }
4971 if (obj2) {
4972 {
4973 arg3 = wxString_in_helper(obj2);
4974 if (arg3 == NULL) SWIG_fail;
4975 temp3 = true;
4976 }
4977 }
4978 if (obj3) {
4979 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4980 if (SWIG_arg_fail(4)) SWIG_fail;
4981 }
4982 {
4983 if (!wxPyCheckForApp()) SWIG_fail;
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4986
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 {
4991 #if wxUSE_UNICODE
4992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4993 #else
4994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4995 #endif
4996 }
4997 {
4998 if (temp1)
4999 delete arg1;
5000 }
5001 {
5002 if (temp2)
5003 delete arg2;
5004 }
5005 {
5006 if (temp3)
5007 delete arg3;
5008 }
5009 return resultobj;
5010 fail:
5011 {
5012 if (temp1)
5013 delete arg1;
5014 }
5015 {
5016 if (temp2)
5017 delete arg2;
5018 }
5019 {
5020 if (temp3)
5021 delete arg3;
5022 }
5023 return NULL;
5024 }
5025
5026
5027 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5028 PyObject *resultobj;
5029 wxString *arg1 = 0 ;
5030 wxString *arg2 = 0 ;
5031 int arg3 ;
5032 wxString *arg4 = (wxString *) 0 ;
5033 wxWindow *arg5 = (wxWindow *) NULL ;
5034 int arg6 = (int) -1 ;
5035 int arg7 = (int) -1 ;
5036 bool arg8 = (bool) true ;
5037 int arg9 = (int) 150 ;
5038 int arg10 = (int) 200 ;
5039 wxString result;
5040 bool temp1 = false ;
5041 bool temp2 = false ;
5042 PyObject * obj0 = 0 ;
5043 PyObject * obj1 = 0 ;
5044 PyObject * obj2 = 0 ;
5045 PyObject * obj3 = 0 ;
5046 PyObject * obj4 = 0 ;
5047 PyObject * obj5 = 0 ;
5048 PyObject * obj6 = 0 ;
5049 PyObject * obj7 = 0 ;
5050 PyObject * obj8 = 0 ;
5051 char *kwnames[] = {
5052 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5053 };
5054
5055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5056 {
5057 arg1 = wxString_in_helper(obj0);
5058 if (arg1 == NULL) SWIG_fail;
5059 temp1 = true;
5060 }
5061 {
5062 arg2 = wxString_in_helper(obj1);
5063 if (arg2 == NULL) SWIG_fail;
5064 temp2 = true;
5065 }
5066 {
5067 arg3 = PyList_Size(obj2);
5068 arg4 = wxString_LIST_helper(obj2);
5069 if (arg4 == NULL) SWIG_fail;
5070 }
5071 if (obj3) {
5072 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5073 if (SWIG_arg_fail(5)) SWIG_fail;
5074 }
5075 if (obj4) {
5076 {
5077 arg6 = (int)(SWIG_As_int(obj4));
5078 if (SWIG_arg_fail(6)) SWIG_fail;
5079 }
5080 }
5081 if (obj5) {
5082 {
5083 arg7 = (int)(SWIG_As_int(obj5));
5084 if (SWIG_arg_fail(7)) SWIG_fail;
5085 }
5086 }
5087 if (obj6) {
5088 {
5089 arg8 = (bool)(SWIG_As_bool(obj6));
5090 if (SWIG_arg_fail(8)) SWIG_fail;
5091 }
5092 }
5093 if (obj7) {
5094 {
5095 arg9 = (int)(SWIG_As_int(obj7));
5096 if (SWIG_arg_fail(9)) SWIG_fail;
5097 }
5098 }
5099 if (obj8) {
5100 {
5101 arg10 = (int)(SWIG_As_int(obj8));
5102 if (SWIG_arg_fail(10)) SWIG_fail;
5103 }
5104 }
5105 {
5106 if (!wxPyCheckForApp()) SWIG_fail;
5107 PyThreadState* __tstate = wxPyBeginAllowThreads();
5108 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5109
5110 wxPyEndAllowThreads(__tstate);
5111 if (PyErr_Occurred()) SWIG_fail;
5112 }
5113 {
5114 #if wxUSE_UNICODE
5115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5116 #else
5117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5118 #endif
5119 }
5120 {
5121 if (temp1)
5122 delete arg1;
5123 }
5124 {
5125 if (temp2)
5126 delete arg2;
5127 }
5128 {
5129 if (arg4) delete [] arg4;
5130 }
5131 return resultobj;
5132 fail:
5133 {
5134 if (temp1)
5135 delete arg1;
5136 }
5137 {
5138 if (temp2)
5139 delete arg2;
5140 }
5141 {
5142 if (arg4) delete [] arg4;
5143 }
5144 return NULL;
5145 }
5146
5147
5148 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5149 PyObject *resultobj;
5150 wxString *arg1 = 0 ;
5151 wxString *arg2 = 0 ;
5152 int arg3 ;
5153 wxString *arg4 = (wxString *) 0 ;
5154 wxWindow *arg5 = (wxWindow *) NULL ;
5155 int arg6 = (int) -1 ;
5156 int arg7 = (int) -1 ;
5157 bool arg8 = (bool) true ;
5158 int arg9 = (int) 150 ;
5159 int arg10 = (int) 200 ;
5160 int result;
5161 bool temp1 = false ;
5162 bool temp2 = false ;
5163 PyObject * obj0 = 0 ;
5164 PyObject * obj1 = 0 ;
5165 PyObject * obj2 = 0 ;
5166 PyObject * obj3 = 0 ;
5167 PyObject * obj4 = 0 ;
5168 PyObject * obj5 = 0 ;
5169 PyObject * obj6 = 0 ;
5170 PyObject * obj7 = 0 ;
5171 PyObject * obj8 = 0 ;
5172 char *kwnames[] = {
5173 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5174 };
5175
5176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5177 {
5178 arg1 = wxString_in_helper(obj0);
5179 if (arg1 == NULL) SWIG_fail;
5180 temp1 = true;
5181 }
5182 {
5183 arg2 = wxString_in_helper(obj1);
5184 if (arg2 == NULL) SWIG_fail;
5185 temp2 = true;
5186 }
5187 {
5188 arg3 = PyList_Size(obj2);
5189 arg4 = wxString_LIST_helper(obj2);
5190 if (arg4 == NULL) SWIG_fail;
5191 }
5192 if (obj3) {
5193 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5194 if (SWIG_arg_fail(5)) SWIG_fail;
5195 }
5196 if (obj4) {
5197 {
5198 arg6 = (int)(SWIG_As_int(obj4));
5199 if (SWIG_arg_fail(6)) SWIG_fail;
5200 }
5201 }
5202 if (obj5) {
5203 {
5204 arg7 = (int)(SWIG_As_int(obj5));
5205 if (SWIG_arg_fail(7)) SWIG_fail;
5206 }
5207 }
5208 if (obj6) {
5209 {
5210 arg8 = (bool)(SWIG_As_bool(obj6));
5211 if (SWIG_arg_fail(8)) SWIG_fail;
5212 }
5213 }
5214 if (obj7) {
5215 {
5216 arg9 = (int)(SWIG_As_int(obj7));
5217 if (SWIG_arg_fail(9)) SWIG_fail;
5218 }
5219 }
5220 if (obj8) {
5221 {
5222 arg10 = (int)(SWIG_As_int(obj8));
5223 if (SWIG_arg_fail(10)) SWIG_fail;
5224 }
5225 }
5226 {
5227 if (!wxPyCheckForApp()) SWIG_fail;
5228 PyThreadState* __tstate = wxPyBeginAllowThreads();
5229 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5230
5231 wxPyEndAllowThreads(__tstate);
5232 if (PyErr_Occurred()) SWIG_fail;
5233 }
5234 {
5235 resultobj = SWIG_From_int((int)(result));
5236 }
5237 {
5238 if (temp1)
5239 delete arg1;
5240 }
5241 {
5242 if (temp2)
5243 delete arg2;
5244 }
5245 {
5246 if (arg4) delete [] arg4;
5247 }
5248 return resultobj;
5249 fail:
5250 {
5251 if (temp1)
5252 delete arg1;
5253 }
5254 {
5255 if (temp2)
5256 delete arg2;
5257 }
5258 {
5259 if (arg4) delete [] arg4;
5260 }
5261 return NULL;
5262 }
5263
5264
5265 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5266 PyObject *resultobj;
5267 wxString *arg1 = 0 ;
5268 wxString const &arg2_defvalue = wxPyEmptyString ;
5269 wxString *arg2 = (wxString *) &arg2_defvalue ;
5270 int arg3 = (int) wxOK|wxCENTRE ;
5271 wxWindow *arg4 = (wxWindow *) NULL ;
5272 int arg5 = (int) -1 ;
5273 int arg6 = (int) -1 ;
5274 int result;
5275 bool temp1 = false ;
5276 bool temp2 = false ;
5277 PyObject * obj0 = 0 ;
5278 PyObject * obj1 = 0 ;
5279 PyObject * obj2 = 0 ;
5280 PyObject * obj3 = 0 ;
5281 PyObject * obj4 = 0 ;
5282 PyObject * obj5 = 0 ;
5283 char *kwnames[] = {
5284 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5285 };
5286
5287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5288 {
5289 arg1 = wxString_in_helper(obj0);
5290 if (arg1 == NULL) SWIG_fail;
5291 temp1 = true;
5292 }
5293 if (obj1) {
5294 {
5295 arg2 = wxString_in_helper(obj1);
5296 if (arg2 == NULL) SWIG_fail;
5297 temp2 = true;
5298 }
5299 }
5300 if (obj2) {
5301 {
5302 arg3 = (int)(SWIG_As_int(obj2));
5303 if (SWIG_arg_fail(3)) SWIG_fail;
5304 }
5305 }
5306 if (obj3) {
5307 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5308 if (SWIG_arg_fail(4)) SWIG_fail;
5309 }
5310 if (obj4) {
5311 {
5312 arg5 = (int)(SWIG_As_int(obj4));
5313 if (SWIG_arg_fail(5)) SWIG_fail;
5314 }
5315 }
5316 if (obj5) {
5317 {
5318 arg6 = (int)(SWIG_As_int(obj5));
5319 if (SWIG_arg_fail(6)) SWIG_fail;
5320 }
5321 }
5322 {
5323 if (!wxPyCheckForApp()) SWIG_fail;
5324 PyThreadState* __tstate = wxPyBeginAllowThreads();
5325 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5326
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 {
5331 resultobj = SWIG_From_int((int)(result));
5332 }
5333 {
5334 if (temp1)
5335 delete arg1;
5336 }
5337 {
5338 if (temp2)
5339 delete arg2;
5340 }
5341 return resultobj;
5342 fail:
5343 {
5344 if (temp1)
5345 delete arg1;
5346 }
5347 {
5348 if (temp2)
5349 delete arg2;
5350 }
5351 return NULL;
5352 }
5353
5354
5355 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5356 PyObject *resultobj;
5357 wxString *arg1 = 0 ;
5358 wxString *arg2 = 0 ;
5359 wxString *arg3 = 0 ;
5360 long arg4 ;
5361 long arg5 = (long) 0 ;
5362 long arg6 = (long) 100 ;
5363 wxWindow *arg7 = (wxWindow *) NULL ;
5364 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5365 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5366 long result;
5367 bool temp1 = false ;
5368 bool temp2 = false ;
5369 bool temp3 = false ;
5370 wxPoint temp8 ;
5371 PyObject * obj0 = 0 ;
5372 PyObject * obj1 = 0 ;
5373 PyObject * obj2 = 0 ;
5374 PyObject * obj3 = 0 ;
5375 PyObject * obj4 = 0 ;
5376 PyObject * obj5 = 0 ;
5377 PyObject * obj6 = 0 ;
5378 PyObject * obj7 = 0 ;
5379 char *kwnames[] = {
5380 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5381 };
5382
5383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5384 {
5385 arg1 = wxString_in_helper(obj0);
5386 if (arg1 == NULL) SWIG_fail;
5387 temp1 = true;
5388 }
5389 {
5390 arg2 = wxString_in_helper(obj1);
5391 if (arg2 == NULL) SWIG_fail;
5392 temp2 = true;
5393 }
5394 {
5395 arg3 = wxString_in_helper(obj2);
5396 if (arg3 == NULL) SWIG_fail;
5397 temp3 = true;
5398 }
5399 {
5400 arg4 = (long)(SWIG_As_long(obj3));
5401 if (SWIG_arg_fail(4)) SWIG_fail;
5402 }
5403 if (obj4) {
5404 {
5405 arg5 = (long)(SWIG_As_long(obj4));
5406 if (SWIG_arg_fail(5)) SWIG_fail;
5407 }
5408 }
5409 if (obj5) {
5410 {
5411 arg6 = (long)(SWIG_As_long(obj5));
5412 if (SWIG_arg_fail(6)) SWIG_fail;
5413 }
5414 }
5415 if (obj6) {
5416 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5417 if (SWIG_arg_fail(7)) SWIG_fail;
5418 }
5419 if (obj7) {
5420 {
5421 arg8 = &temp8;
5422 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5423 }
5424 }
5425 {
5426 if (!wxPyCheckForApp()) SWIG_fail;
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5429
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 {
5434 resultobj = SWIG_From_long((long)(result));
5435 }
5436 {
5437 if (temp1)
5438 delete arg1;
5439 }
5440 {
5441 if (temp2)
5442 delete arg2;
5443 }
5444 {
5445 if (temp3)
5446 delete arg3;
5447 }
5448 return resultobj;
5449 fail:
5450 {
5451 if (temp1)
5452 delete arg1;
5453 }
5454 {
5455 if (temp2)
5456 delete arg2;
5457 }
5458 {
5459 if (temp3)
5460 delete arg3;
5461 }
5462 return NULL;
5463 }
5464
5465
5466 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5467 PyObject *resultobj;
5468 bool result;
5469 char *kwnames[] = {
5470 NULL
5471 };
5472
5473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5474 {
5475 if (!wxPyCheckForApp()) SWIG_fail;
5476 PyThreadState* __tstate = wxPyBeginAllowThreads();
5477 result = (bool)wxColourDisplay();
5478
5479 wxPyEndAllowThreads(__tstate);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 {
5483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5484 }
5485 return resultobj;
5486 fail:
5487 return NULL;
5488 }
5489
5490
5491 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5492 PyObject *resultobj;
5493 int result;
5494 char *kwnames[] = {
5495 NULL
5496 };
5497
5498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5499 {
5500 if (!wxPyCheckForApp()) SWIG_fail;
5501 PyThreadState* __tstate = wxPyBeginAllowThreads();
5502 result = (int)wxDisplayDepth();
5503
5504 wxPyEndAllowThreads(__tstate);
5505 if (PyErr_Occurred()) SWIG_fail;
5506 }
5507 {
5508 resultobj = SWIG_From_int((int)(result));
5509 }
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj;
5518 int result;
5519 char *kwnames[] = {
5520 NULL
5521 };
5522
5523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5524 {
5525 if (!wxPyCheckForApp()) SWIG_fail;
5526 PyThreadState* __tstate = wxPyBeginAllowThreads();
5527 result = (int)wxGetDisplayDepth();
5528
5529 wxPyEndAllowThreads(__tstate);
5530 if (PyErr_Occurred()) SWIG_fail;
5531 }
5532 {
5533 resultobj = SWIG_From_int((int)(result));
5534 }
5535 return resultobj;
5536 fail:
5537 return NULL;
5538 }
5539
5540
5541 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5542 PyObject *resultobj;
5543 int *arg1 = (int *) 0 ;
5544 int *arg2 = (int *) 0 ;
5545 int temp1 ;
5546 int res1 = 0 ;
5547 int temp2 ;
5548 int res2 = 0 ;
5549 char *kwnames[] = {
5550 NULL
5551 };
5552
5553 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5554 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5556 {
5557 if (!wxPyCheckForApp()) SWIG_fail;
5558 PyThreadState* __tstate = wxPyBeginAllowThreads();
5559 wxDisplaySize(arg1,arg2);
5560
5561 wxPyEndAllowThreads(__tstate);
5562 if (PyErr_Occurred()) SWIG_fail;
5563 }
5564 Py_INCREF(Py_None); resultobj = Py_None;
5565 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5566 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5567 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5568 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5569 return resultobj;
5570 fail:
5571 return NULL;
5572 }
5573
5574
5575 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5576 PyObject *resultobj;
5577 wxSize result;
5578 char *kwnames[] = {
5579 NULL
5580 };
5581
5582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5583 {
5584 if (!wxPyCheckForApp()) SWIG_fail;
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 result = wxGetDisplaySize();
5587
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 {
5592 wxSize * resultptr;
5593 resultptr = new wxSize((wxSize &)(result));
5594 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5595 }
5596 return resultobj;
5597 fail:
5598 return NULL;
5599 }
5600
5601
5602 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5603 PyObject *resultobj;
5604 int *arg1 = (int *) 0 ;
5605 int *arg2 = (int *) 0 ;
5606 int temp1 ;
5607 int res1 = 0 ;
5608 int temp2 ;
5609 int res2 = 0 ;
5610 char *kwnames[] = {
5611 NULL
5612 };
5613
5614 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5615 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5617 {
5618 if (!wxPyCheckForApp()) SWIG_fail;
5619 PyThreadState* __tstate = wxPyBeginAllowThreads();
5620 wxDisplaySizeMM(arg1,arg2);
5621
5622 wxPyEndAllowThreads(__tstate);
5623 if (PyErr_Occurred()) SWIG_fail;
5624 }
5625 Py_INCREF(Py_None); resultobj = Py_None;
5626 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5627 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5628 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5629 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5630 return resultobj;
5631 fail:
5632 return NULL;
5633 }
5634
5635
5636 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5637 PyObject *resultobj;
5638 wxSize result;
5639 char *kwnames[] = {
5640 NULL
5641 };
5642
5643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5644 {
5645 if (!wxPyCheckForApp()) SWIG_fail;
5646 PyThreadState* __tstate = wxPyBeginAllowThreads();
5647 result = wxGetDisplaySizeMM();
5648
5649 wxPyEndAllowThreads(__tstate);
5650 if (PyErr_Occurred()) SWIG_fail;
5651 }
5652 {
5653 wxSize * resultptr;
5654 resultptr = new wxSize((wxSize &)(result));
5655 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5656 }
5657 return resultobj;
5658 fail:
5659 return NULL;
5660 }
5661
5662
5663 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5664 PyObject *resultobj;
5665 int *arg1 = (int *) 0 ;
5666 int *arg2 = (int *) 0 ;
5667 int *arg3 = (int *) 0 ;
5668 int *arg4 = (int *) 0 ;
5669 int temp1 ;
5670 int res1 = 0 ;
5671 int temp2 ;
5672 int res2 = 0 ;
5673 int temp3 ;
5674 int res3 = 0 ;
5675 int temp4 ;
5676 int res4 = 0 ;
5677 char *kwnames[] = {
5678 NULL
5679 };
5680
5681 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5682 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5683 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5684 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5686 {
5687 if (!wxPyCheckForApp()) SWIG_fail;
5688 PyThreadState* __tstate = wxPyBeginAllowThreads();
5689 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5690
5691 wxPyEndAllowThreads(__tstate);
5692 if (PyErr_Occurred()) SWIG_fail;
5693 }
5694 Py_INCREF(Py_None); resultobj = Py_None;
5695 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5696 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5697 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5698 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5699 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5700 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5701 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5702 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj;
5711 wxRect result;
5712 char *kwnames[] = {
5713 NULL
5714 };
5715
5716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5717 {
5718 if (!wxPyCheckForApp()) SWIG_fail;
5719 PyThreadState* __tstate = wxPyBeginAllowThreads();
5720 result = wxGetClientDisplayRect();
5721
5722 wxPyEndAllowThreads(__tstate);
5723 if (PyErr_Occurred()) SWIG_fail;
5724 }
5725 {
5726 wxRect * resultptr;
5727 resultptr = new wxRect((wxRect &)(result));
5728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5729 }
5730 return resultobj;
5731 fail:
5732 return NULL;
5733 }
5734
5735
5736 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5737 PyObject *resultobj;
5738 wxCursor *arg1 = 0 ;
5739 PyObject * obj0 = 0 ;
5740 char *kwnames[] = {
5741 (char *) "cursor", NULL
5742 };
5743
5744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5745 {
5746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5747 if (SWIG_arg_fail(1)) SWIG_fail;
5748 if (arg1 == NULL) {
5749 SWIG_null_ref("wxCursor");
5750 }
5751 if (SWIG_arg_fail(1)) SWIG_fail;
5752 }
5753 {
5754 if (!wxPyCheckForApp()) SWIG_fail;
5755 PyThreadState* __tstate = wxPyBeginAllowThreads();
5756 wxSetCursor(*arg1);
5757
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 Py_INCREF(Py_None); resultobj = Py_None;
5762 return resultobj;
5763 fail:
5764 return NULL;
5765 }
5766
5767
5768 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj;
5770 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5771 PyObject * obj0 = 0 ;
5772 char *kwnames[] = {
5773 (char *) "cursor", NULL
5774 };
5775
5776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5777 if (obj0) {
5778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5779 if (SWIG_arg_fail(1)) SWIG_fail;
5780 }
5781 {
5782 if (!wxPyCheckForApp()) SWIG_fail;
5783 PyThreadState* __tstate = wxPyBeginAllowThreads();
5784 wxBeginBusyCursor(arg1);
5785
5786 wxPyEndAllowThreads(__tstate);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 Py_INCREF(Py_None); resultobj = Py_None;
5790 return resultobj;
5791 fail:
5792 return NULL;
5793 }
5794
5795
5796 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5797 PyObject *resultobj;
5798 wxWindow *result;
5799 char *kwnames[] = {
5800 NULL
5801 };
5802
5803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5804 {
5805 if (!wxPyCheckForApp()) SWIG_fail;
5806 PyThreadState* __tstate = wxPyBeginAllowThreads();
5807 result = (wxWindow *)wxGetActiveWindow();
5808
5809 wxPyEndAllowThreads(__tstate);
5810 if (PyErr_Occurred()) SWIG_fail;
5811 }
5812 {
5813 resultobj = wxPyMake_wxObject(result, 0);
5814 }
5815 return resultobj;
5816 fail:
5817 return NULL;
5818 }
5819
5820
5821 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5822 PyObject *resultobj;
5823 wxPoint *arg1 = 0 ;
5824 wxWindow *result;
5825 wxPoint temp1 ;
5826 PyObject * obj0 = 0 ;
5827 char *kwnames[] = {
5828 (char *) "pt", NULL
5829 };
5830
5831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5832 {
5833 arg1 = &temp1;
5834 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5835 }
5836 {
5837 if (!wxPyCheckForApp()) SWIG_fail;
5838 PyThreadState* __tstate = wxPyBeginAllowThreads();
5839 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5840
5841 wxPyEndAllowThreads(__tstate);
5842 if (PyErr_Occurred()) SWIG_fail;
5843 }
5844 {
5845 resultobj = wxPyMake_wxObject(result, 0);
5846 }
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj;
5855 wxPoint *arg1 = 0 ;
5856 wxWindow *result;
5857 wxPoint temp1 ;
5858 PyObject * obj0 = 0 ;
5859 char *kwnames[] = {
5860 (char *) "pt", NULL
5861 };
5862
5863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5864 {
5865 arg1 = &temp1;
5866 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5867 }
5868 {
5869 if (!wxPyCheckForApp()) SWIG_fail;
5870 PyThreadState* __tstate = wxPyBeginAllowThreads();
5871 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5872
5873 wxPyEndAllowThreads(__tstate);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 {
5877 resultobj = wxPyMake_wxObject(result, 0);
5878 }
5879 return resultobj;
5880 fail:
5881 return NULL;
5882 }
5883
5884
5885 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5886 PyObject *resultobj;
5887 wxWindow *arg1 = (wxWindow *) 0 ;
5888 wxWindow *result;
5889 PyObject * obj0 = 0 ;
5890 char *kwnames[] = {
5891 (char *) "win", NULL
5892 };
5893
5894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5896 if (SWIG_arg_fail(1)) SWIG_fail;
5897 {
5898 if (!wxPyCheckForApp()) SWIG_fail;
5899 PyThreadState* __tstate = wxPyBeginAllowThreads();
5900 result = (wxWindow *)wxGetTopLevelParent(arg1);
5901
5902 wxPyEndAllowThreads(__tstate);
5903 if (PyErr_Occurred()) SWIG_fail;
5904 }
5905 {
5906 resultobj = wxPyMake_wxObject(result, 0);
5907 }
5908 return resultobj;
5909 fail:
5910 return NULL;
5911 }
5912
5913
5914 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5915 PyObject *resultobj;
5916 wxKeyCode arg1 ;
5917 bool result;
5918 PyObject * obj0 = 0 ;
5919 char *kwnames[] = {
5920 (char *) "key", NULL
5921 };
5922
5923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5924 {
5925 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5926 if (SWIG_arg_fail(1)) SWIG_fail;
5927 }
5928 {
5929 if (!wxPyCheckForApp()) SWIG_fail;
5930 PyThreadState* __tstate = wxPyBeginAllowThreads();
5931 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5932
5933 wxPyEndAllowThreads(__tstate);
5934 if (PyErr_Occurred()) SWIG_fail;
5935 }
5936 {
5937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5938 }
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj;
5947 char *kwnames[] = {
5948 NULL
5949 };
5950
5951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5952 {
5953 if (!wxPyCheckForApp()) SWIG_fail;
5954 PyThreadState* __tstate = wxPyBeginAllowThreads();
5955 wxWakeUpMainThread();
5956
5957 wxPyEndAllowThreads(__tstate);
5958 if (PyErr_Occurred()) SWIG_fail;
5959 }
5960 Py_INCREF(Py_None); resultobj = Py_None;
5961 return resultobj;
5962 fail:
5963 return NULL;
5964 }
5965
5966
5967 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5968 PyObject *resultobj;
5969 char *kwnames[] = {
5970 NULL
5971 };
5972
5973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5974 {
5975 if (!wxPyCheckForApp()) SWIG_fail;
5976 PyThreadState* __tstate = wxPyBeginAllowThreads();
5977 wxMutexGuiEnter();
5978
5979 wxPyEndAllowThreads(__tstate);
5980 if (PyErr_Occurred()) SWIG_fail;
5981 }
5982 Py_INCREF(Py_None); resultobj = Py_None;
5983 return resultobj;
5984 fail:
5985 return NULL;
5986 }
5987
5988
5989 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5990 PyObject *resultobj;
5991 char *kwnames[] = {
5992 NULL
5993 };
5994
5995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5996 {
5997 if (!wxPyCheckForApp()) SWIG_fail;
5998 PyThreadState* __tstate = wxPyBeginAllowThreads();
5999 wxMutexGuiLeave();
6000
6001 wxPyEndAllowThreads(__tstate);
6002 if (PyErr_Occurred()) SWIG_fail;
6003 }
6004 Py_INCREF(Py_None); resultobj = Py_None;
6005 return resultobj;
6006 fail:
6007 return NULL;
6008 }
6009
6010
6011 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6012 PyObject *resultobj;
6013 wxMutexGuiLocker *result;
6014 char *kwnames[] = {
6015 NULL
6016 };
6017
6018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6019 {
6020 if (!wxPyCheckForApp()) SWIG_fail;
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6023
6024 wxPyEndAllowThreads(__tstate);
6025 if (PyErr_Occurred()) SWIG_fail;
6026 }
6027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6028 return resultobj;
6029 fail:
6030 return NULL;
6031 }
6032
6033
6034 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6035 PyObject *resultobj;
6036 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6037 PyObject * obj0 = 0 ;
6038 char *kwnames[] = {
6039 (char *) "self", NULL
6040 };
6041
6042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6044 if (SWIG_arg_fail(1)) SWIG_fail;
6045 {
6046 PyThreadState* __tstate = wxPyBeginAllowThreads();
6047 delete arg1;
6048
6049 wxPyEndAllowThreads(__tstate);
6050 if (PyErr_Occurred()) SWIG_fail;
6051 }
6052 Py_INCREF(Py_None); resultobj = Py_None;
6053 return resultobj;
6054 fail:
6055 return NULL;
6056 }
6057
6058
6059 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6060 PyObject *obj;
6061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6062 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6063 Py_INCREF(obj);
6064 return Py_BuildValue((char *)"");
6065 }
6066 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6067 PyObject *resultobj;
6068 bool result;
6069 char *kwnames[] = {
6070 NULL
6071 };
6072
6073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6074 {
6075 PyThreadState* __tstate = wxPyBeginAllowThreads();
6076 result = (bool)wxThread_IsMain();
6077
6078 wxPyEndAllowThreads(__tstate);
6079 if (PyErr_Occurred()) SWIG_fail;
6080 }
6081 {
6082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6083 }
6084 return resultobj;
6085 fail:
6086 return NULL;
6087 }
6088
6089
6090 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6091 PyObject *resultobj;
6092 wxString *arg1 = 0 ;
6093 wxToolTip *result;
6094 bool temp1 = false ;
6095 PyObject * obj0 = 0 ;
6096 char *kwnames[] = {
6097 (char *) "tip", NULL
6098 };
6099
6100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6101 {
6102 arg1 = wxString_in_helper(obj0);
6103 if (arg1 == NULL) SWIG_fail;
6104 temp1 = true;
6105 }
6106 {
6107 if (!wxPyCheckForApp()) SWIG_fail;
6108 PyThreadState* __tstate = wxPyBeginAllowThreads();
6109 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6110
6111 wxPyEndAllowThreads(__tstate);
6112 if (PyErr_Occurred()) SWIG_fail;
6113 }
6114 {
6115 resultobj = wxPyMake_wxObject(result, 1);
6116 }
6117 {
6118 if (temp1)
6119 delete arg1;
6120 }
6121 return resultobj;
6122 fail:
6123 {
6124 if (temp1)
6125 delete arg1;
6126 }
6127 return NULL;
6128 }
6129
6130
6131 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6132 PyObject *resultobj;
6133 wxToolTip *arg1 = (wxToolTip *) 0 ;
6134 wxString *arg2 = 0 ;
6135 bool temp2 = false ;
6136 PyObject * obj0 = 0 ;
6137 PyObject * obj1 = 0 ;
6138 char *kwnames[] = {
6139 (char *) "self",(char *) "tip", NULL
6140 };
6141
6142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6144 if (SWIG_arg_fail(1)) SWIG_fail;
6145 {
6146 arg2 = wxString_in_helper(obj1);
6147 if (arg2 == NULL) SWIG_fail;
6148 temp2 = true;
6149 }
6150 {
6151 PyThreadState* __tstate = wxPyBeginAllowThreads();
6152 (arg1)->SetTip((wxString const &)*arg2);
6153
6154 wxPyEndAllowThreads(__tstate);
6155 if (PyErr_Occurred()) SWIG_fail;
6156 }
6157 Py_INCREF(Py_None); resultobj = Py_None;
6158 {
6159 if (temp2)
6160 delete arg2;
6161 }
6162 return resultobj;
6163 fail:
6164 {
6165 if (temp2)
6166 delete arg2;
6167 }
6168 return NULL;
6169 }
6170
6171
6172 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6173 PyObject *resultobj;
6174 wxToolTip *arg1 = (wxToolTip *) 0 ;
6175 wxString result;
6176 PyObject * obj0 = 0 ;
6177 char *kwnames[] = {
6178 (char *) "self", NULL
6179 };
6180
6181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6183 if (SWIG_arg_fail(1)) SWIG_fail;
6184 {
6185 PyThreadState* __tstate = wxPyBeginAllowThreads();
6186 result = (arg1)->GetTip();
6187
6188 wxPyEndAllowThreads(__tstate);
6189 if (PyErr_Occurred()) SWIG_fail;
6190 }
6191 {
6192 #if wxUSE_UNICODE
6193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6194 #else
6195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6196 #endif
6197 }
6198 return resultobj;
6199 fail:
6200 return NULL;
6201 }
6202
6203
6204 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6205 PyObject *resultobj;
6206 wxToolTip *arg1 = (wxToolTip *) 0 ;
6207 wxWindow *result;
6208 PyObject * obj0 = 0 ;
6209 char *kwnames[] = {
6210 (char *) "self", NULL
6211 };
6212
6213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6215 if (SWIG_arg_fail(1)) SWIG_fail;
6216 {
6217 PyThreadState* __tstate = wxPyBeginAllowThreads();
6218 result = (wxWindow *)(arg1)->GetWindow();
6219
6220 wxPyEndAllowThreads(__tstate);
6221 if (PyErr_Occurred()) SWIG_fail;
6222 }
6223 {
6224 resultobj = wxPyMake_wxObject(result, 0);
6225 }
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6233 PyObject *resultobj;
6234 bool arg1 ;
6235 PyObject * obj0 = 0 ;
6236 char *kwnames[] = {
6237 (char *) "flag", NULL
6238 };
6239
6240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6241 {
6242 arg1 = (bool)(SWIG_As_bool(obj0));
6243 if (SWIG_arg_fail(1)) SWIG_fail;
6244 }
6245 {
6246 PyThreadState* __tstate = wxPyBeginAllowThreads();
6247 wxToolTip::Enable(arg1);
6248
6249 wxPyEndAllowThreads(__tstate);
6250 if (PyErr_Occurred()) SWIG_fail;
6251 }
6252 Py_INCREF(Py_None); resultobj = Py_None;
6253 return resultobj;
6254 fail:
6255 return NULL;
6256 }
6257
6258
6259 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6260 PyObject *resultobj;
6261 long arg1 ;
6262 PyObject * obj0 = 0 ;
6263 char *kwnames[] = {
6264 (char *) "milliseconds", NULL
6265 };
6266
6267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6268 {
6269 arg1 = (long)(SWIG_As_long(obj0));
6270 if (SWIG_arg_fail(1)) SWIG_fail;
6271 }
6272 {
6273 PyThreadState* __tstate = wxPyBeginAllowThreads();
6274 wxToolTip::SetDelay(arg1);
6275
6276 wxPyEndAllowThreads(__tstate);
6277 if (PyErr_Occurred()) SWIG_fail;
6278 }
6279 Py_INCREF(Py_None); resultobj = Py_None;
6280 return resultobj;
6281 fail:
6282 return NULL;
6283 }
6284
6285
6286 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6287 PyObject *obj;
6288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6289 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6290 Py_INCREF(obj);
6291 return Py_BuildValue((char *)"");
6292 }
6293 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6294 PyObject *resultobj;
6295 wxWindow *arg1 = (wxWindow *) 0 ;
6296 wxSize *arg2 = 0 ;
6297 wxCaret *result;
6298 wxSize temp2 ;
6299 PyObject * obj0 = 0 ;
6300 PyObject * obj1 = 0 ;
6301 char *kwnames[] = {
6302 (char *) "window",(char *) "size", NULL
6303 };
6304
6305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6307 if (SWIG_arg_fail(1)) SWIG_fail;
6308 {
6309 arg2 = &temp2;
6310 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6311 }
6312 {
6313 if (!wxPyCheckForApp()) SWIG_fail;
6314 PyThreadState* __tstate = wxPyBeginAllowThreads();
6315 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6316
6317 wxPyEndAllowThreads(__tstate);
6318 if (PyErr_Occurred()) SWIG_fail;
6319 }
6320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6321 return resultobj;
6322 fail:
6323 return NULL;
6324 }
6325
6326
6327 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6328 PyObject *resultobj;
6329 wxCaret *arg1 = (wxCaret *) 0 ;
6330 PyObject * obj0 = 0 ;
6331 char *kwnames[] = {
6332 (char *) "self", NULL
6333 };
6334
6335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
6336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6337 if (SWIG_arg_fail(1)) SWIG_fail;
6338 {
6339 PyThreadState* __tstate = wxPyBeginAllowThreads();
6340 delete arg1;
6341
6342 wxPyEndAllowThreads(__tstate);
6343 if (PyErr_Occurred()) SWIG_fail;
6344 }
6345 Py_INCREF(Py_None); resultobj = Py_None;
6346 return resultobj;
6347 fail:
6348 return NULL;
6349 }
6350
6351
6352 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6353 PyObject *resultobj;
6354 wxCaret *arg1 = (wxCaret *) 0 ;
6355 bool result;
6356 PyObject * obj0 = 0 ;
6357 char *kwnames[] = {
6358 (char *) "self", NULL
6359 };
6360
6361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6363 if (SWIG_arg_fail(1)) SWIG_fail;
6364 {
6365 PyThreadState* __tstate = wxPyBeginAllowThreads();
6366 result = (bool)(arg1)->IsOk();
6367
6368 wxPyEndAllowThreads(__tstate);
6369 if (PyErr_Occurred()) SWIG_fail;
6370 }
6371 {
6372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6373 }
6374 return resultobj;
6375 fail:
6376 return NULL;
6377 }
6378
6379
6380 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6381 PyObject *resultobj;
6382 wxCaret *arg1 = (wxCaret *) 0 ;
6383 bool result;
6384 PyObject * obj0 = 0 ;
6385 char *kwnames[] = {
6386 (char *) "self", NULL
6387 };
6388
6389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6391 if (SWIG_arg_fail(1)) SWIG_fail;
6392 {
6393 PyThreadState* __tstate = wxPyBeginAllowThreads();
6394 result = (bool)(arg1)->IsVisible();
6395
6396 wxPyEndAllowThreads(__tstate);
6397 if (PyErr_Occurred()) SWIG_fail;
6398 }
6399 {
6400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6401 }
6402 return resultobj;
6403 fail:
6404 return NULL;
6405 }
6406
6407
6408 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6409 PyObject *resultobj;
6410 wxCaret *arg1 = (wxCaret *) 0 ;
6411 wxPoint result;
6412 PyObject * obj0 = 0 ;
6413 char *kwnames[] = {
6414 (char *) "self", NULL
6415 };
6416
6417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6419 if (SWIG_arg_fail(1)) SWIG_fail;
6420 {
6421 PyThreadState* __tstate = wxPyBeginAllowThreads();
6422 result = (arg1)->GetPosition();
6423
6424 wxPyEndAllowThreads(__tstate);
6425 if (PyErr_Occurred()) SWIG_fail;
6426 }
6427 {
6428 wxPoint * resultptr;
6429 resultptr = new wxPoint((wxPoint &)(result));
6430 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6431 }
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj;
6440 wxCaret *arg1 = (wxCaret *) 0 ;
6441 int *arg2 = (int *) 0 ;
6442 int *arg3 = (int *) 0 ;
6443 int temp2 ;
6444 int res2 = 0 ;
6445 int temp3 ;
6446 int res3 = 0 ;
6447 PyObject * obj0 = 0 ;
6448 char *kwnames[] = {
6449 (char *) "self", NULL
6450 };
6451
6452 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6453 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6456 if (SWIG_arg_fail(1)) SWIG_fail;
6457 {
6458 PyThreadState* __tstate = wxPyBeginAllowThreads();
6459 (arg1)->GetPosition(arg2,arg3);
6460
6461 wxPyEndAllowThreads(__tstate);
6462 if (PyErr_Occurred()) SWIG_fail;
6463 }
6464 Py_INCREF(Py_None); resultobj = Py_None;
6465 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6466 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6467 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6468 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6476 PyObject *resultobj;
6477 wxCaret *arg1 = (wxCaret *) 0 ;
6478 wxSize result;
6479 PyObject * obj0 = 0 ;
6480 char *kwnames[] = {
6481 (char *) "self", NULL
6482 };
6483
6484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6486 if (SWIG_arg_fail(1)) SWIG_fail;
6487 {
6488 PyThreadState* __tstate = wxPyBeginAllowThreads();
6489 result = (arg1)->GetSize();
6490
6491 wxPyEndAllowThreads(__tstate);
6492 if (PyErr_Occurred()) SWIG_fail;
6493 }
6494 {
6495 wxSize * resultptr;
6496 resultptr = new wxSize((wxSize &)(result));
6497 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6498 }
6499 return resultobj;
6500 fail:
6501 return NULL;
6502 }
6503
6504
6505 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6506 PyObject *resultobj;
6507 wxCaret *arg1 = (wxCaret *) 0 ;
6508 int *arg2 = (int *) 0 ;
6509 int *arg3 = (int *) 0 ;
6510 int temp2 ;
6511 int res2 = 0 ;
6512 int temp3 ;
6513 int res3 = 0 ;
6514 PyObject * obj0 = 0 ;
6515 char *kwnames[] = {
6516 (char *) "self", NULL
6517 };
6518
6519 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6520 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6523 if (SWIG_arg_fail(1)) SWIG_fail;
6524 {
6525 PyThreadState* __tstate = wxPyBeginAllowThreads();
6526 (arg1)->GetSize(arg2,arg3);
6527
6528 wxPyEndAllowThreads(__tstate);
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 Py_INCREF(Py_None); resultobj = Py_None;
6532 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6533 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6534 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6535 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6543 PyObject *resultobj;
6544 wxCaret *arg1 = (wxCaret *) 0 ;
6545 wxWindow *result;
6546 PyObject * obj0 = 0 ;
6547 char *kwnames[] = {
6548 (char *) "self", NULL
6549 };
6550
6551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6553 if (SWIG_arg_fail(1)) SWIG_fail;
6554 {
6555 PyThreadState* __tstate = wxPyBeginAllowThreads();
6556 result = (wxWindow *)(arg1)->GetWindow();
6557
6558 wxPyEndAllowThreads(__tstate);
6559 if (PyErr_Occurred()) SWIG_fail;
6560 }
6561 {
6562 resultobj = wxPyMake_wxObject(result, 0);
6563 }
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj;
6572 wxCaret *arg1 = (wxCaret *) 0 ;
6573 int arg2 ;
6574 int arg3 ;
6575 PyObject * obj0 = 0 ;
6576 PyObject * obj1 = 0 ;
6577 PyObject * obj2 = 0 ;
6578 char *kwnames[] = {
6579 (char *) "self",(char *) "x",(char *) "y", NULL
6580 };
6581
6582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6584 if (SWIG_arg_fail(1)) SWIG_fail;
6585 {
6586 arg2 = (int)(SWIG_As_int(obj1));
6587 if (SWIG_arg_fail(2)) SWIG_fail;
6588 }
6589 {
6590 arg3 = (int)(SWIG_As_int(obj2));
6591 if (SWIG_arg_fail(3)) SWIG_fail;
6592 }
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->Move(arg2,arg3);
6596
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 Py_INCREF(Py_None); resultobj = Py_None;
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6608 PyObject *resultobj;
6609 wxCaret *arg1 = (wxCaret *) 0 ;
6610 wxPoint *arg2 = 0 ;
6611 wxPoint temp2 ;
6612 PyObject * obj0 = 0 ;
6613 PyObject * obj1 = 0 ;
6614 char *kwnames[] = {
6615 (char *) "self",(char *) "pt", NULL
6616 };
6617
6618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6620 if (SWIG_arg_fail(1)) SWIG_fail;
6621 {
6622 arg2 = &temp2;
6623 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6624 }
6625 {
6626 PyThreadState* __tstate = wxPyBeginAllowThreads();
6627 (arg1)->Move((wxPoint const &)*arg2);
6628
6629 wxPyEndAllowThreads(__tstate);
6630 if (PyErr_Occurred()) SWIG_fail;
6631 }
6632 Py_INCREF(Py_None); resultobj = Py_None;
6633 return resultobj;
6634 fail:
6635 return NULL;
6636 }
6637
6638
6639 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6640 PyObject *resultobj;
6641 wxCaret *arg1 = (wxCaret *) 0 ;
6642 int arg2 ;
6643 int arg3 ;
6644 PyObject * obj0 = 0 ;
6645 PyObject * obj1 = 0 ;
6646 PyObject * obj2 = 0 ;
6647 char *kwnames[] = {
6648 (char *) "self",(char *) "width",(char *) "height", NULL
6649 };
6650
6651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6653 if (SWIG_arg_fail(1)) SWIG_fail;
6654 {
6655 arg2 = (int)(SWIG_As_int(obj1));
6656 if (SWIG_arg_fail(2)) SWIG_fail;
6657 }
6658 {
6659 arg3 = (int)(SWIG_As_int(obj2));
6660 if (SWIG_arg_fail(3)) SWIG_fail;
6661 }
6662 {
6663 PyThreadState* __tstate = wxPyBeginAllowThreads();
6664 (arg1)->SetSize(arg2,arg3);
6665
6666 wxPyEndAllowThreads(__tstate);
6667 if (PyErr_Occurred()) SWIG_fail;
6668 }
6669 Py_INCREF(Py_None); resultobj = Py_None;
6670 return resultobj;
6671 fail:
6672 return NULL;
6673 }
6674
6675
6676 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6677 PyObject *resultobj;
6678 wxCaret *arg1 = (wxCaret *) 0 ;
6679 wxSize *arg2 = 0 ;
6680 wxSize temp2 ;
6681 PyObject * obj0 = 0 ;
6682 PyObject * obj1 = 0 ;
6683 char *kwnames[] = {
6684 (char *) "self",(char *) "size", NULL
6685 };
6686
6687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6689 if (SWIG_arg_fail(1)) SWIG_fail;
6690 {
6691 arg2 = &temp2;
6692 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6693 }
6694 {
6695 PyThreadState* __tstate = wxPyBeginAllowThreads();
6696 (arg1)->SetSize((wxSize const &)*arg2);
6697
6698 wxPyEndAllowThreads(__tstate);
6699 if (PyErr_Occurred()) SWIG_fail;
6700 }
6701 Py_INCREF(Py_None); resultobj = Py_None;
6702 return resultobj;
6703 fail:
6704 return NULL;
6705 }
6706
6707
6708 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6709 PyObject *resultobj;
6710 wxCaret *arg1 = (wxCaret *) 0 ;
6711 int arg2 = (int) true ;
6712 PyObject * obj0 = 0 ;
6713 PyObject * obj1 = 0 ;
6714 char *kwnames[] = {
6715 (char *) "self",(char *) "show", NULL
6716 };
6717
6718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6720 if (SWIG_arg_fail(1)) SWIG_fail;
6721 if (obj1) {
6722 {
6723 arg2 = (int)(SWIG_As_int(obj1));
6724 if (SWIG_arg_fail(2)) SWIG_fail;
6725 }
6726 }
6727 {
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 (arg1)->Show(arg2);
6730
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 Py_INCREF(Py_None); resultobj = Py_None;
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6742 PyObject *resultobj;
6743 wxCaret *arg1 = (wxCaret *) 0 ;
6744 PyObject * obj0 = 0 ;
6745 char *kwnames[] = {
6746 (char *) "self", NULL
6747 };
6748
6749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6751 if (SWIG_arg_fail(1)) SWIG_fail;
6752 {
6753 PyThreadState* __tstate = wxPyBeginAllowThreads();
6754 (arg1)->Hide();
6755
6756 wxPyEndAllowThreads(__tstate);
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 Py_INCREF(Py_None); resultobj = Py_None;
6760 return resultobj;
6761 fail:
6762 return NULL;
6763 }
6764
6765
6766 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6767 PyObject *obj;
6768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6769 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6770 Py_INCREF(obj);
6771 return Py_BuildValue((char *)"");
6772 }
6773 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6774 PyObject *resultobj;
6775 int result;
6776 char *kwnames[] = {
6777 NULL
6778 };
6779
6780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6781 {
6782 PyThreadState* __tstate = wxPyBeginAllowThreads();
6783 result = (int)wxCaret_GetBlinkTime();
6784
6785 wxPyEndAllowThreads(__tstate);
6786 if (PyErr_Occurred()) SWIG_fail;
6787 }
6788 {
6789 resultobj = SWIG_From_int((int)(result));
6790 }
6791 return resultobj;
6792 fail:
6793 return NULL;
6794 }
6795
6796
6797 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6798 PyObject *resultobj;
6799 int arg1 ;
6800 PyObject * obj0 = 0 ;
6801 char *kwnames[] = {
6802 (char *) "milliseconds", NULL
6803 };
6804
6805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6806 {
6807 arg1 = (int)(SWIG_As_int(obj0));
6808 if (SWIG_arg_fail(1)) SWIG_fail;
6809 }
6810 {
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 wxCaret_SetBlinkTime(arg1);
6813
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 Py_INCREF(Py_None); resultobj = Py_None;
6818 return resultobj;
6819 fail:
6820 return NULL;
6821 }
6822
6823
6824 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6825 PyObject *resultobj;
6826 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6827 wxBusyCursor *result;
6828 PyObject * obj0 = 0 ;
6829 char *kwnames[] = {
6830 (char *) "cursor", NULL
6831 };
6832
6833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6834 if (obj0) {
6835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6836 if (SWIG_arg_fail(1)) SWIG_fail;
6837 }
6838 {
6839 if (!wxPyCheckForApp()) SWIG_fail;
6840 PyThreadState* __tstate = wxPyBeginAllowThreads();
6841 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6842
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6854 PyObject *resultobj;
6855 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6856 PyObject * obj0 = 0 ;
6857 char *kwnames[] = {
6858 (char *) "self", NULL
6859 };
6860
6861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6863 if (SWIG_arg_fail(1)) SWIG_fail;
6864 {
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 delete arg1;
6867
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 Py_INCREF(Py_None); resultobj = Py_None;
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6879 PyObject *obj;
6880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6881 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6882 Py_INCREF(obj);
6883 return Py_BuildValue((char *)"");
6884 }
6885 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6886 PyObject *resultobj;
6887 wxWindow *arg1 = (wxWindow *) NULL ;
6888 wxWindowDisabler *result;
6889 PyObject * obj0 = 0 ;
6890 char *kwnames[] = {
6891 (char *) "winToSkip", NULL
6892 };
6893
6894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6895 if (obj0) {
6896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6897 if (SWIG_arg_fail(1)) SWIG_fail;
6898 }
6899 {
6900 if (!wxPyCheckForApp()) SWIG_fail;
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6903
6904 wxPyEndAllowThreads(__tstate);
6905 if (PyErr_Occurred()) SWIG_fail;
6906 }
6907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6908 return resultobj;
6909 fail:
6910 return NULL;
6911 }
6912
6913
6914 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6915 PyObject *resultobj;
6916 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6917 PyObject * obj0 = 0 ;
6918 char *kwnames[] = {
6919 (char *) "self", NULL
6920 };
6921
6922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6924 if (SWIG_arg_fail(1)) SWIG_fail;
6925 {
6926 PyThreadState* __tstate = wxPyBeginAllowThreads();
6927 delete arg1;
6928
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 Py_INCREF(Py_None); resultobj = Py_None;
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6940 PyObject *obj;
6941 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6942 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6943 Py_INCREF(obj);
6944 return Py_BuildValue((char *)"");
6945 }
6946 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6947 PyObject *resultobj;
6948 wxString *arg1 = 0 ;
6949 wxBusyInfo *result;
6950 bool temp1 = false ;
6951 PyObject * obj0 = 0 ;
6952 char *kwnames[] = {
6953 (char *) "message", NULL
6954 };
6955
6956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6957 {
6958 arg1 = wxString_in_helper(obj0);
6959 if (arg1 == NULL) SWIG_fail;
6960 temp1 = true;
6961 }
6962 {
6963 if (!wxPyCheckForApp()) SWIG_fail;
6964 PyThreadState* __tstate = wxPyBeginAllowThreads();
6965 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6966
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6971 {
6972 if (temp1)
6973 delete arg1;
6974 }
6975 return resultobj;
6976 fail:
6977 {
6978 if (temp1)
6979 delete arg1;
6980 }
6981 return NULL;
6982 }
6983
6984
6985 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6986 PyObject *resultobj;
6987 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6988 PyObject * obj0 = 0 ;
6989 char *kwnames[] = {
6990 (char *) "self", NULL
6991 };
6992
6993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6995 if (SWIG_arg_fail(1)) SWIG_fail;
6996 {
6997 PyThreadState* __tstate = wxPyBeginAllowThreads();
6998 delete arg1;
6999
7000 wxPyEndAllowThreads(__tstate);
7001 if (PyErr_Occurred()) SWIG_fail;
7002 }
7003 Py_INCREF(Py_None); resultobj = Py_None;
7004 return resultobj;
7005 fail:
7006 return NULL;
7007 }
7008
7009
7010 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7011 PyObject *obj;
7012 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7013 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7014 Py_INCREF(obj);
7015 return Py_BuildValue((char *)"");
7016 }
7017 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7018 PyObject *resultobj;
7019 wxStopWatch *result;
7020 char *kwnames[] = {
7021 NULL
7022 };
7023
7024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7025 {
7026 PyThreadState* __tstate = wxPyBeginAllowThreads();
7027 result = (wxStopWatch *)new wxStopWatch();
7028
7029 wxPyEndAllowThreads(__tstate);
7030 if (PyErr_Occurred()) SWIG_fail;
7031 }
7032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7033 return resultobj;
7034 fail:
7035 return NULL;
7036 }
7037
7038
7039 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7040 PyObject *resultobj;
7041 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7042 long arg2 = (long) 0 ;
7043 PyObject * obj0 = 0 ;
7044 PyObject * obj1 = 0 ;
7045 char *kwnames[] = {
7046 (char *) "self",(char *) "t0", NULL
7047 };
7048
7049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7051 if (SWIG_arg_fail(1)) SWIG_fail;
7052 if (obj1) {
7053 {
7054 arg2 = (long)(SWIG_As_long(obj1));
7055 if (SWIG_arg_fail(2)) SWIG_fail;
7056 }
7057 }
7058 {
7059 PyThreadState* __tstate = wxPyBeginAllowThreads();
7060 (arg1)->Start(arg2);
7061
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 Py_INCREF(Py_None); resultobj = Py_None;
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj;
7074 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7075 PyObject * obj0 = 0 ;
7076 char *kwnames[] = {
7077 (char *) "self", NULL
7078 };
7079
7080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7082 if (SWIG_arg_fail(1)) SWIG_fail;
7083 {
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 (arg1)->Pause();
7086
7087 wxPyEndAllowThreads(__tstate);
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 Py_INCREF(Py_None); resultobj = Py_None;
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7098 PyObject *resultobj;
7099 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7100 PyObject * obj0 = 0 ;
7101 char *kwnames[] = {
7102 (char *) "self", NULL
7103 };
7104
7105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7107 if (SWIG_arg_fail(1)) SWIG_fail;
7108 {
7109 PyThreadState* __tstate = wxPyBeginAllowThreads();
7110 (arg1)->Resume();
7111
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 Py_INCREF(Py_None); resultobj = Py_None;
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj;
7124 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7125 long result;
7126 PyObject * obj0 = 0 ;
7127 char *kwnames[] = {
7128 (char *) "self", NULL
7129 };
7130
7131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7133 if (SWIG_arg_fail(1)) SWIG_fail;
7134 {
7135 PyThreadState* __tstate = wxPyBeginAllowThreads();
7136 result = (long)((wxStopWatch const *)arg1)->Time();
7137
7138 wxPyEndAllowThreads(__tstate);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 {
7142 resultobj = SWIG_From_long((long)(result));
7143 }
7144 return resultobj;
7145 fail:
7146 return NULL;
7147 }
7148
7149
7150 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7151 PyObject *obj;
7152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7153 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7154 Py_INCREF(obj);
7155 return Py_BuildValue((char *)"");
7156 }
7157 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj;
7159 int arg1 = (int) 9 ;
7160 int arg2 = (int) wxID_FILE1 ;
7161 wxFileHistory *result;
7162 PyObject * obj0 = 0 ;
7163 PyObject * obj1 = 0 ;
7164 char *kwnames[] = {
7165 (char *) "maxFiles",(char *) "idBase", NULL
7166 };
7167
7168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7169 if (obj0) {
7170 {
7171 arg1 = (int)(SWIG_As_int(obj0));
7172 if (SWIG_arg_fail(1)) SWIG_fail;
7173 }
7174 }
7175 if (obj1) {
7176 {
7177 arg2 = (int)(SWIG_As_int(obj1));
7178 if (SWIG_arg_fail(2)) SWIG_fail;
7179 }
7180 }
7181 {
7182 PyThreadState* __tstate = wxPyBeginAllowThreads();
7183 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7184
7185 wxPyEndAllowThreads(__tstate);
7186 if (PyErr_Occurred()) SWIG_fail;
7187 }
7188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj;
7197 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7198 PyObject * obj0 = 0 ;
7199 char *kwnames[] = {
7200 (char *) "self", NULL
7201 };
7202
7203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7205 if (SWIG_arg_fail(1)) SWIG_fail;
7206 {
7207 PyThreadState* __tstate = wxPyBeginAllowThreads();
7208 delete arg1;
7209
7210 wxPyEndAllowThreads(__tstate);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 Py_INCREF(Py_None); resultobj = Py_None;
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj;
7222 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7223 wxString *arg2 = 0 ;
7224 bool temp2 = false ;
7225 PyObject * obj0 = 0 ;
7226 PyObject * obj1 = 0 ;
7227 char *kwnames[] = {
7228 (char *) "self",(char *) "file", NULL
7229 };
7230
7231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7233 if (SWIG_arg_fail(1)) SWIG_fail;
7234 {
7235 arg2 = wxString_in_helper(obj1);
7236 if (arg2 == NULL) SWIG_fail;
7237 temp2 = true;
7238 }
7239 {
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 (arg1)->AddFileToHistory((wxString const &)*arg2);
7242
7243 wxPyEndAllowThreads(__tstate);
7244 if (PyErr_Occurred()) SWIG_fail;
7245 }
7246 Py_INCREF(Py_None); resultobj = Py_None;
7247 {
7248 if (temp2)
7249 delete arg2;
7250 }
7251 return resultobj;
7252 fail:
7253 {
7254 if (temp2)
7255 delete arg2;
7256 }
7257 return NULL;
7258 }
7259
7260
7261 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj;
7263 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7264 int arg2 ;
7265 PyObject * obj0 = 0 ;
7266 PyObject * obj1 = 0 ;
7267 char *kwnames[] = {
7268 (char *) "self",(char *) "i", NULL
7269 };
7270
7271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7273 if (SWIG_arg_fail(1)) SWIG_fail;
7274 {
7275 arg2 = (int)(SWIG_As_int(obj1));
7276 if (SWIG_arg_fail(2)) SWIG_fail;
7277 }
7278 {
7279 PyThreadState* __tstate = wxPyBeginAllowThreads();
7280 (arg1)->RemoveFileFromHistory(arg2);
7281
7282 wxPyEndAllowThreads(__tstate);
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 Py_INCREF(Py_None); resultobj = Py_None;
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj;
7294 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7295 int result;
7296 PyObject * obj0 = 0 ;
7297 char *kwnames[] = {
7298 (char *) "self", NULL
7299 };
7300
7301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7303 if (SWIG_arg_fail(1)) SWIG_fail;
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 {
7312 resultobj = SWIG_From_int((int)(result));
7313 }
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj;
7322 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7323 wxMenu *arg2 = (wxMenu *) 0 ;
7324 PyObject * obj0 = 0 ;
7325 PyObject * obj1 = 0 ;
7326 char *kwnames[] = {
7327 (char *) "self",(char *) "menu", NULL
7328 };
7329
7330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7332 if (SWIG_arg_fail(1)) SWIG_fail;
7333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7334 if (SWIG_arg_fail(2)) SWIG_fail;
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 (arg1)->UseMenu(arg2);
7338
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 Py_INCREF(Py_None); resultobj = Py_None;
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7350 PyObject *resultobj;
7351 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7352 wxMenu *arg2 = (wxMenu *) 0 ;
7353 PyObject * obj0 = 0 ;
7354 PyObject * obj1 = 0 ;
7355 char *kwnames[] = {
7356 (char *) "self",(char *) "menu", NULL
7357 };
7358
7359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7361 if (SWIG_arg_fail(1)) SWIG_fail;
7362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7363 if (SWIG_arg_fail(2)) SWIG_fail;
7364 {
7365 PyThreadState* __tstate = wxPyBeginAllowThreads();
7366 (arg1)->RemoveMenu(arg2);
7367
7368 wxPyEndAllowThreads(__tstate);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 Py_INCREF(Py_None); resultobj = Py_None;
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7379 PyObject *resultobj;
7380 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7381 wxConfigBase *arg2 = 0 ;
7382 PyObject * obj0 = 0 ;
7383 PyObject * obj1 = 0 ;
7384 char *kwnames[] = {
7385 (char *) "self",(char *) "config", NULL
7386 };
7387
7388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7390 if (SWIG_arg_fail(1)) SWIG_fail;
7391 {
7392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7393 if (SWIG_arg_fail(2)) SWIG_fail;
7394 if (arg2 == NULL) {
7395 SWIG_null_ref("wxConfigBase");
7396 }
7397 if (SWIG_arg_fail(2)) SWIG_fail;
7398 }
7399 {
7400 PyThreadState* __tstate = wxPyBeginAllowThreads();
7401 (arg1)->Load(*arg2);
7402
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 Py_INCREF(Py_None); resultobj = Py_None;
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj;
7415 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7416 wxConfigBase *arg2 = 0 ;
7417 PyObject * obj0 = 0 ;
7418 PyObject * obj1 = 0 ;
7419 char *kwnames[] = {
7420 (char *) "self",(char *) "config", NULL
7421 };
7422
7423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7425 if (SWIG_arg_fail(1)) SWIG_fail;
7426 {
7427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7428 if (SWIG_arg_fail(2)) SWIG_fail;
7429 if (arg2 == NULL) {
7430 SWIG_null_ref("wxConfigBase");
7431 }
7432 if (SWIG_arg_fail(2)) SWIG_fail;
7433 }
7434 {
7435 PyThreadState* __tstate = wxPyBeginAllowThreads();
7436 (arg1)->Save(*arg2);
7437
7438 wxPyEndAllowThreads(__tstate);
7439 if (PyErr_Occurred()) SWIG_fail;
7440 }
7441 Py_INCREF(Py_None); resultobj = Py_None;
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj;
7450 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7451 PyObject * obj0 = 0 ;
7452 char *kwnames[] = {
7453 (char *) "self", NULL
7454 };
7455
7456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7458 if (SWIG_arg_fail(1)) SWIG_fail;
7459 {
7460 PyThreadState* __tstate = wxPyBeginAllowThreads();
7461 (arg1)->AddFilesToMenu();
7462
7463 wxPyEndAllowThreads(__tstate);
7464 if (PyErr_Occurred()) SWIG_fail;
7465 }
7466 Py_INCREF(Py_None); resultobj = Py_None;
7467 return resultobj;
7468 fail:
7469 return NULL;
7470 }
7471
7472
7473 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7474 PyObject *resultobj;
7475 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7476 wxMenu *arg2 = (wxMenu *) 0 ;
7477 PyObject * obj0 = 0 ;
7478 PyObject * obj1 = 0 ;
7479 char *kwnames[] = {
7480 (char *) "self",(char *) "menu", NULL
7481 };
7482
7483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7485 if (SWIG_arg_fail(1)) SWIG_fail;
7486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7487 if (SWIG_arg_fail(2)) SWIG_fail;
7488 {
7489 PyThreadState* __tstate = wxPyBeginAllowThreads();
7490 (arg1)->AddFilesToMenu(arg2);
7491
7492 wxPyEndAllowThreads(__tstate);
7493 if (PyErr_Occurred()) SWIG_fail;
7494 }
7495 Py_INCREF(Py_None); resultobj = Py_None;
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7503 PyObject *resultobj;
7504 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7505 int arg2 ;
7506 wxString result;
7507 PyObject * obj0 = 0 ;
7508 PyObject * obj1 = 0 ;
7509 char *kwnames[] = {
7510 (char *) "self",(char *) "i", NULL
7511 };
7512
7513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7515 if (SWIG_arg_fail(1)) SWIG_fail;
7516 {
7517 arg2 = (int)(SWIG_As_int(obj1));
7518 if (SWIG_arg_fail(2)) SWIG_fail;
7519 }
7520 {
7521 PyThreadState* __tstate = wxPyBeginAllowThreads();
7522 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7523
7524 wxPyEndAllowThreads(__tstate);
7525 if (PyErr_Occurred()) SWIG_fail;
7526 }
7527 {
7528 #if wxUSE_UNICODE
7529 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7530 #else
7531 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7532 #endif
7533 }
7534 return resultobj;
7535 fail:
7536 return NULL;
7537 }
7538
7539
7540 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7541 PyObject *resultobj;
7542 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7543 int result;
7544 PyObject * obj0 = 0 ;
7545 char *kwnames[] = {
7546 (char *) "self", NULL
7547 };
7548
7549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7551 if (SWIG_arg_fail(1)) SWIG_fail;
7552 {
7553 PyThreadState* __tstate = wxPyBeginAllowThreads();
7554 result = (int)((wxFileHistory const *)arg1)->GetCount();
7555
7556 wxPyEndAllowThreads(__tstate);
7557 if (PyErr_Occurred()) SWIG_fail;
7558 }
7559 {
7560 resultobj = SWIG_From_int((int)(result));
7561 }
7562 return resultobj;
7563 fail:
7564 return NULL;
7565 }
7566
7567
7568 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7569 PyObject *obj;
7570 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7571 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7572 Py_INCREF(obj);
7573 return Py_BuildValue((char *)"");
7574 }
7575 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7576 PyObject *resultobj;
7577 wxString *arg1 = 0 ;
7578 wxString const &arg2_defvalue = wxPyEmptyString ;
7579 wxString *arg2 = (wxString *) &arg2_defvalue ;
7580 wxSingleInstanceChecker *result;
7581 bool temp1 = false ;
7582 bool temp2 = false ;
7583 PyObject * obj0 = 0 ;
7584 PyObject * obj1 = 0 ;
7585 char *kwnames[] = {
7586 (char *) "name",(char *) "path", NULL
7587 };
7588
7589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7590 {
7591 arg1 = wxString_in_helper(obj0);
7592 if (arg1 == NULL) SWIG_fail;
7593 temp1 = true;
7594 }
7595 if (obj1) {
7596 {
7597 arg2 = wxString_in_helper(obj1);
7598 if (arg2 == NULL) SWIG_fail;
7599 temp2 = true;
7600 }
7601 }
7602 {
7603 PyThreadState* __tstate = wxPyBeginAllowThreads();
7604 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7605
7606 wxPyEndAllowThreads(__tstate);
7607 if (PyErr_Occurred()) SWIG_fail;
7608 }
7609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7610 {
7611 if (temp1)
7612 delete arg1;
7613 }
7614 {
7615 if (temp2)
7616 delete arg2;
7617 }
7618 return resultobj;
7619 fail:
7620 {
7621 if (temp1)
7622 delete arg1;
7623 }
7624 {
7625 if (temp2)
7626 delete arg2;
7627 }
7628 return NULL;
7629 }
7630
7631
7632 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7633 PyObject *resultobj;
7634 wxSingleInstanceChecker *result;
7635 char *kwnames[] = {
7636 NULL
7637 };
7638
7639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7640 {
7641 PyThreadState* __tstate = wxPyBeginAllowThreads();
7642 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7643
7644 wxPyEndAllowThreads(__tstate);
7645 if (PyErr_Occurred()) SWIG_fail;
7646 }
7647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7648 return resultobj;
7649 fail:
7650 return NULL;
7651 }
7652
7653
7654 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7655 PyObject *resultobj;
7656 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7657 PyObject * obj0 = 0 ;
7658 char *kwnames[] = {
7659 (char *) "self", NULL
7660 };
7661
7662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7664 if (SWIG_arg_fail(1)) SWIG_fail;
7665 {
7666 PyThreadState* __tstate = wxPyBeginAllowThreads();
7667 delete arg1;
7668
7669 wxPyEndAllowThreads(__tstate);
7670 if (PyErr_Occurred()) SWIG_fail;
7671 }
7672 Py_INCREF(Py_None); resultobj = Py_None;
7673 return resultobj;
7674 fail:
7675 return NULL;
7676 }
7677
7678
7679 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7680 PyObject *resultobj;
7681 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7682 wxString *arg2 = 0 ;
7683 wxString const &arg3_defvalue = wxPyEmptyString ;
7684 wxString *arg3 = (wxString *) &arg3_defvalue ;
7685 bool result;
7686 bool temp2 = false ;
7687 bool temp3 = false ;
7688 PyObject * obj0 = 0 ;
7689 PyObject * obj1 = 0 ;
7690 PyObject * obj2 = 0 ;
7691 char *kwnames[] = {
7692 (char *) "self",(char *) "name",(char *) "path", NULL
7693 };
7694
7695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7697 if (SWIG_arg_fail(1)) SWIG_fail;
7698 {
7699 arg2 = wxString_in_helper(obj1);
7700 if (arg2 == NULL) SWIG_fail;
7701 temp2 = true;
7702 }
7703 if (obj2) {
7704 {
7705 arg3 = wxString_in_helper(obj2);
7706 if (arg3 == NULL) SWIG_fail;
7707 temp3 = true;
7708 }
7709 }
7710 {
7711 PyThreadState* __tstate = wxPyBeginAllowThreads();
7712 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7713
7714 wxPyEndAllowThreads(__tstate);
7715 if (PyErr_Occurred()) SWIG_fail;
7716 }
7717 {
7718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7719 }
7720 {
7721 if (temp2)
7722 delete arg2;
7723 }
7724 {
7725 if (temp3)
7726 delete arg3;
7727 }
7728 return resultobj;
7729 fail:
7730 {
7731 if (temp2)
7732 delete arg2;
7733 }
7734 {
7735 if (temp3)
7736 delete arg3;
7737 }
7738 return NULL;
7739 }
7740
7741
7742 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj;
7744 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7745 bool result;
7746 PyObject * obj0 = 0 ;
7747 char *kwnames[] = {
7748 (char *) "self", NULL
7749 };
7750
7751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7753 if (SWIG_arg_fail(1)) SWIG_fail;
7754 {
7755 PyThreadState* __tstate = wxPyBeginAllowThreads();
7756 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7757
7758 wxPyEndAllowThreads(__tstate);
7759 if (PyErr_Occurred()) SWIG_fail;
7760 }
7761 {
7762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7763 }
7764 return resultobj;
7765 fail:
7766 return NULL;
7767 }
7768
7769
7770 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7771 PyObject *obj;
7772 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7773 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7774 Py_INCREF(obj);
7775 return Py_BuildValue((char *)"");
7776 }
7777 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj;
7779 wxWindow *arg1 = (wxWindow *) 0 ;
7780 wxDC *arg2 = 0 ;
7781 int arg3 ;
7782 PyObject * obj0 = 0 ;
7783 PyObject * obj1 = 0 ;
7784 PyObject * obj2 = 0 ;
7785 char *kwnames[] = {
7786 (char *) "window",(char *) "dc",(char *) "method", NULL
7787 };
7788
7789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DrawWindowOnDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
7790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7791 if (SWIG_arg_fail(1)) SWIG_fail;
7792 {
7793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7794 if (SWIG_arg_fail(2)) SWIG_fail;
7795 if (arg2 == NULL) {
7796 SWIG_null_ref("wxDC");
7797 }
7798 if (SWIG_arg_fail(2)) SWIG_fail;
7799 }
7800 {
7801 arg3 = (int)(SWIG_As_int(obj2));
7802 if (SWIG_arg_fail(3)) SWIG_fail;
7803 }
7804 {
7805 PyThreadState* __tstate = wxPyBeginAllowThreads();
7806 wxDrawWindowOnDC(arg1,(wxDC const &)*arg2,arg3);
7807
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 Py_INCREF(Py_None); resultobj = Py_None;
7812 return resultobj;
7813 fail:
7814 return NULL;
7815 }
7816
7817
7818 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7819 PyObject *resultobj;
7820 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7821 PyObject * obj0 = 0 ;
7822 char *kwnames[] = {
7823 (char *) "self", NULL
7824 };
7825
7826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7828 if (SWIG_arg_fail(1)) SWIG_fail;
7829 {
7830 PyThreadState* __tstate = wxPyBeginAllowThreads();
7831 delete arg1;
7832
7833 wxPyEndAllowThreads(__tstate);
7834 if (PyErr_Occurred()) SWIG_fail;
7835 }
7836 Py_INCREF(Py_None); resultobj = Py_None;
7837 return resultobj;
7838 fail:
7839 return NULL;
7840 }
7841
7842
7843 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7844 PyObject *resultobj;
7845 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7846 wxString result;
7847 PyObject * obj0 = 0 ;
7848 char *kwnames[] = {
7849 (char *) "self", NULL
7850 };
7851
7852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7854 if (SWIG_arg_fail(1)) SWIG_fail;
7855 {
7856 PyThreadState* __tstate = wxPyBeginAllowThreads();
7857 result = (arg1)->GetTip();
7858
7859 wxPyEndAllowThreads(__tstate);
7860 if (PyErr_Occurred()) SWIG_fail;
7861 }
7862 {
7863 #if wxUSE_UNICODE
7864 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7865 #else
7866 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7867 #endif
7868 }
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7876 PyObject *resultobj;
7877 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7878 size_t result;
7879 PyObject * obj0 = 0 ;
7880 char *kwnames[] = {
7881 (char *) "self", NULL
7882 };
7883
7884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7886 if (SWIG_arg_fail(1)) SWIG_fail;
7887 {
7888 PyThreadState* __tstate = wxPyBeginAllowThreads();
7889 result = (size_t)(arg1)->GetCurrentTip();
7890
7891 wxPyEndAllowThreads(__tstate);
7892 if (PyErr_Occurred()) SWIG_fail;
7893 }
7894 {
7895 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7896 }
7897 return resultobj;
7898 fail:
7899 return NULL;
7900 }
7901
7902
7903 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7904 PyObject *resultobj;
7905 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7906 wxString *arg2 = 0 ;
7907 wxString result;
7908 bool temp2 = false ;
7909 PyObject * obj0 = 0 ;
7910 PyObject * obj1 = 0 ;
7911 char *kwnames[] = {
7912 (char *) "self",(char *) "tip", NULL
7913 };
7914
7915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7917 if (SWIG_arg_fail(1)) SWIG_fail;
7918 {
7919 arg2 = wxString_in_helper(obj1);
7920 if (arg2 == NULL) SWIG_fail;
7921 temp2 = true;
7922 }
7923 {
7924 PyThreadState* __tstate = wxPyBeginAllowThreads();
7925 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7926
7927 wxPyEndAllowThreads(__tstate);
7928 if (PyErr_Occurred()) SWIG_fail;
7929 }
7930 {
7931 #if wxUSE_UNICODE
7932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7933 #else
7934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7935 #endif
7936 }
7937 {
7938 if (temp2)
7939 delete arg2;
7940 }
7941 return resultobj;
7942 fail:
7943 {
7944 if (temp2)
7945 delete arg2;
7946 }
7947 return NULL;
7948 }
7949
7950
7951 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7952 PyObject *obj;
7953 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7954 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7955 Py_INCREF(obj);
7956 return Py_BuildValue((char *)"");
7957 }
7958 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7959 PyObject *resultobj;
7960 size_t arg1 ;
7961 wxPyTipProvider *result;
7962 PyObject * obj0 = 0 ;
7963 char *kwnames[] = {
7964 (char *) "currentTip", NULL
7965 };
7966
7967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7968 {
7969 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7970 if (SWIG_arg_fail(1)) SWIG_fail;
7971 }
7972 {
7973 PyThreadState* __tstate = wxPyBeginAllowThreads();
7974 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7975
7976 wxPyEndAllowThreads(__tstate);
7977 if (PyErr_Occurred()) SWIG_fail;
7978 }
7979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7987 PyObject *resultobj;
7988 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7989 PyObject *arg2 = (PyObject *) 0 ;
7990 PyObject *arg3 = (PyObject *) 0 ;
7991 PyObject * obj0 = 0 ;
7992 PyObject * obj1 = 0 ;
7993 PyObject * obj2 = 0 ;
7994 char *kwnames[] = {
7995 (char *) "self",(char *) "self",(char *) "_class", NULL
7996 };
7997
7998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8000 if (SWIG_arg_fail(1)) SWIG_fail;
8001 arg2 = obj1;
8002 arg3 = obj2;
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 (arg1)->_setCallbackInfo(arg2,arg3);
8006
8007 wxPyEndAllowThreads(__tstate);
8008 if (PyErr_Occurred()) SWIG_fail;
8009 }
8010 Py_INCREF(Py_None); resultobj = Py_None;
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8018 PyObject *obj;
8019 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8020 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8021 Py_INCREF(obj);
8022 return Py_BuildValue((char *)"");
8023 }
8024 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8025 PyObject *resultobj;
8026 wxWindow *arg1 = (wxWindow *) 0 ;
8027 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8028 bool arg3 = (bool) true ;
8029 bool result;
8030 PyObject * obj0 = 0 ;
8031 PyObject * obj1 = 0 ;
8032 PyObject * obj2 = 0 ;
8033 char *kwnames[] = {
8034 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8035 };
8036
8037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8039 if (SWIG_arg_fail(1)) SWIG_fail;
8040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8041 if (SWIG_arg_fail(2)) SWIG_fail;
8042 if (obj2) {
8043 {
8044 arg3 = (bool)(SWIG_As_bool(obj2));
8045 if (SWIG_arg_fail(3)) SWIG_fail;
8046 }
8047 }
8048 {
8049 if (!wxPyCheckForApp()) SWIG_fail;
8050 PyThreadState* __tstate = wxPyBeginAllowThreads();
8051 result = (bool)wxShowTip(arg1,arg2,arg3);
8052
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 {
8057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8058 }
8059 return resultobj;
8060 fail:
8061 return NULL;
8062 }
8063
8064
8065 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8066 PyObject *resultobj;
8067 wxString *arg1 = 0 ;
8068 size_t arg2 ;
8069 wxTipProvider *result;
8070 bool temp1 = false ;
8071 PyObject * obj0 = 0 ;
8072 PyObject * obj1 = 0 ;
8073 char *kwnames[] = {
8074 (char *) "filename",(char *) "currentTip", NULL
8075 };
8076
8077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8078 {
8079 arg1 = wxString_in_helper(obj0);
8080 if (arg1 == NULL) SWIG_fail;
8081 temp1 = true;
8082 }
8083 {
8084 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8085 if (SWIG_arg_fail(2)) SWIG_fail;
8086 }
8087 {
8088 if (!wxPyCheckForApp()) SWIG_fail;
8089 PyThreadState* __tstate = wxPyBeginAllowThreads();
8090 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8091
8092 wxPyEndAllowThreads(__tstate);
8093 if (PyErr_Occurred()) SWIG_fail;
8094 }
8095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8096 {
8097 if (temp1)
8098 delete arg1;
8099 }
8100 return resultobj;
8101 fail:
8102 {
8103 if (temp1)
8104 delete arg1;
8105 }
8106 return NULL;
8107 }
8108
8109
8110 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8111 PyObject *resultobj;
8112 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8113 int arg2 = (int) -1 ;
8114 wxPyTimer *result;
8115 PyObject * obj0 = 0 ;
8116 PyObject * obj1 = 0 ;
8117 char *kwnames[] = {
8118 (char *) "owner",(char *) "id", NULL
8119 };
8120
8121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8122 if (obj0) {
8123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8124 if (SWIG_arg_fail(1)) SWIG_fail;
8125 }
8126 if (obj1) {
8127 {
8128 arg2 = (int)(SWIG_As_int(obj1));
8129 if (SWIG_arg_fail(2)) SWIG_fail;
8130 }
8131 }
8132 {
8133 if (!wxPyCheckForApp()) SWIG_fail;
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8136
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj;
8149 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8150 PyObject * obj0 = 0 ;
8151 char *kwnames[] = {
8152 (char *) "self", NULL
8153 };
8154
8155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8157 if (SWIG_arg_fail(1)) SWIG_fail;
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 delete arg1;
8161
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 Py_INCREF(Py_None); resultobj = Py_None;
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8173 PyObject *resultobj;
8174 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8175 PyObject *arg2 = (PyObject *) 0 ;
8176 PyObject *arg3 = (PyObject *) 0 ;
8177 int arg4 = (int) 1 ;
8178 PyObject * obj0 = 0 ;
8179 PyObject * obj1 = 0 ;
8180 PyObject * obj2 = 0 ;
8181 PyObject * obj3 = 0 ;
8182 char *kwnames[] = {
8183 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8184 };
8185
8186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8188 if (SWIG_arg_fail(1)) SWIG_fail;
8189 arg2 = obj1;
8190 arg3 = obj2;
8191 if (obj3) {
8192 {
8193 arg4 = (int)(SWIG_As_int(obj3));
8194 if (SWIG_arg_fail(4)) SWIG_fail;
8195 }
8196 }
8197 {
8198 PyThreadState* __tstate = wxPyBeginAllowThreads();
8199 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8200
8201 wxPyEndAllowThreads(__tstate);
8202 if (PyErr_Occurred()) SWIG_fail;
8203 }
8204 Py_INCREF(Py_None); resultobj = Py_None;
8205 return resultobj;
8206 fail:
8207 return NULL;
8208 }
8209
8210
8211 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8212 PyObject *resultobj;
8213 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8214 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8215 int arg3 = (int) -1 ;
8216 PyObject * obj0 = 0 ;
8217 PyObject * obj1 = 0 ;
8218 PyObject * obj2 = 0 ;
8219 char *kwnames[] = {
8220 (char *) "self",(char *) "owner",(char *) "id", NULL
8221 };
8222
8223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8225 if (SWIG_arg_fail(1)) SWIG_fail;
8226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8227 if (SWIG_arg_fail(2)) SWIG_fail;
8228 if (obj2) {
8229 {
8230 arg3 = (int)(SWIG_As_int(obj2));
8231 if (SWIG_arg_fail(3)) SWIG_fail;
8232 }
8233 }
8234 {
8235 PyThreadState* __tstate = wxPyBeginAllowThreads();
8236 (arg1)->SetOwner(arg2,arg3);
8237
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 Py_INCREF(Py_None); resultobj = Py_None;
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj;
8250 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8251 wxEvtHandler *result;
8252 PyObject * obj0 = 0 ;
8253 char *kwnames[] = {
8254 (char *) "self", NULL
8255 };
8256
8257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8259 if (SWIG_arg_fail(1)) SWIG_fail;
8260 {
8261 PyThreadState* __tstate = wxPyBeginAllowThreads();
8262 result = (wxEvtHandler *)(arg1)->GetOwner();
8263
8264 wxPyEndAllowThreads(__tstate);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 {
8268 resultobj = wxPyMake_wxObject(result, 0);
8269 }
8270 return resultobj;
8271 fail:
8272 return NULL;
8273 }
8274
8275
8276 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8277 PyObject *resultobj;
8278 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8279 int arg2 = (int) -1 ;
8280 bool arg3 = (bool) false ;
8281 bool result;
8282 PyObject * obj0 = 0 ;
8283 PyObject * obj1 = 0 ;
8284 PyObject * obj2 = 0 ;
8285 char *kwnames[] = {
8286 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8287 };
8288
8289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8291 if (SWIG_arg_fail(1)) SWIG_fail;
8292 if (obj1) {
8293 {
8294 arg2 = (int)(SWIG_As_int(obj1));
8295 if (SWIG_arg_fail(2)) SWIG_fail;
8296 }
8297 }
8298 if (obj2) {
8299 {
8300 arg3 = (bool)(SWIG_As_bool(obj2));
8301 if (SWIG_arg_fail(3)) SWIG_fail;
8302 }
8303 }
8304 {
8305 PyThreadState* __tstate = wxPyBeginAllowThreads();
8306 result = (bool)(arg1)->Start(arg2,arg3);
8307
8308 wxPyEndAllowThreads(__tstate);
8309 if (PyErr_Occurred()) SWIG_fail;
8310 }
8311 {
8312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8313 }
8314 return resultobj;
8315 fail:
8316 return NULL;
8317 }
8318
8319
8320 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8321 PyObject *resultobj;
8322 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8323 PyObject * obj0 = 0 ;
8324 char *kwnames[] = {
8325 (char *) "self", NULL
8326 };
8327
8328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8330 if (SWIG_arg_fail(1)) SWIG_fail;
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 (arg1)->Stop();
8334
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 Py_INCREF(Py_None); resultobj = Py_None;
8339 return resultobj;
8340 fail:
8341 return NULL;
8342 }
8343
8344
8345 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8346 PyObject *resultobj;
8347 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8348 bool result;
8349 PyObject * obj0 = 0 ;
8350 char *kwnames[] = {
8351 (char *) "self", NULL
8352 };
8353
8354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8356 if (SWIG_arg_fail(1)) SWIG_fail;
8357 {
8358 PyThreadState* __tstate = wxPyBeginAllowThreads();
8359 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8360
8361 wxPyEndAllowThreads(__tstate);
8362 if (PyErr_Occurred()) SWIG_fail;
8363 }
8364 {
8365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8366 }
8367 return resultobj;
8368 fail:
8369 return NULL;
8370 }
8371
8372
8373 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8374 PyObject *resultobj;
8375 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8376 int result;
8377 PyObject * obj0 = 0 ;
8378 char *kwnames[] = {
8379 (char *) "self", NULL
8380 };
8381
8382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8384 if (SWIG_arg_fail(1)) SWIG_fail;
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8388
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 {
8393 resultobj = SWIG_From_int((int)(result));
8394 }
8395 return resultobj;
8396 fail:
8397 return NULL;
8398 }
8399
8400
8401 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8402 PyObject *resultobj;
8403 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8404 bool result;
8405 PyObject * obj0 = 0 ;
8406 char *kwnames[] = {
8407 (char *) "self", NULL
8408 };
8409
8410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8412 if (SWIG_arg_fail(1)) SWIG_fail;
8413 {
8414 PyThreadState* __tstate = wxPyBeginAllowThreads();
8415 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8416
8417 wxPyEndAllowThreads(__tstate);
8418 if (PyErr_Occurred()) SWIG_fail;
8419 }
8420 {
8421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8422 }
8423 return resultobj;
8424 fail:
8425 return NULL;
8426 }
8427
8428
8429 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8430 PyObject *resultobj;
8431 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8432 int result;
8433 PyObject * obj0 = 0 ;
8434 char *kwnames[] = {
8435 (char *) "self", NULL
8436 };
8437
8438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8440 if (SWIG_arg_fail(1)) SWIG_fail;
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 result = (int)((wxPyTimer const *)arg1)->GetId();
8444
8445 wxPyEndAllowThreads(__tstate);
8446 if (PyErr_Occurred()) SWIG_fail;
8447 }
8448 {
8449 resultobj = SWIG_From_int((int)(result));
8450 }
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8458 PyObject *obj;
8459 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8460 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8461 Py_INCREF(obj);
8462 return Py_BuildValue((char *)"");
8463 }
8464 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8465 PyObject *resultobj;
8466 int arg1 = (int) 0 ;
8467 int arg2 = (int) 0 ;
8468 wxTimerEvent *result;
8469 PyObject * obj0 = 0 ;
8470 PyObject * obj1 = 0 ;
8471 char *kwnames[] = {
8472 (char *) "timerid",(char *) "interval", NULL
8473 };
8474
8475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8476 if (obj0) {
8477 {
8478 arg1 = (int)(SWIG_As_int(obj0));
8479 if (SWIG_arg_fail(1)) SWIG_fail;
8480 }
8481 }
8482 if (obj1) {
8483 {
8484 arg2 = (int)(SWIG_As_int(obj1));
8485 if (SWIG_arg_fail(2)) SWIG_fail;
8486 }
8487 }
8488 {
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8491
8492 wxPyEndAllowThreads(__tstate);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8503 PyObject *resultobj;
8504 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8505 int result;
8506 PyObject * obj0 = 0 ;
8507 char *kwnames[] = {
8508 (char *) "self", NULL
8509 };
8510
8511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8513 if (SWIG_arg_fail(1)) SWIG_fail;
8514 {
8515 PyThreadState* __tstate = wxPyBeginAllowThreads();
8516 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8517
8518 wxPyEndAllowThreads(__tstate);
8519 if (PyErr_Occurred()) SWIG_fail;
8520 }
8521 {
8522 resultobj = SWIG_From_int((int)(result));
8523 }
8524 return resultobj;
8525 fail:
8526 return NULL;
8527 }
8528
8529
8530 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8531 PyObject *obj;
8532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8533 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8534 Py_INCREF(obj);
8535 return Py_BuildValue((char *)"");
8536 }
8537 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8538 PyObject *resultobj;
8539 wxTimer *arg1 = 0 ;
8540 wxTimerRunner *result;
8541 PyObject * obj0 = 0 ;
8542
8543 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8544 {
8545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8546 if (SWIG_arg_fail(1)) SWIG_fail;
8547 if (arg1 == NULL) {
8548 SWIG_null_ref("wxTimer");
8549 }
8550 if (SWIG_arg_fail(1)) SWIG_fail;
8551 }
8552 {
8553 if (!wxPyCheckForApp()) SWIG_fail;
8554 PyThreadState* __tstate = wxPyBeginAllowThreads();
8555 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8556
8557 wxPyEndAllowThreads(__tstate);
8558 if (PyErr_Occurred()) SWIG_fail;
8559 }
8560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8561 return resultobj;
8562 fail:
8563 return NULL;
8564 }
8565
8566
8567 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8568 PyObject *resultobj;
8569 wxTimer *arg1 = 0 ;
8570 int arg2 ;
8571 bool arg3 = (bool) false ;
8572 wxTimerRunner *result;
8573 PyObject * obj0 = 0 ;
8574 PyObject * obj1 = 0 ;
8575 PyObject * obj2 = 0 ;
8576
8577 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8578 {
8579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8580 if (SWIG_arg_fail(1)) SWIG_fail;
8581 if (arg1 == NULL) {
8582 SWIG_null_ref("wxTimer");
8583 }
8584 if (SWIG_arg_fail(1)) SWIG_fail;
8585 }
8586 {
8587 arg2 = (int)(SWIG_As_int(obj1));
8588 if (SWIG_arg_fail(2)) SWIG_fail;
8589 }
8590 if (obj2) {
8591 {
8592 arg3 = (bool)(SWIG_As_bool(obj2));
8593 if (SWIG_arg_fail(3)) SWIG_fail;
8594 }
8595 }
8596 {
8597 if (!wxPyCheckForApp()) SWIG_fail;
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8600
8601 wxPyEndAllowThreads(__tstate);
8602 if (PyErr_Occurred()) SWIG_fail;
8603 }
8604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8605 return resultobj;
8606 fail:
8607 return NULL;
8608 }
8609
8610
8611 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8612 int argc;
8613 PyObject *argv[4];
8614 int ii;
8615
8616 argc = PyObject_Length(args);
8617 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8618 argv[ii] = PyTuple_GetItem(args,ii);
8619 }
8620 if (argc == 1) {
8621 int _v;
8622 {
8623 void *ptr = 0;
8624 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8625 _v = 0;
8626 PyErr_Clear();
8627 } else {
8628 _v = (ptr != 0);
8629 }
8630 }
8631 if (_v) {
8632 return _wrap_new_TimerRunner__SWIG_0(self,args);
8633 }
8634 }
8635 if ((argc >= 2) && (argc <= 3)) {
8636 int _v;
8637 {
8638 void *ptr = 0;
8639 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8640 _v = 0;
8641 PyErr_Clear();
8642 } else {
8643 _v = (ptr != 0);
8644 }
8645 }
8646 if (_v) {
8647 _v = SWIG_Check_int(argv[1]);
8648 if (_v) {
8649 if (argc <= 2) {
8650 return _wrap_new_TimerRunner__SWIG_1(self,args);
8651 }
8652 _v = SWIG_Check_bool(argv[2]);
8653 if (_v) {
8654 return _wrap_new_TimerRunner__SWIG_1(self,args);
8655 }
8656 }
8657 }
8658 }
8659
8660 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8661 return NULL;
8662 }
8663
8664
8665 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8666 PyObject *resultobj;
8667 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8668 PyObject * obj0 = 0 ;
8669 char *kwnames[] = {
8670 (char *) "self", NULL
8671 };
8672
8673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8675 if (SWIG_arg_fail(1)) SWIG_fail;
8676 {
8677 PyThreadState* __tstate = wxPyBeginAllowThreads();
8678 delete arg1;
8679
8680 wxPyEndAllowThreads(__tstate);
8681 if (PyErr_Occurred()) SWIG_fail;
8682 }
8683 Py_INCREF(Py_None); resultobj = Py_None;
8684 return resultobj;
8685 fail:
8686 return NULL;
8687 }
8688
8689
8690 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8691 PyObject *resultobj;
8692 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8693 int arg2 ;
8694 bool arg3 = (bool) false ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 PyObject * obj2 = 0 ;
8698 char *kwnames[] = {
8699 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8700 };
8701
8702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8704 if (SWIG_arg_fail(1)) SWIG_fail;
8705 {
8706 arg2 = (int)(SWIG_As_int(obj1));
8707 if (SWIG_arg_fail(2)) SWIG_fail;
8708 }
8709 if (obj2) {
8710 {
8711 arg3 = (bool)(SWIG_As_bool(obj2));
8712 if (SWIG_arg_fail(3)) SWIG_fail;
8713 }
8714 }
8715 {
8716 PyThreadState* __tstate = wxPyBeginAllowThreads();
8717 (arg1)->Start(arg2,arg3);
8718
8719 wxPyEndAllowThreads(__tstate);
8720 if (PyErr_Occurred()) SWIG_fail;
8721 }
8722 Py_INCREF(Py_None); resultobj = Py_None;
8723 return resultobj;
8724 fail:
8725 return NULL;
8726 }
8727
8728
8729 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8730 PyObject *obj;
8731 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8732 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8733 Py_INCREF(obj);
8734 return Py_BuildValue((char *)"");
8735 }
8736 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8737 PyObject *resultobj;
8738 wxLog *result;
8739 char *kwnames[] = {
8740 NULL
8741 };
8742
8743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8744 {
8745 PyThreadState* __tstate = wxPyBeginAllowThreads();
8746 result = (wxLog *)new wxLog();
8747
8748 wxPyEndAllowThreads(__tstate);
8749 if (PyErr_Occurred()) SWIG_fail;
8750 }
8751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8752 return resultobj;
8753 fail:
8754 return NULL;
8755 }
8756
8757
8758 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8759 PyObject *resultobj;
8760 bool result;
8761 char *kwnames[] = {
8762 NULL
8763 };
8764
8765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8766 {
8767 PyThreadState* __tstate = wxPyBeginAllowThreads();
8768 result = (bool)wxLog::IsEnabled();
8769
8770 wxPyEndAllowThreads(__tstate);
8771 if (PyErr_Occurred()) SWIG_fail;
8772 }
8773 {
8774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8775 }
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj;
8784 bool arg1 = (bool) true ;
8785 bool result;
8786 PyObject * obj0 = 0 ;
8787 char *kwnames[] = {
8788 (char *) "doIt", NULL
8789 };
8790
8791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8792 if (obj0) {
8793 {
8794 arg1 = (bool)(SWIG_As_bool(obj0));
8795 if (SWIG_arg_fail(1)) SWIG_fail;
8796 }
8797 }
8798 {
8799 PyThreadState* __tstate = wxPyBeginAllowThreads();
8800 result = (bool)wxLog::EnableLogging(arg1);
8801
8802 wxPyEndAllowThreads(__tstate);
8803 if (PyErr_Occurred()) SWIG_fail;
8804 }
8805 {
8806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8807 }
8808 return resultobj;
8809 fail:
8810 return NULL;
8811 }
8812
8813
8814 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8815 PyObject *resultobj;
8816 wxLogLevel arg1 ;
8817 wxChar *arg2 = (wxChar *) 0 ;
8818 time_t arg3 ;
8819 PyObject * obj0 = 0 ;
8820 PyObject * obj1 = 0 ;
8821 PyObject * obj2 = 0 ;
8822 char *kwnames[] = {
8823 (char *) "level",(char *) "szString",(char *) "t", NULL
8824 };
8825
8826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8827 {
8828 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8829 if (SWIG_arg_fail(1)) SWIG_fail;
8830 }
8831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8832 if (SWIG_arg_fail(2)) SWIG_fail;
8833 {
8834 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8835 if (SWIG_arg_fail(3)) SWIG_fail;
8836 }
8837 {
8838 PyThreadState* __tstate = wxPyBeginAllowThreads();
8839 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8840
8841 wxPyEndAllowThreads(__tstate);
8842 if (PyErr_Occurred()) SWIG_fail;
8843 }
8844 Py_INCREF(Py_None); resultobj = Py_None;
8845 return resultobj;
8846 fail:
8847 return NULL;
8848 }
8849
8850
8851 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8852 PyObject *resultobj;
8853 wxLog *arg1 = (wxLog *) 0 ;
8854 PyObject * obj0 = 0 ;
8855 char *kwnames[] = {
8856 (char *) "self", NULL
8857 };
8858
8859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8861 if (SWIG_arg_fail(1)) SWIG_fail;
8862 {
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 (arg1)->Flush();
8865
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 Py_INCREF(Py_None); resultobj = Py_None;
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj;
8878 char *kwnames[] = {
8879 NULL
8880 };
8881
8882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 wxLog::FlushActive();
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_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8898 PyObject *resultobj;
8899 wxLog *result;
8900 char *kwnames[] = {
8901 NULL
8902 };
8903
8904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8905 {
8906 PyThreadState* __tstate = wxPyBeginAllowThreads();
8907 result = (wxLog *)wxLog::GetActiveTarget();
8908
8909 wxPyEndAllowThreads(__tstate);
8910 if (PyErr_Occurred()) SWIG_fail;
8911 }
8912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8913 return resultobj;
8914 fail:
8915 return NULL;
8916 }
8917
8918
8919 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8920 PyObject *resultobj;
8921 wxLog *arg1 = (wxLog *) 0 ;
8922 wxLog *result;
8923 PyObject * obj0 = 0 ;
8924 char *kwnames[] = {
8925 (char *) "pLogger", NULL
8926 };
8927
8928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8930 if (SWIG_arg_fail(1)) SWIG_fail;
8931 {
8932 PyThreadState* __tstate = wxPyBeginAllowThreads();
8933 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8934
8935 wxPyEndAllowThreads(__tstate);
8936 if (PyErr_Occurred()) SWIG_fail;
8937 }
8938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj;
8947 char *kwnames[] = {
8948 NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 wxLog::Suspend();
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 Py_INCREF(Py_None); resultobj = Py_None;
8960 return resultobj;
8961 fail:
8962 return NULL;
8963 }
8964
8965
8966 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8967 PyObject *resultobj;
8968 char *kwnames[] = {
8969 NULL
8970 };
8971
8972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8973 {
8974 PyThreadState* __tstate = wxPyBeginAllowThreads();
8975 wxLog::Resume();
8976
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 Py_INCREF(Py_None); resultobj = Py_None;
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8988 PyObject *resultobj;
8989 bool arg1 = (bool) true ;
8990 PyObject * obj0 = 0 ;
8991 char *kwnames[] = {
8992 (char *) "bVerbose", NULL
8993 };
8994
8995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8996 if (obj0) {
8997 {
8998 arg1 = (bool)(SWIG_As_bool(obj0));
8999 if (SWIG_arg_fail(1)) SWIG_fail;
9000 }
9001 }
9002 {
9003 PyThreadState* __tstate = wxPyBeginAllowThreads();
9004 wxLog::SetVerbose(arg1);
9005
9006 wxPyEndAllowThreads(__tstate);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 Py_INCREF(Py_None); resultobj = Py_None;
9010 return resultobj;
9011 fail:
9012 return NULL;
9013 }
9014
9015
9016 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9017 PyObject *resultobj;
9018 wxLogLevel arg1 ;
9019 PyObject * obj0 = 0 ;
9020 char *kwnames[] = {
9021 (char *) "logLevel", NULL
9022 };
9023
9024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9025 {
9026 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9027 if (SWIG_arg_fail(1)) SWIG_fail;
9028 }
9029 {
9030 PyThreadState* __tstate = wxPyBeginAllowThreads();
9031 wxLog::SetLogLevel(arg1);
9032
9033 wxPyEndAllowThreads(__tstate);
9034 if (PyErr_Occurred()) SWIG_fail;
9035 }
9036 Py_INCREF(Py_None); resultobj = Py_None;
9037 return resultobj;
9038 fail:
9039 return NULL;
9040 }
9041
9042
9043 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj;
9045 char *kwnames[] = {
9046 NULL
9047 };
9048
9049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9050 {
9051 PyThreadState* __tstate = wxPyBeginAllowThreads();
9052 wxLog::DontCreateOnDemand();
9053
9054 wxPyEndAllowThreads(__tstate);
9055 if (PyErr_Occurred()) SWIG_fail;
9056 }
9057 Py_INCREF(Py_None); resultobj = Py_None;
9058 return resultobj;
9059 fail:
9060 return NULL;
9061 }
9062
9063
9064 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9065 PyObject *resultobj;
9066 wxTraceMask arg1 ;
9067 PyObject * obj0 = 0 ;
9068 char *kwnames[] = {
9069 (char *) "ulMask", NULL
9070 };
9071
9072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9073 {
9074 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9075 if (SWIG_arg_fail(1)) SWIG_fail;
9076 }
9077 {
9078 PyThreadState* __tstate = wxPyBeginAllowThreads();
9079 wxLog::SetTraceMask(arg1);
9080
9081 wxPyEndAllowThreads(__tstate);
9082 if (PyErr_Occurred()) SWIG_fail;
9083 }
9084 Py_INCREF(Py_None); resultobj = Py_None;
9085 return resultobj;
9086 fail:
9087 return NULL;
9088 }
9089
9090
9091 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9092 PyObject *resultobj;
9093 wxString *arg1 = 0 ;
9094 bool temp1 = false ;
9095 PyObject * obj0 = 0 ;
9096 char *kwnames[] = {
9097 (char *) "str", NULL
9098 };
9099
9100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9101 {
9102 arg1 = wxString_in_helper(obj0);
9103 if (arg1 == NULL) SWIG_fail;
9104 temp1 = true;
9105 }
9106 {
9107 PyThreadState* __tstate = wxPyBeginAllowThreads();
9108 wxLog::AddTraceMask((wxString const &)*arg1);
9109
9110 wxPyEndAllowThreads(__tstate);
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 Py_INCREF(Py_None); resultobj = Py_None;
9114 {
9115 if (temp1)
9116 delete arg1;
9117 }
9118 return resultobj;
9119 fail:
9120 {
9121 if (temp1)
9122 delete arg1;
9123 }
9124 return NULL;
9125 }
9126
9127
9128 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9129 PyObject *resultobj;
9130 wxString *arg1 = 0 ;
9131 bool temp1 = false ;
9132 PyObject * obj0 = 0 ;
9133 char *kwnames[] = {
9134 (char *) "str", NULL
9135 };
9136
9137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9138 {
9139 arg1 = wxString_in_helper(obj0);
9140 if (arg1 == NULL) SWIG_fail;
9141 temp1 = true;
9142 }
9143 {
9144 PyThreadState* __tstate = wxPyBeginAllowThreads();
9145 wxLog::RemoveTraceMask((wxString const &)*arg1);
9146
9147 wxPyEndAllowThreads(__tstate);
9148 if (PyErr_Occurred()) SWIG_fail;
9149 }
9150 Py_INCREF(Py_None); resultobj = Py_None;
9151 {
9152 if (temp1)
9153 delete arg1;
9154 }
9155 return resultobj;
9156 fail:
9157 {
9158 if (temp1)
9159 delete arg1;
9160 }
9161 return NULL;
9162 }
9163
9164
9165 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9166 PyObject *resultobj;
9167 char *kwnames[] = {
9168 NULL
9169 };
9170
9171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 wxLog::ClearTraceMasks();
9175
9176 wxPyEndAllowThreads(__tstate);
9177 if (PyErr_Occurred()) SWIG_fail;
9178 }
9179 Py_INCREF(Py_None); resultobj = Py_None;
9180 return resultobj;
9181 fail:
9182 return NULL;
9183 }
9184
9185
9186 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9187 PyObject *resultobj;
9188 wxArrayString *result;
9189 char *kwnames[] = {
9190 NULL
9191 };
9192
9193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9194 {
9195 PyThreadState* __tstate = wxPyBeginAllowThreads();
9196 {
9197 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9198 result = (wxArrayString *) &_result_ref;
9199 }
9200
9201 wxPyEndAllowThreads(__tstate);
9202 if (PyErr_Occurred()) SWIG_fail;
9203 }
9204 {
9205 resultobj = wxArrayString2PyList_helper(*result);
9206 }
9207 return resultobj;
9208 fail:
9209 return NULL;
9210 }
9211
9212
9213 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9214 PyObject *resultobj;
9215 wxChar *arg1 = (wxChar *) 0 ;
9216 PyObject * obj0 = 0 ;
9217 char *kwnames[] = {
9218 (char *) "ts", NULL
9219 };
9220
9221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9223 if (SWIG_arg_fail(1)) SWIG_fail;
9224 {
9225 PyThreadState* __tstate = wxPyBeginAllowThreads();
9226 wxLog::SetTimestamp((wxChar const *)arg1);
9227
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 Py_INCREF(Py_None); resultobj = Py_None;
9232 return resultobj;
9233 fail:
9234 return NULL;
9235 }
9236
9237
9238 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9239 PyObject *resultobj;
9240 bool result;
9241 char *kwnames[] = {
9242 NULL
9243 };
9244
9245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9246 {
9247 PyThreadState* __tstate = wxPyBeginAllowThreads();
9248 result = (bool)wxLog::GetVerbose();
9249
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 {
9254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9255 }
9256 return resultobj;
9257 fail:
9258 return NULL;
9259 }
9260
9261
9262 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9263 PyObject *resultobj;
9264 wxTraceMask result;
9265 char *kwnames[] = {
9266 NULL
9267 };
9268
9269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 result = (wxTraceMask)wxLog::GetTraceMask();
9273
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 {
9278 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9279 }
9280 return resultobj;
9281 fail:
9282 return NULL;
9283 }
9284
9285
9286 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9287 PyObject *resultobj;
9288 wxChar *arg1 = (wxChar *) 0 ;
9289 bool result;
9290 PyObject * obj0 = 0 ;
9291 char *kwnames[] = {
9292 (char *) "mask", NULL
9293 };
9294
9295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9297 if (SWIG_arg_fail(1)) SWIG_fail;
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 {
9306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9307 }
9308 return resultobj;
9309 fail:
9310 return NULL;
9311 }
9312
9313
9314 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9315 PyObject *resultobj;
9316 wxLogLevel result;
9317 char *kwnames[] = {
9318 NULL
9319 };
9320
9321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9322 {
9323 PyThreadState* __tstate = wxPyBeginAllowThreads();
9324 result = (wxLogLevel)wxLog::GetLogLevel();
9325
9326 wxPyEndAllowThreads(__tstate);
9327 if (PyErr_Occurred()) SWIG_fail;
9328 }
9329 {
9330 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9331 }
9332 return resultobj;
9333 fail:
9334 return NULL;
9335 }
9336
9337
9338 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9339 PyObject *resultobj;
9340 wxChar *result;
9341 char *kwnames[] = {
9342 NULL
9343 };
9344
9345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 result = (wxChar *)wxLog::GetTimestamp();
9349
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9361 PyObject *resultobj;
9362 wxString result;
9363 char *kwnames[] = {
9364 NULL
9365 };
9366
9367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9368 {
9369 PyThreadState* __tstate = wxPyBeginAllowThreads();
9370 result = Log_TimeStamp();
9371
9372 wxPyEndAllowThreads(__tstate);
9373 if (PyErr_Occurred()) SWIG_fail;
9374 }
9375 {
9376 #if wxUSE_UNICODE
9377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9378 #else
9379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9380 #endif
9381 }
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9389 PyObject *resultobj;
9390 wxLog *arg1 = (wxLog *) 0 ;
9391 PyObject * obj0 = 0 ;
9392 char *kwnames[] = {
9393 (char *) "self", NULL
9394 };
9395
9396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9398 if (SWIG_arg_fail(1)) SWIG_fail;
9399 {
9400 PyThreadState* __tstate = wxPyBeginAllowThreads();
9401 wxLog_Destroy(arg1);
9402
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 Py_INCREF(Py_None); resultobj = Py_None;
9407 return resultobj;
9408 fail:
9409 return NULL;
9410 }
9411
9412
9413 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9414 PyObject *obj;
9415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9416 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9417 Py_INCREF(obj);
9418 return Py_BuildValue((char *)"");
9419 }
9420 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9421 PyObject *resultobj;
9422 wxLogStderr *result;
9423 char *kwnames[] = {
9424 NULL
9425 };
9426
9427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9428 {
9429 PyThreadState* __tstate = wxPyBeginAllowThreads();
9430 result = (wxLogStderr *)new wxLogStderr();
9431
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9436 return resultobj;
9437 fail:
9438 return NULL;
9439 }
9440
9441
9442 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9443 PyObject *obj;
9444 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9445 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9446 Py_INCREF(obj);
9447 return Py_BuildValue((char *)"");
9448 }
9449 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9450 PyObject *resultobj;
9451 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9452 wxLogTextCtrl *result;
9453 PyObject * obj0 = 0 ;
9454 char *kwnames[] = {
9455 (char *) "pTextCtrl", NULL
9456 };
9457
9458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9460 if (SWIG_arg_fail(1)) SWIG_fail;
9461 {
9462 PyThreadState* __tstate = wxPyBeginAllowThreads();
9463 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9464
9465 wxPyEndAllowThreads(__tstate);
9466 if (PyErr_Occurred()) SWIG_fail;
9467 }
9468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9469 return resultobj;
9470 fail:
9471 return NULL;
9472 }
9473
9474
9475 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9476 PyObject *obj;
9477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9478 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9479 Py_INCREF(obj);
9480 return Py_BuildValue((char *)"");
9481 }
9482 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9483 PyObject *resultobj;
9484 wxLogGui *result;
9485 char *kwnames[] = {
9486 NULL
9487 };
9488
9489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9490 {
9491 PyThreadState* __tstate = wxPyBeginAllowThreads();
9492 result = (wxLogGui *)new wxLogGui();
9493
9494 wxPyEndAllowThreads(__tstate);
9495 if (PyErr_Occurred()) SWIG_fail;
9496 }
9497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9498 return resultobj;
9499 fail:
9500 return NULL;
9501 }
9502
9503
9504 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9505 PyObject *obj;
9506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9507 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9508 Py_INCREF(obj);
9509 return Py_BuildValue((char *)"");
9510 }
9511 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9512 PyObject *resultobj;
9513 wxFrame *arg1 = (wxFrame *) 0 ;
9514 wxString *arg2 = 0 ;
9515 bool arg3 = (bool) true ;
9516 bool arg4 = (bool) true ;
9517 wxLogWindow *result;
9518 bool temp2 = false ;
9519 PyObject * obj0 = 0 ;
9520 PyObject * obj1 = 0 ;
9521 PyObject * obj2 = 0 ;
9522 PyObject * obj3 = 0 ;
9523 char *kwnames[] = {
9524 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9525 };
9526
9527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9529 if (SWIG_arg_fail(1)) SWIG_fail;
9530 {
9531 arg2 = wxString_in_helper(obj1);
9532 if (arg2 == NULL) SWIG_fail;
9533 temp2 = true;
9534 }
9535 if (obj2) {
9536 {
9537 arg3 = (bool)(SWIG_As_bool(obj2));
9538 if (SWIG_arg_fail(3)) SWIG_fail;
9539 }
9540 }
9541 if (obj3) {
9542 {
9543 arg4 = (bool)(SWIG_As_bool(obj3));
9544 if (SWIG_arg_fail(4)) SWIG_fail;
9545 }
9546 }
9547 {
9548 PyThreadState* __tstate = wxPyBeginAllowThreads();
9549 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9550
9551 wxPyEndAllowThreads(__tstate);
9552 if (PyErr_Occurred()) SWIG_fail;
9553 }
9554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9555 {
9556 if (temp2)
9557 delete arg2;
9558 }
9559 return resultobj;
9560 fail:
9561 {
9562 if (temp2)
9563 delete arg2;
9564 }
9565 return NULL;
9566 }
9567
9568
9569 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9570 PyObject *resultobj;
9571 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9572 bool arg2 = (bool) true ;
9573 PyObject * obj0 = 0 ;
9574 PyObject * obj1 = 0 ;
9575 char *kwnames[] = {
9576 (char *) "self",(char *) "bShow", NULL
9577 };
9578
9579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9581 if (SWIG_arg_fail(1)) SWIG_fail;
9582 if (obj1) {
9583 {
9584 arg2 = (bool)(SWIG_As_bool(obj1));
9585 if (SWIG_arg_fail(2)) SWIG_fail;
9586 }
9587 }
9588 {
9589 PyThreadState* __tstate = wxPyBeginAllowThreads();
9590 (arg1)->Show(arg2);
9591
9592 wxPyEndAllowThreads(__tstate);
9593 if (PyErr_Occurred()) SWIG_fail;
9594 }
9595 Py_INCREF(Py_None); resultobj = Py_None;
9596 return resultobj;
9597 fail:
9598 return NULL;
9599 }
9600
9601
9602 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9603 PyObject *resultobj;
9604 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9605 wxFrame *result;
9606 PyObject * obj0 = 0 ;
9607 char *kwnames[] = {
9608 (char *) "self", NULL
9609 };
9610
9611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9613 if (SWIG_arg_fail(1)) SWIG_fail;
9614 {
9615 PyThreadState* __tstate = wxPyBeginAllowThreads();
9616 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9617
9618 wxPyEndAllowThreads(__tstate);
9619 if (PyErr_Occurred()) SWIG_fail;
9620 }
9621 {
9622 resultobj = wxPyMake_wxObject(result, 0);
9623 }
9624 return resultobj;
9625 fail:
9626 return NULL;
9627 }
9628
9629
9630 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9631 PyObject *resultobj;
9632 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9633 wxLog *result;
9634 PyObject * obj0 = 0 ;
9635 char *kwnames[] = {
9636 (char *) "self", NULL
9637 };
9638
9639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9641 if (SWIG_arg_fail(1)) SWIG_fail;
9642 {
9643 PyThreadState* __tstate = wxPyBeginAllowThreads();
9644 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9645
9646 wxPyEndAllowThreads(__tstate);
9647 if (PyErr_Occurred()) SWIG_fail;
9648 }
9649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9650 return resultobj;
9651 fail:
9652 return NULL;
9653 }
9654
9655
9656 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9657 PyObject *resultobj;
9658 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9659 bool result;
9660 PyObject * obj0 = 0 ;
9661 char *kwnames[] = {
9662 (char *) "self", NULL
9663 };
9664
9665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9667 if (SWIG_arg_fail(1)) SWIG_fail;
9668 {
9669 PyThreadState* __tstate = wxPyBeginAllowThreads();
9670 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9671
9672 wxPyEndAllowThreads(__tstate);
9673 if (PyErr_Occurred()) SWIG_fail;
9674 }
9675 {
9676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9677 }
9678 return resultobj;
9679 fail:
9680 return NULL;
9681 }
9682
9683
9684 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9685 PyObject *resultobj;
9686 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9687 bool arg2 ;
9688 PyObject * obj0 = 0 ;
9689 PyObject * obj1 = 0 ;
9690 char *kwnames[] = {
9691 (char *) "self",(char *) "bDoPass", NULL
9692 };
9693
9694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9696 if (SWIG_arg_fail(1)) SWIG_fail;
9697 {
9698 arg2 = (bool)(SWIG_As_bool(obj1));
9699 if (SWIG_arg_fail(2)) SWIG_fail;
9700 }
9701 {
9702 PyThreadState* __tstate = wxPyBeginAllowThreads();
9703 (arg1)->PassMessages(arg2);
9704
9705 wxPyEndAllowThreads(__tstate);
9706 if (PyErr_Occurred()) SWIG_fail;
9707 }
9708 Py_INCREF(Py_None); resultobj = Py_None;
9709 return resultobj;
9710 fail:
9711 return NULL;
9712 }
9713
9714
9715 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9716 PyObject *obj;
9717 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9718 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9719 Py_INCREF(obj);
9720 return Py_BuildValue((char *)"");
9721 }
9722 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9723 PyObject *resultobj;
9724 wxLog *arg1 = (wxLog *) 0 ;
9725 wxLogChain *result;
9726 PyObject * obj0 = 0 ;
9727 char *kwnames[] = {
9728 (char *) "logger", NULL
9729 };
9730
9731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9733 if (SWIG_arg_fail(1)) SWIG_fail;
9734 {
9735 PyThreadState* __tstate = wxPyBeginAllowThreads();
9736 result = (wxLogChain *)new wxLogChain(arg1);
9737
9738 wxPyEndAllowThreads(__tstate);
9739 if (PyErr_Occurred()) SWIG_fail;
9740 }
9741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9742 return resultobj;
9743 fail:
9744 return NULL;
9745 }
9746
9747
9748 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9749 PyObject *resultobj;
9750 wxLogChain *arg1 = (wxLogChain *) 0 ;
9751 wxLog *arg2 = (wxLog *) 0 ;
9752 PyObject * obj0 = 0 ;
9753 PyObject * obj1 = 0 ;
9754 char *kwnames[] = {
9755 (char *) "self",(char *) "logger", NULL
9756 };
9757
9758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9760 if (SWIG_arg_fail(1)) SWIG_fail;
9761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9762 if (SWIG_arg_fail(2)) SWIG_fail;
9763 {
9764 PyThreadState* __tstate = wxPyBeginAllowThreads();
9765 (arg1)->SetLog(arg2);
9766
9767 wxPyEndAllowThreads(__tstate);
9768 if (PyErr_Occurred()) SWIG_fail;
9769 }
9770 Py_INCREF(Py_None); resultobj = Py_None;
9771 return resultobj;
9772 fail:
9773 return NULL;
9774 }
9775
9776
9777 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9778 PyObject *resultobj;
9779 wxLogChain *arg1 = (wxLogChain *) 0 ;
9780 bool arg2 ;
9781 PyObject * obj0 = 0 ;
9782 PyObject * obj1 = 0 ;
9783 char *kwnames[] = {
9784 (char *) "self",(char *) "bDoPass", NULL
9785 };
9786
9787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9789 if (SWIG_arg_fail(1)) SWIG_fail;
9790 {
9791 arg2 = (bool)(SWIG_As_bool(obj1));
9792 if (SWIG_arg_fail(2)) SWIG_fail;
9793 }
9794 {
9795 PyThreadState* __tstate = wxPyBeginAllowThreads();
9796 (arg1)->PassMessages(arg2);
9797
9798 wxPyEndAllowThreads(__tstate);
9799 if (PyErr_Occurred()) SWIG_fail;
9800 }
9801 Py_INCREF(Py_None); resultobj = Py_None;
9802 return resultobj;
9803 fail:
9804 return NULL;
9805 }
9806
9807
9808 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9809 PyObject *resultobj;
9810 wxLogChain *arg1 = (wxLogChain *) 0 ;
9811 bool result;
9812 PyObject * obj0 = 0 ;
9813 char *kwnames[] = {
9814 (char *) "self", NULL
9815 };
9816
9817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9819 if (SWIG_arg_fail(1)) SWIG_fail;
9820 {
9821 PyThreadState* __tstate = wxPyBeginAllowThreads();
9822 result = (bool)(arg1)->IsPassingMessages();
9823
9824 wxPyEndAllowThreads(__tstate);
9825 if (PyErr_Occurred()) SWIG_fail;
9826 }
9827 {
9828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9829 }
9830 return resultobj;
9831 fail:
9832 return NULL;
9833 }
9834
9835
9836 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9837 PyObject *resultobj;
9838 wxLogChain *arg1 = (wxLogChain *) 0 ;
9839 wxLog *result;
9840 PyObject * obj0 = 0 ;
9841 char *kwnames[] = {
9842 (char *) "self", NULL
9843 };
9844
9845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9847 if (SWIG_arg_fail(1)) SWIG_fail;
9848 {
9849 PyThreadState* __tstate = wxPyBeginAllowThreads();
9850 result = (wxLog *)(arg1)->GetOldLog();
9851
9852 wxPyEndAllowThreads(__tstate);
9853 if (PyErr_Occurred()) SWIG_fail;
9854 }
9855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9856 return resultobj;
9857 fail:
9858 return NULL;
9859 }
9860
9861
9862 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9863 PyObject *obj;
9864 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9865 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9866 Py_INCREF(obj);
9867 return Py_BuildValue((char *)"");
9868 }
9869 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj;
9871 unsigned long result;
9872 char *kwnames[] = {
9873 NULL
9874 };
9875
9876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9877 {
9878 PyThreadState* __tstate = wxPyBeginAllowThreads();
9879 result = (unsigned long)wxSysErrorCode();
9880
9881 wxPyEndAllowThreads(__tstate);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 {
9885 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9886 }
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9894 PyObject *resultobj;
9895 unsigned long arg1 = (unsigned long) 0 ;
9896 wxString result;
9897 PyObject * obj0 = 0 ;
9898 char *kwnames[] = {
9899 (char *) "nErrCode", NULL
9900 };
9901
9902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9903 if (obj0) {
9904 {
9905 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9906 if (SWIG_arg_fail(1)) SWIG_fail;
9907 }
9908 }
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = wxSysErrorMsg(arg1);
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 #if wxUSE_UNICODE
9918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9919 #else
9920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9921 #endif
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9930 PyObject *resultobj;
9931 wxString *arg1 = 0 ;
9932 bool temp1 = false ;
9933 PyObject * obj0 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "msg", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9939 {
9940 arg1 = wxString_in_helper(obj0);
9941 if (arg1 == NULL) SWIG_fail;
9942 temp1 = true;
9943 }
9944 {
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 wxPyLogFatalError((wxString const &)*arg1);
9947
9948 wxPyEndAllowThreads(__tstate);
9949 if (PyErr_Occurred()) SWIG_fail;
9950 }
9951 Py_INCREF(Py_None); resultobj = Py_None;
9952 {
9953 if (temp1)
9954 delete arg1;
9955 }
9956 return resultobj;
9957 fail:
9958 {
9959 if (temp1)
9960 delete arg1;
9961 }
9962 return NULL;
9963 }
9964
9965
9966 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9967 PyObject *resultobj;
9968 wxString *arg1 = 0 ;
9969 bool temp1 = false ;
9970 PyObject * obj0 = 0 ;
9971 char *kwnames[] = {
9972 (char *) "msg", NULL
9973 };
9974
9975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9976 {
9977 arg1 = wxString_in_helper(obj0);
9978 if (arg1 == NULL) SWIG_fail;
9979 temp1 = true;
9980 }
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 wxPyLogError((wxString const &)*arg1);
9984
9985 wxPyEndAllowThreads(__tstate);
9986 if (PyErr_Occurred()) SWIG_fail;
9987 }
9988 Py_INCREF(Py_None); resultobj = Py_None;
9989 {
9990 if (temp1)
9991 delete arg1;
9992 }
9993 return resultobj;
9994 fail:
9995 {
9996 if (temp1)
9997 delete arg1;
9998 }
9999 return NULL;
10000 }
10001
10002
10003 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10004 PyObject *resultobj;
10005 wxString *arg1 = 0 ;
10006 bool temp1 = false ;
10007 PyObject * obj0 = 0 ;
10008 char *kwnames[] = {
10009 (char *) "msg", NULL
10010 };
10011
10012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10013 {
10014 arg1 = wxString_in_helper(obj0);
10015 if (arg1 == NULL) SWIG_fail;
10016 temp1 = true;
10017 }
10018 {
10019 PyThreadState* __tstate = wxPyBeginAllowThreads();
10020 wxPyLogWarning((wxString const &)*arg1);
10021
10022 wxPyEndAllowThreads(__tstate);
10023 if (PyErr_Occurred()) SWIG_fail;
10024 }
10025 Py_INCREF(Py_None); resultobj = Py_None;
10026 {
10027 if (temp1)
10028 delete arg1;
10029 }
10030 return resultobj;
10031 fail:
10032 {
10033 if (temp1)
10034 delete arg1;
10035 }
10036 return NULL;
10037 }
10038
10039
10040 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10041 PyObject *resultobj;
10042 wxString *arg1 = 0 ;
10043 bool temp1 = false ;
10044 PyObject * obj0 = 0 ;
10045 char *kwnames[] = {
10046 (char *) "msg", NULL
10047 };
10048
10049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10050 {
10051 arg1 = wxString_in_helper(obj0);
10052 if (arg1 == NULL) SWIG_fail;
10053 temp1 = true;
10054 }
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 wxPyLogMessage((wxString const &)*arg1);
10058
10059 wxPyEndAllowThreads(__tstate);
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 Py_INCREF(Py_None); resultobj = Py_None;
10063 {
10064 if (temp1)
10065 delete arg1;
10066 }
10067 return resultobj;
10068 fail:
10069 {
10070 if (temp1)
10071 delete arg1;
10072 }
10073 return NULL;
10074 }
10075
10076
10077 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10078 PyObject *resultobj;
10079 wxString *arg1 = 0 ;
10080 bool temp1 = false ;
10081 PyObject * obj0 = 0 ;
10082 char *kwnames[] = {
10083 (char *) "msg", NULL
10084 };
10085
10086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10087 {
10088 arg1 = wxString_in_helper(obj0);
10089 if (arg1 == NULL) SWIG_fail;
10090 temp1 = true;
10091 }
10092 {
10093 PyThreadState* __tstate = wxPyBeginAllowThreads();
10094 wxPyLogInfo((wxString const &)*arg1);
10095
10096 wxPyEndAllowThreads(__tstate);
10097 if (PyErr_Occurred()) SWIG_fail;
10098 }
10099 Py_INCREF(Py_None); resultobj = Py_None;
10100 {
10101 if (temp1)
10102 delete arg1;
10103 }
10104 return resultobj;
10105 fail:
10106 {
10107 if (temp1)
10108 delete arg1;
10109 }
10110 return NULL;
10111 }
10112
10113
10114 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10115 PyObject *resultobj;
10116 wxString *arg1 = 0 ;
10117 bool temp1 = false ;
10118 PyObject * obj0 = 0 ;
10119 char *kwnames[] = {
10120 (char *) "msg", NULL
10121 };
10122
10123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10124 {
10125 arg1 = wxString_in_helper(obj0);
10126 if (arg1 == NULL) SWIG_fail;
10127 temp1 = true;
10128 }
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 wxPyLogDebug((wxString const &)*arg1);
10132
10133 wxPyEndAllowThreads(__tstate);
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 Py_INCREF(Py_None); resultobj = Py_None;
10137 {
10138 if (temp1)
10139 delete arg1;
10140 }
10141 return resultobj;
10142 fail:
10143 {
10144 if (temp1)
10145 delete arg1;
10146 }
10147 return NULL;
10148 }
10149
10150
10151 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj;
10153 wxString *arg1 = 0 ;
10154 bool temp1 = false ;
10155 PyObject * obj0 = 0 ;
10156 char *kwnames[] = {
10157 (char *) "msg", NULL
10158 };
10159
10160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10161 {
10162 arg1 = wxString_in_helper(obj0);
10163 if (arg1 == NULL) SWIG_fail;
10164 temp1 = true;
10165 }
10166 {
10167 PyThreadState* __tstate = wxPyBeginAllowThreads();
10168 wxPyLogVerbose((wxString const &)*arg1);
10169
10170 wxPyEndAllowThreads(__tstate);
10171 if (PyErr_Occurred()) SWIG_fail;
10172 }
10173 Py_INCREF(Py_None); resultobj = Py_None;
10174 {
10175 if (temp1)
10176 delete arg1;
10177 }
10178 return resultobj;
10179 fail:
10180 {
10181 if (temp1)
10182 delete arg1;
10183 }
10184 return NULL;
10185 }
10186
10187
10188 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10189 PyObject *resultobj;
10190 wxString *arg1 = 0 ;
10191 bool temp1 = false ;
10192 PyObject * obj0 = 0 ;
10193 char *kwnames[] = {
10194 (char *) "msg", NULL
10195 };
10196
10197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10198 {
10199 arg1 = wxString_in_helper(obj0);
10200 if (arg1 == NULL) SWIG_fail;
10201 temp1 = true;
10202 }
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 wxPyLogStatus((wxString const &)*arg1);
10206
10207 wxPyEndAllowThreads(__tstate);
10208 if (PyErr_Occurred()) SWIG_fail;
10209 }
10210 Py_INCREF(Py_None); resultobj = Py_None;
10211 {
10212 if (temp1)
10213 delete arg1;
10214 }
10215 return resultobj;
10216 fail:
10217 {
10218 if (temp1)
10219 delete arg1;
10220 }
10221 return NULL;
10222 }
10223
10224
10225 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10226 PyObject *resultobj;
10227 wxFrame *arg1 = (wxFrame *) 0 ;
10228 wxString *arg2 = 0 ;
10229 bool temp2 = false ;
10230 PyObject * obj0 = 0 ;
10231 PyObject * obj1 = 0 ;
10232 char *kwnames[] = {
10233 (char *) "pFrame",(char *) "msg", NULL
10234 };
10235
10236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10238 if (SWIG_arg_fail(1)) SWIG_fail;
10239 {
10240 arg2 = wxString_in_helper(obj1);
10241 if (arg2 == NULL) SWIG_fail;
10242 temp2 = true;
10243 }
10244 {
10245 PyThreadState* __tstate = wxPyBeginAllowThreads();
10246 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10247
10248 wxPyEndAllowThreads(__tstate);
10249 if (PyErr_Occurred()) SWIG_fail;
10250 }
10251 Py_INCREF(Py_None); resultobj = Py_None;
10252 {
10253 if (temp2)
10254 delete arg2;
10255 }
10256 return resultobj;
10257 fail:
10258 {
10259 if (temp2)
10260 delete arg2;
10261 }
10262 return NULL;
10263 }
10264
10265
10266 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10267 PyObject *resultobj;
10268 wxString *arg1 = 0 ;
10269 bool temp1 = false ;
10270 PyObject * obj0 = 0 ;
10271 char *kwnames[] = {
10272 (char *) "msg", NULL
10273 };
10274
10275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10276 {
10277 arg1 = wxString_in_helper(obj0);
10278 if (arg1 == NULL) SWIG_fail;
10279 temp1 = true;
10280 }
10281 {
10282 PyThreadState* __tstate = wxPyBeginAllowThreads();
10283 wxPyLogSysError((wxString const &)*arg1);
10284
10285 wxPyEndAllowThreads(__tstate);
10286 if (PyErr_Occurred()) SWIG_fail;
10287 }
10288 Py_INCREF(Py_None); resultobj = Py_None;
10289 {
10290 if (temp1)
10291 delete arg1;
10292 }
10293 return resultobj;
10294 fail:
10295 {
10296 if (temp1)
10297 delete arg1;
10298 }
10299 return NULL;
10300 }
10301
10302
10303 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10304 PyObject *resultobj;
10305 unsigned long arg1 ;
10306 wxString *arg2 = 0 ;
10307 bool temp2 = false ;
10308 PyObject * obj0 = 0 ;
10309 PyObject * obj1 = 0 ;
10310 char *kwnames[] = {
10311 (char *) "level",(char *) "msg", NULL
10312 };
10313
10314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10315 {
10316 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10317 if (SWIG_arg_fail(1)) SWIG_fail;
10318 }
10319 {
10320 arg2 = wxString_in_helper(obj1);
10321 if (arg2 == NULL) SWIG_fail;
10322 temp2 = true;
10323 }
10324 {
10325 PyThreadState* __tstate = wxPyBeginAllowThreads();
10326 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10327
10328 wxPyEndAllowThreads(__tstate);
10329 if (PyErr_Occurred()) SWIG_fail;
10330 }
10331 Py_INCREF(Py_None); resultobj = Py_None;
10332 {
10333 if (temp2)
10334 delete arg2;
10335 }
10336 return resultobj;
10337 fail:
10338 {
10339 if (temp2)
10340 delete arg2;
10341 }
10342 return NULL;
10343 }
10344
10345
10346 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10347 PyObject *resultobj;
10348 unsigned long arg1 ;
10349 wxString *arg2 = 0 ;
10350 bool temp2 = false ;
10351 PyObject * obj0 = 0 ;
10352 PyObject * obj1 = 0 ;
10353
10354 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10355 {
10356 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10357 if (SWIG_arg_fail(1)) SWIG_fail;
10358 }
10359 {
10360 arg2 = wxString_in_helper(obj1);
10361 if (arg2 == NULL) SWIG_fail;
10362 temp2 = true;
10363 }
10364 {
10365 PyThreadState* __tstate = wxPyBeginAllowThreads();
10366 wxPyLogTrace(arg1,(wxString const &)*arg2);
10367
10368 wxPyEndAllowThreads(__tstate);
10369 if (PyErr_Occurred()) SWIG_fail;
10370 }
10371 Py_INCREF(Py_None); resultobj = Py_None;
10372 {
10373 if (temp2)
10374 delete arg2;
10375 }
10376 return resultobj;
10377 fail:
10378 {
10379 if (temp2)
10380 delete arg2;
10381 }
10382 return NULL;
10383 }
10384
10385
10386 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10387 PyObject *resultobj;
10388 wxString *arg1 = 0 ;
10389 wxString *arg2 = 0 ;
10390 bool temp1 = false ;
10391 bool temp2 = false ;
10392 PyObject * obj0 = 0 ;
10393 PyObject * obj1 = 0 ;
10394
10395 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10396 {
10397 arg1 = wxString_in_helper(obj0);
10398 if (arg1 == NULL) SWIG_fail;
10399 temp1 = true;
10400 }
10401 {
10402 arg2 = wxString_in_helper(obj1);
10403 if (arg2 == NULL) SWIG_fail;
10404 temp2 = true;
10405 }
10406 {
10407 PyThreadState* __tstate = wxPyBeginAllowThreads();
10408 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10409
10410 wxPyEndAllowThreads(__tstate);
10411 if (PyErr_Occurred()) SWIG_fail;
10412 }
10413 Py_INCREF(Py_None); resultobj = Py_None;
10414 {
10415 if (temp1)
10416 delete arg1;
10417 }
10418 {
10419 if (temp2)
10420 delete arg2;
10421 }
10422 return resultobj;
10423 fail:
10424 {
10425 if (temp1)
10426 delete arg1;
10427 }
10428 {
10429 if (temp2)
10430 delete arg2;
10431 }
10432 return NULL;
10433 }
10434
10435
10436 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10437 int argc;
10438 PyObject *argv[3];
10439 int ii;
10440
10441 argc = PyObject_Length(args);
10442 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10443 argv[ii] = PyTuple_GetItem(args,ii);
10444 }
10445 if (argc == 2) {
10446 int _v;
10447 {
10448 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10449 }
10450 if (_v) {
10451 {
10452 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10453 }
10454 if (_v) {
10455 return _wrap_LogTrace__SWIG_1(self,args);
10456 }
10457 }
10458 }
10459 if (argc == 2) {
10460 int _v;
10461 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10462 if (_v) {
10463 {
10464 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10465 }
10466 if (_v) {
10467 return _wrap_LogTrace__SWIG_0(self,args);
10468 }
10469 }
10470 }
10471
10472 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10473 return NULL;
10474 }
10475
10476
10477 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10478 PyObject *resultobj;
10479 wxString *arg1 = 0 ;
10480 wxString *arg2 = 0 ;
10481 bool temp1 = false ;
10482 bool temp2 = false ;
10483 PyObject * obj0 = 0 ;
10484 PyObject * obj1 = 0 ;
10485 char *kwnames[] = {
10486 (char *) "title",(char *) "text", NULL
10487 };
10488
10489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10490 {
10491 arg1 = wxString_in_helper(obj0);
10492 if (arg1 == NULL) SWIG_fail;
10493 temp1 = true;
10494 }
10495 {
10496 arg2 = wxString_in_helper(obj1);
10497 if (arg2 == NULL) SWIG_fail;
10498 temp2 = true;
10499 }
10500 {
10501 PyThreadState* __tstate = wxPyBeginAllowThreads();
10502 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10503
10504 wxPyEndAllowThreads(__tstate);
10505 if (PyErr_Occurred()) SWIG_fail;
10506 }
10507 Py_INCREF(Py_None); resultobj = Py_None;
10508 {
10509 if (temp1)
10510 delete arg1;
10511 }
10512 {
10513 if (temp2)
10514 delete arg2;
10515 }
10516 return resultobj;
10517 fail:
10518 {
10519 if (temp1)
10520 delete arg1;
10521 }
10522 {
10523 if (temp2)
10524 delete arg2;
10525 }
10526 return NULL;
10527 }
10528
10529
10530 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10531 PyObject *resultobj;
10532 wxLogNull *result;
10533 char *kwnames[] = {
10534 NULL
10535 };
10536
10537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10538 {
10539 PyThreadState* __tstate = wxPyBeginAllowThreads();
10540 result = (wxLogNull *)new wxLogNull();
10541
10542 wxPyEndAllowThreads(__tstate);
10543 if (PyErr_Occurred()) SWIG_fail;
10544 }
10545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10546 return resultobj;
10547 fail:
10548 return NULL;
10549 }
10550
10551
10552 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10553 PyObject *resultobj;
10554 wxLogNull *arg1 = (wxLogNull *) 0 ;
10555 PyObject * obj0 = 0 ;
10556 char *kwnames[] = {
10557 (char *) "self", NULL
10558 };
10559
10560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10562 if (SWIG_arg_fail(1)) SWIG_fail;
10563 {
10564 PyThreadState* __tstate = wxPyBeginAllowThreads();
10565 delete arg1;
10566
10567 wxPyEndAllowThreads(__tstate);
10568 if (PyErr_Occurred()) SWIG_fail;
10569 }
10570 Py_INCREF(Py_None); resultobj = Py_None;
10571 return resultobj;
10572 fail:
10573 return NULL;
10574 }
10575
10576
10577 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10578 PyObject *obj;
10579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10580 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10581 Py_INCREF(obj);
10582 return Py_BuildValue((char *)"");
10583 }
10584 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj;
10586 wxPyLog *result;
10587 char *kwnames[] = {
10588 NULL
10589 };
10590
10591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10592 {
10593 PyThreadState* __tstate = wxPyBeginAllowThreads();
10594 result = (wxPyLog *)new wxPyLog();
10595
10596 wxPyEndAllowThreads(__tstate);
10597 if (PyErr_Occurred()) SWIG_fail;
10598 }
10599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10600 return resultobj;
10601 fail:
10602 return NULL;
10603 }
10604
10605
10606 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10607 PyObject *resultobj;
10608 wxPyLog *arg1 = (wxPyLog *) 0 ;
10609 PyObject *arg2 = (PyObject *) 0 ;
10610 PyObject *arg3 = (PyObject *) 0 ;
10611 PyObject * obj0 = 0 ;
10612 PyObject * obj1 = 0 ;
10613 PyObject * obj2 = 0 ;
10614 char *kwnames[] = {
10615 (char *) "self",(char *) "self",(char *) "_class", NULL
10616 };
10617
10618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10620 if (SWIG_arg_fail(1)) SWIG_fail;
10621 arg2 = obj1;
10622 arg3 = obj2;
10623 {
10624 PyThreadState* __tstate = wxPyBeginAllowThreads();
10625 (arg1)->_setCallbackInfo(arg2,arg3);
10626
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 Py_INCREF(Py_None); resultobj = Py_None;
10631 return resultobj;
10632 fail:
10633 return NULL;
10634 }
10635
10636
10637 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10638 PyObject *obj;
10639 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10640 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10641 Py_INCREF(obj);
10642 return Py_BuildValue((char *)"");
10643 }
10644 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10645 PyObject *resultobj;
10646 int arg1 ;
10647 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10648 int arg3 = (int) wxKILL_NOCHILDREN ;
10649 wxKillError result;
10650 PyObject * obj0 = 0 ;
10651 PyObject * obj1 = 0 ;
10652 PyObject * obj2 = 0 ;
10653 char *kwnames[] = {
10654 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10655 };
10656
10657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10658 {
10659 arg1 = (int)(SWIG_As_int(obj0));
10660 if (SWIG_arg_fail(1)) SWIG_fail;
10661 }
10662 if (obj1) {
10663 {
10664 arg2 = (wxSignal)(SWIG_As_int(obj1));
10665 if (SWIG_arg_fail(2)) SWIG_fail;
10666 }
10667 }
10668 if (obj2) {
10669 {
10670 arg3 = (int)(SWIG_As_int(obj2));
10671 if (SWIG_arg_fail(3)) SWIG_fail;
10672 }
10673 }
10674 {
10675 PyThreadState* __tstate = wxPyBeginAllowThreads();
10676 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10677
10678 wxPyEndAllowThreads(__tstate);
10679 if (PyErr_Occurred()) SWIG_fail;
10680 }
10681 resultobj = SWIG_From_int((result));
10682 return resultobj;
10683 fail:
10684 return NULL;
10685 }
10686
10687
10688 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10689 PyObject *resultobj;
10690 int arg1 ;
10691 bool result;
10692 PyObject * obj0 = 0 ;
10693 char *kwnames[] = {
10694 (char *) "pid", NULL
10695 };
10696
10697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10698 {
10699 arg1 = (int)(SWIG_As_int(obj0));
10700 if (SWIG_arg_fail(1)) SWIG_fail;
10701 }
10702 {
10703 PyThreadState* __tstate = wxPyBeginAllowThreads();
10704 result = (bool)wxPyProcess::Exists(arg1);
10705
10706 wxPyEndAllowThreads(__tstate);
10707 if (PyErr_Occurred()) SWIG_fail;
10708 }
10709 {
10710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10711 }
10712 return resultobj;
10713 fail:
10714 return NULL;
10715 }
10716
10717
10718 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10719 PyObject *resultobj;
10720 wxString *arg1 = 0 ;
10721 int arg2 = (int) wxEXEC_ASYNC ;
10722 wxPyProcess *result;
10723 bool temp1 = false ;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 char *kwnames[] = {
10727 (char *) "cmd",(char *) "flags", NULL
10728 };
10729
10730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10731 {
10732 arg1 = wxString_in_helper(obj0);
10733 if (arg1 == NULL) SWIG_fail;
10734 temp1 = true;
10735 }
10736 if (obj1) {
10737 {
10738 arg2 = (int)(SWIG_As_int(obj1));
10739 if (SWIG_arg_fail(2)) SWIG_fail;
10740 }
10741 }
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10745
10746 wxPyEndAllowThreads(__tstate);
10747 if (PyErr_Occurred()) SWIG_fail;
10748 }
10749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10750 {
10751 if (temp1)
10752 delete arg1;
10753 }
10754 return resultobj;
10755 fail:
10756 {
10757 if (temp1)
10758 delete arg1;
10759 }
10760 return NULL;
10761 }
10762
10763
10764 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10765 PyObject *resultobj;
10766 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10767 int arg2 = (int) -1 ;
10768 wxPyProcess *result;
10769 PyObject * obj0 = 0 ;
10770 PyObject * obj1 = 0 ;
10771 char *kwnames[] = {
10772 (char *) "parent",(char *) "id", NULL
10773 };
10774
10775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10776 if (obj0) {
10777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10778 if (SWIG_arg_fail(1)) SWIG_fail;
10779 }
10780 if (obj1) {
10781 {
10782 arg2 = (int)(SWIG_As_int(obj1));
10783 if (SWIG_arg_fail(2)) SWIG_fail;
10784 }
10785 }
10786 {
10787 PyThreadState* __tstate = wxPyBeginAllowThreads();
10788 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10789
10790 wxPyEndAllowThreads(__tstate);
10791 if (PyErr_Occurred()) SWIG_fail;
10792 }
10793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10794 return resultobj;
10795 fail:
10796 return NULL;
10797 }
10798
10799
10800 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10801 PyObject *resultobj;
10802 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10803 PyObject *arg2 = (PyObject *) 0 ;
10804 PyObject *arg3 = (PyObject *) 0 ;
10805 PyObject * obj0 = 0 ;
10806 PyObject * obj1 = 0 ;
10807 PyObject * obj2 = 0 ;
10808 char *kwnames[] = {
10809 (char *) "self",(char *) "self",(char *) "_class", NULL
10810 };
10811
10812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10814 if (SWIG_arg_fail(1)) SWIG_fail;
10815 arg2 = obj1;
10816 arg3 = obj2;
10817 {
10818 PyThreadState* __tstate = wxPyBeginAllowThreads();
10819 (arg1)->_setCallbackInfo(arg2,arg3);
10820
10821 wxPyEndAllowThreads(__tstate);
10822 if (PyErr_Occurred()) SWIG_fail;
10823 }
10824 Py_INCREF(Py_None); resultobj = Py_None;
10825 return resultobj;
10826 fail:
10827 return NULL;
10828 }
10829
10830
10831 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10832 PyObject *resultobj;
10833 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10834 int arg2 ;
10835 int arg3 ;
10836 PyObject * obj0 = 0 ;
10837 PyObject * obj1 = 0 ;
10838 PyObject * obj2 = 0 ;
10839 char *kwnames[] = {
10840 (char *) "self",(char *) "pid",(char *) "status", NULL
10841 };
10842
10843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10845 if (SWIG_arg_fail(1)) SWIG_fail;
10846 {
10847 arg2 = (int)(SWIG_As_int(obj1));
10848 if (SWIG_arg_fail(2)) SWIG_fail;
10849 }
10850 {
10851 arg3 = (int)(SWIG_As_int(obj2));
10852 if (SWIG_arg_fail(3)) SWIG_fail;
10853 }
10854 {
10855 PyThreadState* __tstate = wxPyBeginAllowThreads();
10856 (arg1)->base_OnTerminate(arg2,arg3);
10857
10858 wxPyEndAllowThreads(__tstate);
10859 if (PyErr_Occurred()) SWIG_fail;
10860 }
10861 Py_INCREF(Py_None); resultobj = Py_None;
10862 return resultobj;
10863 fail:
10864 return NULL;
10865 }
10866
10867
10868 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10869 PyObject *resultobj;
10870 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10871 PyObject * obj0 = 0 ;
10872 char *kwnames[] = {
10873 (char *) "self", NULL
10874 };
10875
10876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10878 if (SWIG_arg_fail(1)) SWIG_fail;
10879 {
10880 PyThreadState* __tstate = wxPyBeginAllowThreads();
10881 (arg1)->Redirect();
10882
10883 wxPyEndAllowThreads(__tstate);
10884 if (PyErr_Occurred()) SWIG_fail;
10885 }
10886 Py_INCREF(Py_None); resultobj = Py_None;
10887 return resultobj;
10888 fail:
10889 return NULL;
10890 }
10891
10892
10893 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10894 PyObject *resultobj;
10895 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10896 bool result;
10897 PyObject * obj0 = 0 ;
10898 char *kwnames[] = {
10899 (char *) "self", NULL
10900 };
10901
10902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10904 if (SWIG_arg_fail(1)) SWIG_fail;
10905 {
10906 PyThreadState* __tstate = wxPyBeginAllowThreads();
10907 result = (bool)(arg1)->IsRedirected();
10908
10909 wxPyEndAllowThreads(__tstate);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 {
10913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10914 }
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj;
10923 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10924 PyObject * obj0 = 0 ;
10925 char *kwnames[] = {
10926 (char *) "self", NULL
10927 };
10928
10929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10931 if (SWIG_arg_fail(1)) SWIG_fail;
10932 {
10933 PyThreadState* __tstate = wxPyBeginAllowThreads();
10934 (arg1)->Detach();
10935
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 Py_INCREF(Py_None); resultobj = Py_None;
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj;
10948 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10949 wxInputStream *result;
10950 PyObject * obj0 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "self", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10957 if (SWIG_arg_fail(1)) SWIG_fail;
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 result = (wxInputStream *)(arg1)->GetInputStream();
10961
10962 wxPyEndAllowThreads(__tstate);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 {
10966 wxPyInputStream * _ptr = NULL;
10967
10968 if (result) {
10969 _ptr = new wxPyInputStream(result);
10970 }
10971 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10972 }
10973 return resultobj;
10974 fail:
10975 return NULL;
10976 }
10977
10978
10979 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10980 PyObject *resultobj;
10981 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10982 wxInputStream *result;
10983 PyObject * obj0 = 0 ;
10984 char *kwnames[] = {
10985 (char *) "self", NULL
10986 };
10987
10988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10990 if (SWIG_arg_fail(1)) SWIG_fail;
10991 {
10992 PyThreadState* __tstate = wxPyBeginAllowThreads();
10993 result = (wxInputStream *)(arg1)->GetErrorStream();
10994
10995 wxPyEndAllowThreads(__tstate);
10996 if (PyErr_Occurred()) SWIG_fail;
10997 }
10998 {
10999 wxPyInputStream * _ptr = NULL;
11000
11001 if (result) {
11002 _ptr = new wxPyInputStream(result);
11003 }
11004 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11005 }
11006 return resultobj;
11007 fail:
11008 return NULL;
11009 }
11010
11011
11012 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11013 PyObject *resultobj;
11014 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11015 wxOutputStream *result;
11016 PyObject * obj0 = 0 ;
11017 char *kwnames[] = {
11018 (char *) "self", NULL
11019 };
11020
11021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11023 if (SWIG_arg_fail(1)) SWIG_fail;
11024 {
11025 PyThreadState* __tstate = wxPyBeginAllowThreads();
11026 result = (wxOutputStream *)(arg1)->GetOutputStream();
11027
11028 wxPyEndAllowThreads(__tstate);
11029 if (PyErr_Occurred()) SWIG_fail;
11030 }
11031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11032 return resultobj;
11033 fail:
11034 return NULL;
11035 }
11036
11037
11038 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11039 PyObject *resultobj;
11040 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11041 PyObject * obj0 = 0 ;
11042 char *kwnames[] = {
11043 (char *) "self", NULL
11044 };
11045
11046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11048 if (SWIG_arg_fail(1)) SWIG_fail;
11049 {
11050 PyThreadState* __tstate = wxPyBeginAllowThreads();
11051 (arg1)->CloseOutput();
11052
11053 wxPyEndAllowThreads(__tstate);
11054 if (PyErr_Occurred()) SWIG_fail;
11055 }
11056 Py_INCREF(Py_None); resultobj = Py_None;
11057 return resultobj;
11058 fail:
11059 return NULL;
11060 }
11061
11062
11063 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11064 PyObject *resultobj;
11065 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11066 bool result;
11067 PyObject * obj0 = 0 ;
11068 char *kwnames[] = {
11069 (char *) "self", NULL
11070 };
11071
11072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11074 if (SWIG_arg_fail(1)) SWIG_fail;
11075 {
11076 PyThreadState* __tstate = wxPyBeginAllowThreads();
11077 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11078
11079 wxPyEndAllowThreads(__tstate);
11080 if (PyErr_Occurred()) SWIG_fail;
11081 }
11082 {
11083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11084 }
11085 return resultobj;
11086 fail:
11087 return NULL;
11088 }
11089
11090
11091 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11092 PyObject *resultobj;
11093 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11094 bool result;
11095 PyObject * obj0 = 0 ;
11096 char *kwnames[] = {
11097 (char *) "self", NULL
11098 };
11099
11100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11102 if (SWIG_arg_fail(1)) SWIG_fail;
11103 {
11104 PyThreadState* __tstate = wxPyBeginAllowThreads();
11105 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11106
11107 wxPyEndAllowThreads(__tstate);
11108 if (PyErr_Occurred()) SWIG_fail;
11109 }
11110 {
11111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11112 }
11113 return resultobj;
11114 fail:
11115 return NULL;
11116 }
11117
11118
11119 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11120 PyObject *resultobj;
11121 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11122 bool result;
11123 PyObject * obj0 = 0 ;
11124 char *kwnames[] = {
11125 (char *) "self", NULL
11126 };
11127
11128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11130 if (SWIG_arg_fail(1)) SWIG_fail;
11131 {
11132 PyThreadState* __tstate = wxPyBeginAllowThreads();
11133 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11134
11135 wxPyEndAllowThreads(__tstate);
11136 if (PyErr_Occurred()) SWIG_fail;
11137 }
11138 {
11139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11140 }
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11148 PyObject *obj;
11149 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11150 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11151 Py_INCREF(obj);
11152 return Py_BuildValue((char *)"");
11153 }
11154 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11155 PyObject *resultobj;
11156 int arg1 = (int) 0 ;
11157 int arg2 = (int) 0 ;
11158 int arg3 = (int) 0 ;
11159 wxProcessEvent *result;
11160 PyObject * obj0 = 0 ;
11161 PyObject * obj1 = 0 ;
11162 PyObject * obj2 = 0 ;
11163 char *kwnames[] = {
11164 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11165 };
11166
11167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11168 if (obj0) {
11169 {
11170 arg1 = (int)(SWIG_As_int(obj0));
11171 if (SWIG_arg_fail(1)) SWIG_fail;
11172 }
11173 }
11174 if (obj1) {
11175 {
11176 arg2 = (int)(SWIG_As_int(obj1));
11177 if (SWIG_arg_fail(2)) SWIG_fail;
11178 }
11179 }
11180 if (obj2) {
11181 {
11182 arg3 = (int)(SWIG_As_int(obj2));
11183 if (SWIG_arg_fail(3)) SWIG_fail;
11184 }
11185 }
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11189
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11194 return resultobj;
11195 fail:
11196 return NULL;
11197 }
11198
11199
11200 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11201 PyObject *resultobj;
11202 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11203 int result;
11204 PyObject * obj0 = 0 ;
11205 char *kwnames[] = {
11206 (char *) "self", NULL
11207 };
11208
11209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11211 if (SWIG_arg_fail(1)) SWIG_fail;
11212 {
11213 PyThreadState* __tstate = wxPyBeginAllowThreads();
11214 result = (int)(arg1)->GetPid();
11215
11216 wxPyEndAllowThreads(__tstate);
11217 if (PyErr_Occurred()) SWIG_fail;
11218 }
11219 {
11220 resultobj = SWIG_From_int((int)(result));
11221 }
11222 return resultobj;
11223 fail:
11224 return NULL;
11225 }
11226
11227
11228 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11229 PyObject *resultobj;
11230 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11231 int result;
11232 PyObject * obj0 = 0 ;
11233 char *kwnames[] = {
11234 (char *) "self", NULL
11235 };
11236
11237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11239 if (SWIG_arg_fail(1)) SWIG_fail;
11240 {
11241 PyThreadState* __tstate = wxPyBeginAllowThreads();
11242 result = (int)(arg1)->GetExitCode();
11243
11244 wxPyEndAllowThreads(__tstate);
11245 if (PyErr_Occurred()) SWIG_fail;
11246 }
11247 {
11248 resultobj = SWIG_From_int((int)(result));
11249 }
11250 return resultobj;
11251 fail:
11252 return NULL;
11253 }
11254
11255
11256 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11257 PyObject *resultobj;
11258 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11259 int arg2 ;
11260 PyObject * obj0 = 0 ;
11261 PyObject * obj1 = 0 ;
11262 char *kwnames[] = {
11263 (char *) "self",(char *) "m_pid", NULL
11264 };
11265
11266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11268 if (SWIG_arg_fail(1)) SWIG_fail;
11269 {
11270 arg2 = (int)(SWIG_As_int(obj1));
11271 if (SWIG_arg_fail(2)) SWIG_fail;
11272 }
11273 if (arg1) (arg1)->m_pid = arg2;
11274
11275 Py_INCREF(Py_None); resultobj = Py_None;
11276 return resultobj;
11277 fail:
11278 return NULL;
11279 }
11280
11281
11282 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11283 PyObject *resultobj;
11284 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11285 int result;
11286 PyObject * obj0 = 0 ;
11287 char *kwnames[] = {
11288 (char *) "self", NULL
11289 };
11290
11291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11293 if (SWIG_arg_fail(1)) SWIG_fail;
11294 result = (int) ((arg1)->m_pid);
11295
11296 {
11297 resultobj = SWIG_From_int((int)(result));
11298 }
11299 return resultobj;
11300 fail:
11301 return NULL;
11302 }
11303
11304
11305 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11306 PyObject *resultobj;
11307 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11308 int arg2 ;
11309 PyObject * obj0 = 0 ;
11310 PyObject * obj1 = 0 ;
11311 char *kwnames[] = {
11312 (char *) "self",(char *) "m_exitcode", NULL
11313 };
11314
11315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11317 if (SWIG_arg_fail(1)) SWIG_fail;
11318 {
11319 arg2 = (int)(SWIG_As_int(obj1));
11320 if (SWIG_arg_fail(2)) SWIG_fail;
11321 }
11322 if (arg1) (arg1)->m_exitcode = arg2;
11323
11324 Py_INCREF(Py_None); resultobj = Py_None;
11325 return resultobj;
11326 fail:
11327 return NULL;
11328 }
11329
11330
11331 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11332 PyObject *resultobj;
11333 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11334 int result;
11335 PyObject * obj0 = 0 ;
11336 char *kwnames[] = {
11337 (char *) "self", NULL
11338 };
11339
11340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11342 if (SWIG_arg_fail(1)) SWIG_fail;
11343 result = (int) ((arg1)->m_exitcode);
11344
11345 {
11346 resultobj = SWIG_From_int((int)(result));
11347 }
11348 return resultobj;
11349 fail:
11350 return NULL;
11351 }
11352
11353
11354 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11355 PyObject *obj;
11356 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11357 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11358 Py_INCREF(obj);
11359 return Py_BuildValue((char *)"");
11360 }
11361 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11362 PyObject *resultobj;
11363 wxString *arg1 = 0 ;
11364 int arg2 = (int) wxEXEC_ASYNC ;
11365 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11366 long result;
11367 bool temp1 = false ;
11368 PyObject * obj0 = 0 ;
11369 PyObject * obj1 = 0 ;
11370 PyObject * obj2 = 0 ;
11371 char *kwnames[] = {
11372 (char *) "command",(char *) "flags",(char *) "process", NULL
11373 };
11374
11375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11376 {
11377 arg1 = wxString_in_helper(obj0);
11378 if (arg1 == NULL) SWIG_fail;
11379 temp1 = true;
11380 }
11381 if (obj1) {
11382 {
11383 arg2 = (int)(SWIG_As_int(obj1));
11384 if (SWIG_arg_fail(2)) SWIG_fail;
11385 }
11386 }
11387 if (obj2) {
11388 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11389 if (SWIG_arg_fail(3)) SWIG_fail;
11390 }
11391 {
11392 if (!wxPyCheckForApp()) SWIG_fail;
11393 PyThreadState* __tstate = wxPyBeginAllowThreads();
11394 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11395
11396 wxPyEndAllowThreads(__tstate);
11397 if (PyErr_Occurred()) SWIG_fail;
11398 }
11399 {
11400 resultobj = SWIG_From_long((long)(result));
11401 }
11402 {
11403 if (temp1)
11404 delete arg1;
11405 }
11406 return resultobj;
11407 fail:
11408 {
11409 if (temp1)
11410 delete arg1;
11411 }
11412 return NULL;
11413 }
11414
11415
11416 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj;
11418 long arg1 ;
11419 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11420 wxKillError *arg3 = (wxKillError *) 0 ;
11421 int arg4 = (int) wxKILL_NOCHILDREN ;
11422 int result;
11423 wxKillError temp3 ;
11424 PyObject * obj0 = 0 ;
11425 PyObject * obj1 = 0 ;
11426 PyObject * obj2 = 0 ;
11427 char *kwnames[] = {
11428 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11429 };
11430
11431 {
11432 arg3 = &temp3;
11433 }
11434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11435 {
11436 arg1 = (long)(SWIG_As_long(obj0));
11437 if (SWIG_arg_fail(1)) SWIG_fail;
11438 }
11439 if (obj1) {
11440 {
11441 arg2 = (wxSignal)(SWIG_As_int(obj1));
11442 if (SWIG_arg_fail(2)) SWIG_fail;
11443 }
11444 }
11445 if (obj2) {
11446 {
11447 arg4 = (int)(SWIG_As_int(obj2));
11448 if (SWIG_arg_fail(4)) SWIG_fail;
11449 }
11450 }
11451 {
11452 PyThreadState* __tstate = wxPyBeginAllowThreads();
11453 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11454
11455 wxPyEndAllowThreads(__tstate);
11456 if (PyErr_Occurred()) SWIG_fail;
11457 }
11458 {
11459 resultobj = SWIG_From_int((int)(result));
11460 }
11461 {
11462 PyObject* o;
11463 o = PyInt_FromLong((long) (*arg3));
11464 resultobj = t_output_helper(resultobj, o);
11465 }
11466 return resultobj;
11467 fail:
11468 return NULL;
11469 }
11470
11471
11472 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11473 PyObject *resultobj;
11474 int arg1 = (int) wxJOYSTICK1 ;
11475 wxJoystick *result;
11476 PyObject * obj0 = 0 ;
11477 char *kwnames[] = {
11478 (char *) "joystick", NULL
11479 };
11480
11481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11482 if (obj0) {
11483 {
11484 arg1 = (int)(SWIG_As_int(obj0));
11485 if (SWIG_arg_fail(1)) SWIG_fail;
11486 }
11487 }
11488 {
11489 if (!wxPyCheckForApp()) SWIG_fail;
11490 PyThreadState* __tstate = wxPyBeginAllowThreads();
11491 result = (wxJoystick *)new wxJoystick(arg1);
11492
11493 wxPyEndAllowThreads(__tstate);
11494 if (PyErr_Occurred()) SWIG_fail;
11495 }
11496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11497 return resultobj;
11498 fail:
11499 return NULL;
11500 }
11501
11502
11503 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11504 PyObject *resultobj;
11505 wxJoystick *arg1 = (wxJoystick *) 0 ;
11506 PyObject * obj0 = 0 ;
11507 char *kwnames[] = {
11508 (char *) "self", NULL
11509 };
11510
11511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11513 if (SWIG_arg_fail(1)) SWIG_fail;
11514 {
11515 PyThreadState* __tstate = wxPyBeginAllowThreads();
11516 delete arg1;
11517
11518 wxPyEndAllowThreads(__tstate);
11519 if (PyErr_Occurred()) SWIG_fail;
11520 }
11521 Py_INCREF(Py_None); resultobj = Py_None;
11522 return resultobj;
11523 fail:
11524 return NULL;
11525 }
11526
11527
11528 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11529 PyObject *resultobj;
11530 wxJoystick *arg1 = (wxJoystick *) 0 ;
11531 wxPoint result;
11532 PyObject * obj0 = 0 ;
11533 char *kwnames[] = {
11534 (char *) "self", NULL
11535 };
11536
11537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11539 if (SWIG_arg_fail(1)) SWIG_fail;
11540 {
11541 PyThreadState* __tstate = wxPyBeginAllowThreads();
11542 result = (arg1)->GetPosition();
11543
11544 wxPyEndAllowThreads(__tstate);
11545 if (PyErr_Occurred()) SWIG_fail;
11546 }
11547 {
11548 wxPoint * resultptr;
11549 resultptr = new wxPoint((wxPoint &)(result));
11550 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11551 }
11552 return resultobj;
11553 fail:
11554 return NULL;
11555 }
11556
11557
11558 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11559 PyObject *resultobj;
11560 wxJoystick *arg1 = (wxJoystick *) 0 ;
11561 int result;
11562 PyObject * obj0 = 0 ;
11563 char *kwnames[] = {
11564 (char *) "self", NULL
11565 };
11566
11567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11569 if (SWIG_arg_fail(1)) SWIG_fail;
11570 {
11571 PyThreadState* __tstate = wxPyBeginAllowThreads();
11572 result = (int)(arg1)->GetZPosition();
11573
11574 wxPyEndAllowThreads(__tstate);
11575 if (PyErr_Occurred()) SWIG_fail;
11576 }
11577 {
11578 resultobj = SWIG_From_int((int)(result));
11579 }
11580 return resultobj;
11581 fail:
11582 return NULL;
11583 }
11584
11585
11586 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11587 PyObject *resultobj;
11588 wxJoystick *arg1 = (wxJoystick *) 0 ;
11589 int result;
11590 PyObject * obj0 = 0 ;
11591 char *kwnames[] = {
11592 (char *) "self", NULL
11593 };
11594
11595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11597 if (SWIG_arg_fail(1)) SWIG_fail;
11598 {
11599 PyThreadState* __tstate = wxPyBeginAllowThreads();
11600 result = (int)(arg1)->GetButtonState();
11601
11602 wxPyEndAllowThreads(__tstate);
11603 if (PyErr_Occurred()) SWIG_fail;
11604 }
11605 {
11606 resultobj = SWIG_From_int((int)(result));
11607 }
11608 return resultobj;
11609 fail:
11610 return NULL;
11611 }
11612
11613
11614 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11615 PyObject *resultobj;
11616 wxJoystick *arg1 = (wxJoystick *) 0 ;
11617 int result;
11618 PyObject * obj0 = 0 ;
11619 char *kwnames[] = {
11620 (char *) "self", NULL
11621 };
11622
11623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11625 if (SWIG_arg_fail(1)) SWIG_fail;
11626 {
11627 PyThreadState* __tstate = wxPyBeginAllowThreads();
11628 result = (int)(arg1)->GetPOVPosition();
11629
11630 wxPyEndAllowThreads(__tstate);
11631 if (PyErr_Occurred()) SWIG_fail;
11632 }
11633 {
11634 resultobj = SWIG_From_int((int)(result));
11635 }
11636 return resultobj;
11637 fail:
11638 return NULL;
11639 }
11640
11641
11642 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11643 PyObject *resultobj;
11644 wxJoystick *arg1 = (wxJoystick *) 0 ;
11645 int result;
11646 PyObject * obj0 = 0 ;
11647 char *kwnames[] = {
11648 (char *) "self", NULL
11649 };
11650
11651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11653 if (SWIG_arg_fail(1)) SWIG_fail;
11654 {
11655 PyThreadState* __tstate = wxPyBeginAllowThreads();
11656 result = (int)(arg1)->GetPOVCTSPosition();
11657
11658 wxPyEndAllowThreads(__tstate);
11659 if (PyErr_Occurred()) SWIG_fail;
11660 }
11661 {
11662 resultobj = SWIG_From_int((int)(result));
11663 }
11664 return resultobj;
11665 fail:
11666 return NULL;
11667 }
11668
11669
11670 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11671 PyObject *resultobj;
11672 wxJoystick *arg1 = (wxJoystick *) 0 ;
11673 int result;
11674 PyObject * obj0 = 0 ;
11675 char *kwnames[] = {
11676 (char *) "self", NULL
11677 };
11678
11679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11681 if (SWIG_arg_fail(1)) SWIG_fail;
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 result = (int)(arg1)->GetRudderPosition();
11685
11686 wxPyEndAllowThreads(__tstate);
11687 if (PyErr_Occurred()) SWIG_fail;
11688 }
11689 {
11690 resultobj = SWIG_From_int((int)(result));
11691 }
11692 return resultobj;
11693 fail:
11694 return NULL;
11695 }
11696
11697
11698 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11699 PyObject *resultobj;
11700 wxJoystick *arg1 = (wxJoystick *) 0 ;
11701 int result;
11702 PyObject * obj0 = 0 ;
11703 char *kwnames[] = {
11704 (char *) "self", NULL
11705 };
11706
11707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11709 if (SWIG_arg_fail(1)) SWIG_fail;
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 result = (int)(arg1)->GetUPosition();
11713
11714 wxPyEndAllowThreads(__tstate);
11715 if (PyErr_Occurred()) SWIG_fail;
11716 }
11717 {
11718 resultobj = SWIG_From_int((int)(result));
11719 }
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11727 PyObject *resultobj;
11728 wxJoystick *arg1 = (wxJoystick *) 0 ;
11729 int result;
11730 PyObject * obj0 = 0 ;
11731 char *kwnames[] = {
11732 (char *) "self", NULL
11733 };
11734
11735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11737 if (SWIG_arg_fail(1)) SWIG_fail;
11738 {
11739 PyThreadState* __tstate = wxPyBeginAllowThreads();
11740 result = (int)(arg1)->GetVPosition();
11741
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 {
11746 resultobj = SWIG_From_int((int)(result));
11747 }
11748 return resultobj;
11749 fail:
11750 return NULL;
11751 }
11752
11753
11754 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11755 PyObject *resultobj;
11756 wxJoystick *arg1 = (wxJoystick *) 0 ;
11757 int result;
11758 PyObject * obj0 = 0 ;
11759 char *kwnames[] = {
11760 (char *) "self", NULL
11761 };
11762
11763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11765 if (SWIG_arg_fail(1)) SWIG_fail;
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (int)(arg1)->GetMovementThreshold();
11769
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 resultobj = SWIG_From_int((int)(result));
11775 }
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11783 PyObject *resultobj;
11784 wxJoystick *arg1 = (wxJoystick *) 0 ;
11785 int arg2 ;
11786 PyObject * obj0 = 0 ;
11787 PyObject * obj1 = 0 ;
11788 char *kwnames[] = {
11789 (char *) "self",(char *) "threshold", NULL
11790 };
11791
11792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11794 if (SWIG_arg_fail(1)) SWIG_fail;
11795 {
11796 arg2 = (int)(SWIG_As_int(obj1));
11797 if (SWIG_arg_fail(2)) SWIG_fail;
11798 }
11799 {
11800 PyThreadState* __tstate = wxPyBeginAllowThreads();
11801 (arg1)->SetMovementThreshold(arg2);
11802
11803 wxPyEndAllowThreads(__tstate);
11804 if (PyErr_Occurred()) SWIG_fail;
11805 }
11806 Py_INCREF(Py_None); resultobj = Py_None;
11807 return resultobj;
11808 fail:
11809 return NULL;
11810 }
11811
11812
11813 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11814 PyObject *resultobj;
11815 wxJoystick *arg1 = (wxJoystick *) 0 ;
11816 bool result;
11817 PyObject * obj0 = 0 ;
11818 char *kwnames[] = {
11819 (char *) "self", NULL
11820 };
11821
11822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11824 if (SWIG_arg_fail(1)) SWIG_fail;
11825 {
11826 PyThreadState* __tstate = wxPyBeginAllowThreads();
11827 result = (bool)(arg1)->IsOk();
11828
11829 wxPyEndAllowThreads(__tstate);
11830 if (PyErr_Occurred()) SWIG_fail;
11831 }
11832 {
11833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11834 }
11835 return resultobj;
11836 fail:
11837 return NULL;
11838 }
11839
11840
11841 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11842 PyObject *resultobj;
11843 wxJoystick *arg1 = (wxJoystick *) 0 ;
11844 int result;
11845 PyObject * obj0 = 0 ;
11846 char *kwnames[] = {
11847 (char *) "self", NULL
11848 };
11849
11850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11852 if (SWIG_arg_fail(1)) SWIG_fail;
11853 {
11854 PyThreadState* __tstate = wxPyBeginAllowThreads();
11855 result = (int)(arg1)->GetNumberJoysticks();
11856
11857 wxPyEndAllowThreads(__tstate);
11858 if (PyErr_Occurred()) SWIG_fail;
11859 }
11860 {
11861 resultobj = SWIG_From_int((int)(result));
11862 }
11863 return resultobj;
11864 fail:
11865 return NULL;
11866 }
11867
11868
11869 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11870 PyObject *resultobj;
11871 wxJoystick *arg1 = (wxJoystick *) 0 ;
11872 int result;
11873 PyObject * obj0 = 0 ;
11874 char *kwnames[] = {
11875 (char *) "self", NULL
11876 };
11877
11878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11880 if (SWIG_arg_fail(1)) SWIG_fail;
11881 {
11882 PyThreadState* __tstate = wxPyBeginAllowThreads();
11883 result = (int)(arg1)->GetManufacturerId();
11884
11885 wxPyEndAllowThreads(__tstate);
11886 if (PyErr_Occurred()) SWIG_fail;
11887 }
11888 {
11889 resultobj = SWIG_From_int((int)(result));
11890 }
11891 return resultobj;
11892 fail:
11893 return NULL;
11894 }
11895
11896
11897 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11898 PyObject *resultobj;
11899 wxJoystick *arg1 = (wxJoystick *) 0 ;
11900 int result;
11901 PyObject * obj0 = 0 ;
11902 char *kwnames[] = {
11903 (char *) "self", NULL
11904 };
11905
11906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11908 if (SWIG_arg_fail(1)) SWIG_fail;
11909 {
11910 PyThreadState* __tstate = wxPyBeginAllowThreads();
11911 result = (int)(arg1)->GetProductId();
11912
11913 wxPyEndAllowThreads(__tstate);
11914 if (PyErr_Occurred()) SWIG_fail;
11915 }
11916 {
11917 resultobj = SWIG_From_int((int)(result));
11918 }
11919 return resultobj;
11920 fail:
11921 return NULL;
11922 }
11923
11924
11925 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11926 PyObject *resultobj;
11927 wxJoystick *arg1 = (wxJoystick *) 0 ;
11928 wxString result;
11929 PyObject * obj0 = 0 ;
11930 char *kwnames[] = {
11931 (char *) "self", NULL
11932 };
11933
11934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11936 if (SWIG_arg_fail(1)) SWIG_fail;
11937 {
11938 PyThreadState* __tstate = wxPyBeginAllowThreads();
11939 result = (arg1)->GetProductName();
11940
11941 wxPyEndAllowThreads(__tstate);
11942 if (PyErr_Occurred()) SWIG_fail;
11943 }
11944 {
11945 #if wxUSE_UNICODE
11946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11947 #else
11948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11949 #endif
11950 }
11951 return resultobj;
11952 fail:
11953 return NULL;
11954 }
11955
11956
11957 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11958 PyObject *resultobj;
11959 wxJoystick *arg1 = (wxJoystick *) 0 ;
11960 int result;
11961 PyObject * obj0 = 0 ;
11962 char *kwnames[] = {
11963 (char *) "self", NULL
11964 };
11965
11966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11968 if (SWIG_arg_fail(1)) SWIG_fail;
11969 {
11970 PyThreadState* __tstate = wxPyBeginAllowThreads();
11971 result = (int)(arg1)->GetXMin();
11972
11973 wxPyEndAllowThreads(__tstate);
11974 if (PyErr_Occurred()) SWIG_fail;
11975 }
11976 {
11977 resultobj = SWIG_From_int((int)(result));
11978 }
11979 return resultobj;
11980 fail:
11981 return NULL;
11982 }
11983
11984
11985 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11986 PyObject *resultobj;
11987 wxJoystick *arg1 = (wxJoystick *) 0 ;
11988 int result;
11989 PyObject * obj0 = 0 ;
11990 char *kwnames[] = {
11991 (char *) "self", NULL
11992 };
11993
11994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11996 if (SWIG_arg_fail(1)) SWIG_fail;
11997 {
11998 PyThreadState* __tstate = wxPyBeginAllowThreads();
11999 result = (int)(arg1)->GetYMin();
12000
12001 wxPyEndAllowThreads(__tstate);
12002 if (PyErr_Occurred()) SWIG_fail;
12003 }
12004 {
12005 resultobj = SWIG_From_int((int)(result));
12006 }
12007 return resultobj;
12008 fail:
12009 return NULL;
12010 }
12011
12012
12013 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12014 PyObject *resultobj;
12015 wxJoystick *arg1 = (wxJoystick *) 0 ;
12016 int result;
12017 PyObject * obj0 = 0 ;
12018 char *kwnames[] = {
12019 (char *) "self", NULL
12020 };
12021
12022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12024 if (SWIG_arg_fail(1)) SWIG_fail;
12025 {
12026 PyThreadState* __tstate = wxPyBeginAllowThreads();
12027 result = (int)(arg1)->GetZMin();
12028
12029 wxPyEndAllowThreads(__tstate);
12030 if (PyErr_Occurred()) SWIG_fail;
12031 }
12032 {
12033 resultobj = SWIG_From_int((int)(result));
12034 }
12035 return resultobj;
12036 fail:
12037 return NULL;
12038 }
12039
12040
12041 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12042 PyObject *resultobj;
12043 wxJoystick *arg1 = (wxJoystick *) 0 ;
12044 int result;
12045 PyObject * obj0 = 0 ;
12046 char *kwnames[] = {
12047 (char *) "self", NULL
12048 };
12049
12050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12052 if (SWIG_arg_fail(1)) SWIG_fail;
12053 {
12054 PyThreadState* __tstate = wxPyBeginAllowThreads();
12055 result = (int)(arg1)->GetXMax();
12056
12057 wxPyEndAllowThreads(__tstate);
12058 if (PyErr_Occurred()) SWIG_fail;
12059 }
12060 {
12061 resultobj = SWIG_From_int((int)(result));
12062 }
12063 return resultobj;
12064 fail:
12065 return NULL;
12066 }
12067
12068
12069 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12070 PyObject *resultobj;
12071 wxJoystick *arg1 = (wxJoystick *) 0 ;
12072 int result;
12073 PyObject * obj0 = 0 ;
12074 char *kwnames[] = {
12075 (char *) "self", NULL
12076 };
12077
12078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12080 if (SWIG_arg_fail(1)) SWIG_fail;
12081 {
12082 PyThreadState* __tstate = wxPyBeginAllowThreads();
12083 result = (int)(arg1)->GetYMax();
12084
12085 wxPyEndAllowThreads(__tstate);
12086 if (PyErr_Occurred()) SWIG_fail;
12087 }
12088 {
12089 resultobj = SWIG_From_int((int)(result));
12090 }
12091 return resultobj;
12092 fail:
12093 return NULL;
12094 }
12095
12096
12097 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12098 PyObject *resultobj;
12099 wxJoystick *arg1 = (wxJoystick *) 0 ;
12100 int result;
12101 PyObject * obj0 = 0 ;
12102 char *kwnames[] = {
12103 (char *) "self", NULL
12104 };
12105
12106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12108 if (SWIG_arg_fail(1)) SWIG_fail;
12109 {
12110 PyThreadState* __tstate = wxPyBeginAllowThreads();
12111 result = (int)(arg1)->GetZMax();
12112
12113 wxPyEndAllowThreads(__tstate);
12114 if (PyErr_Occurred()) SWIG_fail;
12115 }
12116 {
12117 resultobj = SWIG_From_int((int)(result));
12118 }
12119 return resultobj;
12120 fail:
12121 return NULL;
12122 }
12123
12124
12125 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12126 PyObject *resultobj;
12127 wxJoystick *arg1 = (wxJoystick *) 0 ;
12128 int result;
12129 PyObject * obj0 = 0 ;
12130 char *kwnames[] = {
12131 (char *) "self", NULL
12132 };
12133
12134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12136 if (SWIG_arg_fail(1)) SWIG_fail;
12137 {
12138 PyThreadState* __tstate = wxPyBeginAllowThreads();
12139 result = (int)(arg1)->GetNumberButtons();
12140
12141 wxPyEndAllowThreads(__tstate);
12142 if (PyErr_Occurred()) SWIG_fail;
12143 }
12144 {
12145 resultobj = SWIG_From_int((int)(result));
12146 }
12147 return resultobj;
12148 fail:
12149 return NULL;
12150 }
12151
12152
12153 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12154 PyObject *resultobj;
12155 wxJoystick *arg1 = (wxJoystick *) 0 ;
12156 int result;
12157 PyObject * obj0 = 0 ;
12158 char *kwnames[] = {
12159 (char *) "self", NULL
12160 };
12161
12162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12164 if (SWIG_arg_fail(1)) SWIG_fail;
12165 {
12166 PyThreadState* __tstate = wxPyBeginAllowThreads();
12167 result = (int)(arg1)->GetNumberAxes();
12168
12169 wxPyEndAllowThreads(__tstate);
12170 if (PyErr_Occurred()) SWIG_fail;
12171 }
12172 {
12173 resultobj = SWIG_From_int((int)(result));
12174 }
12175 return resultobj;
12176 fail:
12177 return NULL;
12178 }
12179
12180
12181 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12182 PyObject *resultobj;
12183 wxJoystick *arg1 = (wxJoystick *) 0 ;
12184 int result;
12185 PyObject * obj0 = 0 ;
12186 char *kwnames[] = {
12187 (char *) "self", NULL
12188 };
12189
12190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12192 if (SWIG_arg_fail(1)) SWIG_fail;
12193 {
12194 PyThreadState* __tstate = wxPyBeginAllowThreads();
12195 result = (int)(arg1)->GetMaxButtons();
12196
12197 wxPyEndAllowThreads(__tstate);
12198 if (PyErr_Occurred()) SWIG_fail;
12199 }
12200 {
12201 resultobj = SWIG_From_int((int)(result));
12202 }
12203 return resultobj;
12204 fail:
12205 return NULL;
12206 }
12207
12208
12209 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12210 PyObject *resultobj;
12211 wxJoystick *arg1 = (wxJoystick *) 0 ;
12212 int result;
12213 PyObject * obj0 = 0 ;
12214 char *kwnames[] = {
12215 (char *) "self", NULL
12216 };
12217
12218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12220 if (SWIG_arg_fail(1)) SWIG_fail;
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 result = (int)(arg1)->GetMaxAxes();
12224
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 {
12229 resultobj = SWIG_From_int((int)(result));
12230 }
12231 return resultobj;
12232 fail:
12233 return NULL;
12234 }
12235
12236
12237 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12238 PyObject *resultobj;
12239 wxJoystick *arg1 = (wxJoystick *) 0 ;
12240 int result;
12241 PyObject * obj0 = 0 ;
12242 char *kwnames[] = {
12243 (char *) "self", NULL
12244 };
12245
12246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12248 if (SWIG_arg_fail(1)) SWIG_fail;
12249 {
12250 PyThreadState* __tstate = wxPyBeginAllowThreads();
12251 result = (int)(arg1)->GetPollingMin();
12252
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 {
12257 resultobj = SWIG_From_int((int)(result));
12258 }
12259 return resultobj;
12260 fail:
12261 return NULL;
12262 }
12263
12264
12265 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12266 PyObject *resultobj;
12267 wxJoystick *arg1 = (wxJoystick *) 0 ;
12268 int result;
12269 PyObject * obj0 = 0 ;
12270 char *kwnames[] = {
12271 (char *) "self", NULL
12272 };
12273
12274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12276 if (SWIG_arg_fail(1)) SWIG_fail;
12277 {
12278 PyThreadState* __tstate = wxPyBeginAllowThreads();
12279 result = (int)(arg1)->GetPollingMax();
12280
12281 wxPyEndAllowThreads(__tstate);
12282 if (PyErr_Occurred()) SWIG_fail;
12283 }
12284 {
12285 resultobj = SWIG_From_int((int)(result));
12286 }
12287 return resultobj;
12288 fail:
12289 return NULL;
12290 }
12291
12292
12293 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12294 PyObject *resultobj;
12295 wxJoystick *arg1 = (wxJoystick *) 0 ;
12296 int result;
12297 PyObject * obj0 = 0 ;
12298 char *kwnames[] = {
12299 (char *) "self", NULL
12300 };
12301
12302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12304 if (SWIG_arg_fail(1)) SWIG_fail;
12305 {
12306 PyThreadState* __tstate = wxPyBeginAllowThreads();
12307 result = (int)(arg1)->GetRudderMin();
12308
12309 wxPyEndAllowThreads(__tstate);
12310 if (PyErr_Occurred()) SWIG_fail;
12311 }
12312 {
12313 resultobj = SWIG_From_int((int)(result));
12314 }
12315 return resultobj;
12316 fail:
12317 return NULL;
12318 }
12319
12320
12321 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12322 PyObject *resultobj;
12323 wxJoystick *arg1 = (wxJoystick *) 0 ;
12324 int result;
12325 PyObject * obj0 = 0 ;
12326 char *kwnames[] = {
12327 (char *) "self", NULL
12328 };
12329
12330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12332 if (SWIG_arg_fail(1)) SWIG_fail;
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 result = (int)(arg1)->GetRudderMax();
12336
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 {
12341 resultobj = SWIG_From_int((int)(result));
12342 }
12343 return resultobj;
12344 fail:
12345 return NULL;
12346 }
12347
12348
12349 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12350 PyObject *resultobj;
12351 wxJoystick *arg1 = (wxJoystick *) 0 ;
12352 int result;
12353 PyObject * obj0 = 0 ;
12354 char *kwnames[] = {
12355 (char *) "self", NULL
12356 };
12357
12358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12360 if (SWIG_arg_fail(1)) SWIG_fail;
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 result = (int)(arg1)->GetUMin();
12364
12365 wxPyEndAllowThreads(__tstate);
12366 if (PyErr_Occurred()) SWIG_fail;
12367 }
12368 {
12369 resultobj = SWIG_From_int((int)(result));
12370 }
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12378 PyObject *resultobj;
12379 wxJoystick *arg1 = (wxJoystick *) 0 ;
12380 int result;
12381 PyObject * obj0 = 0 ;
12382 char *kwnames[] = {
12383 (char *) "self", NULL
12384 };
12385
12386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12388 if (SWIG_arg_fail(1)) SWIG_fail;
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 result = (int)(arg1)->GetUMax();
12392
12393 wxPyEndAllowThreads(__tstate);
12394 if (PyErr_Occurred()) SWIG_fail;
12395 }
12396 {
12397 resultobj = SWIG_From_int((int)(result));
12398 }
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12406 PyObject *resultobj;
12407 wxJoystick *arg1 = (wxJoystick *) 0 ;
12408 int result;
12409 PyObject * obj0 = 0 ;
12410 char *kwnames[] = {
12411 (char *) "self", NULL
12412 };
12413
12414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12416 if (SWIG_arg_fail(1)) SWIG_fail;
12417 {
12418 PyThreadState* __tstate = wxPyBeginAllowThreads();
12419 result = (int)(arg1)->GetVMin();
12420
12421 wxPyEndAllowThreads(__tstate);
12422 if (PyErr_Occurred()) SWIG_fail;
12423 }
12424 {
12425 resultobj = SWIG_From_int((int)(result));
12426 }
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj;
12435 wxJoystick *arg1 = (wxJoystick *) 0 ;
12436 int result;
12437 PyObject * obj0 = 0 ;
12438 char *kwnames[] = {
12439 (char *) "self", NULL
12440 };
12441
12442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12444 if (SWIG_arg_fail(1)) SWIG_fail;
12445 {
12446 PyThreadState* __tstate = wxPyBeginAllowThreads();
12447 result = (int)(arg1)->GetVMax();
12448
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 {
12453 resultobj = SWIG_From_int((int)(result));
12454 }
12455 return resultobj;
12456 fail:
12457 return NULL;
12458 }
12459
12460
12461 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12462 PyObject *resultobj;
12463 wxJoystick *arg1 = (wxJoystick *) 0 ;
12464 bool result;
12465 PyObject * obj0 = 0 ;
12466 char *kwnames[] = {
12467 (char *) "self", NULL
12468 };
12469
12470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12472 if (SWIG_arg_fail(1)) SWIG_fail;
12473 {
12474 PyThreadState* __tstate = wxPyBeginAllowThreads();
12475 result = (bool)(arg1)->HasRudder();
12476
12477 wxPyEndAllowThreads(__tstate);
12478 if (PyErr_Occurred()) SWIG_fail;
12479 }
12480 {
12481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12482 }
12483 return resultobj;
12484 fail:
12485 return NULL;
12486 }
12487
12488
12489 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12490 PyObject *resultobj;
12491 wxJoystick *arg1 = (wxJoystick *) 0 ;
12492 bool result;
12493 PyObject * obj0 = 0 ;
12494 char *kwnames[] = {
12495 (char *) "self", NULL
12496 };
12497
12498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12500 if (SWIG_arg_fail(1)) SWIG_fail;
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 result = (bool)(arg1)->HasZ();
12504
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 {
12509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12510 }
12511 return resultobj;
12512 fail:
12513 return NULL;
12514 }
12515
12516
12517 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12518 PyObject *resultobj;
12519 wxJoystick *arg1 = (wxJoystick *) 0 ;
12520 bool result;
12521 PyObject * obj0 = 0 ;
12522 char *kwnames[] = {
12523 (char *) "self", NULL
12524 };
12525
12526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12528 if (SWIG_arg_fail(1)) SWIG_fail;
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 result = (bool)(arg1)->HasU();
12532
12533 wxPyEndAllowThreads(__tstate);
12534 if (PyErr_Occurred()) SWIG_fail;
12535 }
12536 {
12537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12538 }
12539 return resultobj;
12540 fail:
12541 return NULL;
12542 }
12543
12544
12545 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12546 PyObject *resultobj;
12547 wxJoystick *arg1 = (wxJoystick *) 0 ;
12548 bool result;
12549 PyObject * obj0 = 0 ;
12550 char *kwnames[] = {
12551 (char *) "self", NULL
12552 };
12553
12554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12556 if (SWIG_arg_fail(1)) SWIG_fail;
12557 {
12558 PyThreadState* __tstate = wxPyBeginAllowThreads();
12559 result = (bool)(arg1)->HasV();
12560
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 {
12565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12566 }
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12574 PyObject *resultobj;
12575 wxJoystick *arg1 = (wxJoystick *) 0 ;
12576 bool result;
12577 PyObject * obj0 = 0 ;
12578 char *kwnames[] = {
12579 (char *) "self", NULL
12580 };
12581
12582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12584 if (SWIG_arg_fail(1)) SWIG_fail;
12585 {
12586 PyThreadState* __tstate = wxPyBeginAllowThreads();
12587 result = (bool)(arg1)->HasPOV();
12588
12589 wxPyEndAllowThreads(__tstate);
12590 if (PyErr_Occurred()) SWIG_fail;
12591 }
12592 {
12593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12594 }
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12602 PyObject *resultobj;
12603 wxJoystick *arg1 = (wxJoystick *) 0 ;
12604 bool result;
12605 PyObject * obj0 = 0 ;
12606 char *kwnames[] = {
12607 (char *) "self", NULL
12608 };
12609
12610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12612 if (SWIG_arg_fail(1)) SWIG_fail;
12613 {
12614 PyThreadState* __tstate = wxPyBeginAllowThreads();
12615 result = (bool)(arg1)->HasPOV4Dir();
12616
12617 wxPyEndAllowThreads(__tstate);
12618 if (PyErr_Occurred()) SWIG_fail;
12619 }
12620 {
12621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12622 }
12623 return resultobj;
12624 fail:
12625 return NULL;
12626 }
12627
12628
12629 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12630 PyObject *resultobj;
12631 wxJoystick *arg1 = (wxJoystick *) 0 ;
12632 bool result;
12633 PyObject * obj0 = 0 ;
12634 char *kwnames[] = {
12635 (char *) "self", NULL
12636 };
12637
12638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12640 if (SWIG_arg_fail(1)) SWIG_fail;
12641 {
12642 PyThreadState* __tstate = wxPyBeginAllowThreads();
12643 result = (bool)(arg1)->HasPOVCTS();
12644
12645 wxPyEndAllowThreads(__tstate);
12646 if (PyErr_Occurred()) SWIG_fail;
12647 }
12648 {
12649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12650 }
12651 return resultobj;
12652 fail:
12653 return NULL;
12654 }
12655
12656
12657 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12658 PyObject *resultobj;
12659 wxJoystick *arg1 = (wxJoystick *) 0 ;
12660 wxWindow *arg2 = (wxWindow *) 0 ;
12661 int arg3 = (int) 0 ;
12662 bool result;
12663 PyObject * obj0 = 0 ;
12664 PyObject * obj1 = 0 ;
12665 PyObject * obj2 = 0 ;
12666 char *kwnames[] = {
12667 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12668 };
12669
12670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12672 if (SWIG_arg_fail(1)) SWIG_fail;
12673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12674 if (SWIG_arg_fail(2)) SWIG_fail;
12675 if (obj2) {
12676 {
12677 arg3 = (int)(SWIG_As_int(obj2));
12678 if (SWIG_arg_fail(3)) SWIG_fail;
12679 }
12680 }
12681 {
12682 PyThreadState* __tstate = wxPyBeginAllowThreads();
12683 result = (bool)(arg1)->SetCapture(arg2,arg3);
12684
12685 wxPyEndAllowThreads(__tstate);
12686 if (PyErr_Occurred()) SWIG_fail;
12687 }
12688 {
12689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12690 }
12691 return resultobj;
12692 fail:
12693 return NULL;
12694 }
12695
12696
12697 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12698 PyObject *resultobj;
12699 wxJoystick *arg1 = (wxJoystick *) 0 ;
12700 bool result;
12701 PyObject * obj0 = 0 ;
12702 char *kwnames[] = {
12703 (char *) "self", NULL
12704 };
12705
12706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12708 if (SWIG_arg_fail(1)) SWIG_fail;
12709 {
12710 PyThreadState* __tstate = wxPyBeginAllowThreads();
12711 result = (bool)(arg1)->ReleaseCapture();
12712
12713 wxPyEndAllowThreads(__tstate);
12714 if (PyErr_Occurred()) SWIG_fail;
12715 }
12716 {
12717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12718 }
12719 return resultobj;
12720 fail:
12721 return NULL;
12722 }
12723
12724
12725 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12726 PyObject *obj;
12727 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12728 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12729 Py_INCREF(obj);
12730 return Py_BuildValue((char *)"");
12731 }
12732 static PyObject *_wrap_JoystickEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
12733 PyObject *resultobj;
12734 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12735 wxPoint *arg2 = (wxPoint *) 0 ;
12736 PyObject * obj0 = 0 ;
12737 PyObject * obj1 = 0 ;
12738 char *kwnames[] = {
12739 (char *) "self",(char *) "m_pos", NULL
12740 };
12741
12742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
12743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12744 if (SWIG_arg_fail(1)) SWIG_fail;
12745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12746 if (SWIG_arg_fail(2)) SWIG_fail;
12747 if (arg1) (arg1)->m_pos = *arg2;
12748
12749 Py_INCREF(Py_None); resultobj = Py_None;
12750 return resultobj;
12751 fail:
12752 return NULL;
12753 }
12754
12755
12756 static PyObject *_wrap_JoystickEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
12757 PyObject *resultobj;
12758 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12759 wxPoint *result;
12760 PyObject * obj0 = 0 ;
12761 char *kwnames[] = {
12762 (char *) "self", NULL
12763 };
12764
12765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_pos_get",kwnames,&obj0)) goto fail;
12766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12767 if (SWIG_arg_fail(1)) SWIG_fail;
12768 result = (wxPoint *)& ((arg1)->m_pos);
12769
12770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
12771 return resultobj;
12772 fail:
12773 return NULL;
12774 }
12775
12776
12777 static PyObject *_wrap_JoystickEvent_m_zPosition_set(PyObject *, PyObject *args, PyObject *kwargs) {
12778 PyObject *resultobj;
12779 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12780 int arg2 ;
12781 PyObject * obj0 = 0 ;
12782 PyObject * obj1 = 0 ;
12783 char *kwnames[] = {
12784 (char *) "self",(char *) "m_zPosition", NULL
12785 };
12786
12787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_zPosition_set",kwnames,&obj0,&obj1)) goto fail;
12788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12789 if (SWIG_arg_fail(1)) SWIG_fail;
12790 {
12791 arg2 = (int)(SWIG_As_int(obj1));
12792 if (SWIG_arg_fail(2)) SWIG_fail;
12793 }
12794 if (arg1) (arg1)->m_zPosition = arg2;
12795
12796 Py_INCREF(Py_None); resultobj = Py_None;
12797 return resultobj;
12798 fail:
12799 return NULL;
12800 }
12801
12802
12803 static PyObject *_wrap_JoystickEvent_m_zPosition_get(PyObject *, PyObject *args, PyObject *kwargs) {
12804 PyObject *resultobj;
12805 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12806 int result;
12807 PyObject * obj0 = 0 ;
12808 char *kwnames[] = {
12809 (char *) "self", NULL
12810 };
12811
12812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_zPosition_get",kwnames,&obj0)) goto fail;
12813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12814 if (SWIG_arg_fail(1)) SWIG_fail;
12815 result = (int) ((arg1)->m_zPosition);
12816
12817 {
12818 resultobj = SWIG_From_int((int)(result));
12819 }
12820 return resultobj;
12821 fail:
12822 return NULL;
12823 }
12824
12825
12826 static PyObject *_wrap_JoystickEvent_m_buttonChange_set(PyObject *, PyObject *args, PyObject *kwargs) {
12827 PyObject *resultobj;
12828 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12829 int arg2 ;
12830 PyObject * obj0 = 0 ;
12831 PyObject * obj1 = 0 ;
12832 char *kwnames[] = {
12833 (char *) "self",(char *) "m_buttonChange", NULL
12834 };
12835
12836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonChange_set",kwnames,&obj0,&obj1)) goto fail;
12837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12838 if (SWIG_arg_fail(1)) SWIG_fail;
12839 {
12840 arg2 = (int)(SWIG_As_int(obj1));
12841 if (SWIG_arg_fail(2)) SWIG_fail;
12842 }
12843 if (arg1) (arg1)->m_buttonChange = arg2;
12844
12845 Py_INCREF(Py_None); resultobj = Py_None;
12846 return resultobj;
12847 fail:
12848 return NULL;
12849 }
12850
12851
12852 static PyObject *_wrap_JoystickEvent_m_buttonChange_get(PyObject *, PyObject *args, PyObject *kwargs) {
12853 PyObject *resultobj;
12854 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12855 int result;
12856 PyObject * obj0 = 0 ;
12857 char *kwnames[] = {
12858 (char *) "self", NULL
12859 };
12860
12861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonChange_get",kwnames,&obj0)) goto fail;
12862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12863 if (SWIG_arg_fail(1)) SWIG_fail;
12864 result = (int) ((arg1)->m_buttonChange);
12865
12866 {
12867 resultobj = SWIG_From_int((int)(result));
12868 }
12869 return resultobj;
12870 fail:
12871 return NULL;
12872 }
12873
12874
12875 static PyObject *_wrap_JoystickEvent_m_buttonState_set(PyObject *, PyObject *args, PyObject *kwargs) {
12876 PyObject *resultobj;
12877 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12878 int arg2 ;
12879 PyObject * obj0 = 0 ;
12880 PyObject * obj1 = 0 ;
12881 char *kwnames[] = {
12882 (char *) "self",(char *) "m_buttonState", NULL
12883 };
12884
12885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonState_set",kwnames,&obj0,&obj1)) goto fail;
12886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12887 if (SWIG_arg_fail(1)) SWIG_fail;
12888 {
12889 arg2 = (int)(SWIG_As_int(obj1));
12890 if (SWIG_arg_fail(2)) SWIG_fail;
12891 }
12892 if (arg1) (arg1)->m_buttonState = arg2;
12893
12894 Py_INCREF(Py_None); resultobj = Py_None;
12895 return resultobj;
12896 fail:
12897 return NULL;
12898 }
12899
12900
12901 static PyObject *_wrap_JoystickEvent_m_buttonState_get(PyObject *, PyObject *args, PyObject *kwargs) {
12902 PyObject *resultobj;
12903 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12904 int result;
12905 PyObject * obj0 = 0 ;
12906 char *kwnames[] = {
12907 (char *) "self", NULL
12908 };
12909
12910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonState_get",kwnames,&obj0)) goto fail;
12911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12912 if (SWIG_arg_fail(1)) SWIG_fail;
12913 result = (int) ((arg1)->m_buttonState);
12914
12915 {
12916 resultobj = SWIG_From_int((int)(result));
12917 }
12918 return resultobj;
12919 fail:
12920 return NULL;
12921 }
12922
12923
12924 static PyObject *_wrap_JoystickEvent_m_joyStick_set(PyObject *, PyObject *args, PyObject *kwargs) {
12925 PyObject *resultobj;
12926 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12927 int arg2 ;
12928 PyObject * obj0 = 0 ;
12929 PyObject * obj1 = 0 ;
12930 char *kwnames[] = {
12931 (char *) "self",(char *) "m_joyStick", NULL
12932 };
12933
12934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_joyStick_set",kwnames,&obj0,&obj1)) goto fail;
12935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12936 if (SWIG_arg_fail(1)) SWIG_fail;
12937 {
12938 arg2 = (int)(SWIG_As_int(obj1));
12939 if (SWIG_arg_fail(2)) SWIG_fail;
12940 }
12941 if (arg1) (arg1)->m_joyStick = arg2;
12942
12943 Py_INCREF(Py_None); resultobj = Py_None;
12944 return resultobj;
12945 fail:
12946 return NULL;
12947 }
12948
12949
12950 static PyObject *_wrap_JoystickEvent_m_joyStick_get(PyObject *, PyObject *args, PyObject *kwargs) {
12951 PyObject *resultobj;
12952 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12953 int result;
12954 PyObject * obj0 = 0 ;
12955 char *kwnames[] = {
12956 (char *) "self", NULL
12957 };
12958
12959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_joyStick_get",kwnames,&obj0)) goto fail;
12960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12961 if (SWIG_arg_fail(1)) SWIG_fail;
12962 result = (int) ((arg1)->m_joyStick);
12963
12964 {
12965 resultobj = SWIG_From_int((int)(result));
12966 }
12967 return resultobj;
12968 fail:
12969 return NULL;
12970 }
12971
12972
12973 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12974 PyObject *resultobj;
12975 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12976 int arg2 = (int) 0 ;
12977 int arg3 = (int) wxJOYSTICK1 ;
12978 int arg4 = (int) 0 ;
12979 wxJoystickEvent *result;
12980 PyObject * obj0 = 0 ;
12981 PyObject * obj1 = 0 ;
12982 PyObject * obj2 = 0 ;
12983 PyObject * obj3 = 0 ;
12984 char *kwnames[] = {
12985 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12986 };
12987
12988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12989 if (obj0) {
12990 {
12991 arg1 = (wxEventType)(SWIG_As_int(obj0));
12992 if (SWIG_arg_fail(1)) SWIG_fail;
12993 }
12994 }
12995 if (obj1) {
12996 {
12997 arg2 = (int)(SWIG_As_int(obj1));
12998 if (SWIG_arg_fail(2)) SWIG_fail;
12999 }
13000 }
13001 if (obj2) {
13002 {
13003 arg3 = (int)(SWIG_As_int(obj2));
13004 if (SWIG_arg_fail(3)) SWIG_fail;
13005 }
13006 }
13007 if (obj3) {
13008 {
13009 arg4 = (int)(SWIG_As_int(obj3));
13010 if (SWIG_arg_fail(4)) SWIG_fail;
13011 }
13012 }
13013 {
13014 PyThreadState* __tstate = wxPyBeginAllowThreads();
13015 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
13016
13017 wxPyEndAllowThreads(__tstate);
13018 if (PyErr_Occurred()) SWIG_fail;
13019 }
13020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
13021 return resultobj;
13022 fail:
13023 return NULL;
13024 }
13025
13026
13027 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13028 PyObject *resultobj;
13029 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13030 wxPoint result;
13031 PyObject * obj0 = 0 ;
13032 char *kwnames[] = {
13033 (char *) "self", NULL
13034 };
13035
13036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
13037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13038 if (SWIG_arg_fail(1)) SWIG_fail;
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 result = ((wxJoystickEvent const *)arg1)->GetPosition();
13042
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 {
13047 wxPoint * resultptr;
13048 resultptr = new wxPoint((wxPoint &)(result));
13049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
13050 }
13051 return resultobj;
13052 fail:
13053 return NULL;
13054 }
13055
13056
13057 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13058 PyObject *resultobj;
13059 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13060 int result;
13061 PyObject * obj0 = 0 ;
13062 char *kwnames[] = {
13063 (char *) "self", NULL
13064 };
13065
13066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13068 if (SWIG_arg_fail(1)) SWIG_fail;
13069 {
13070 PyThreadState* __tstate = wxPyBeginAllowThreads();
13071 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13072
13073 wxPyEndAllowThreads(__tstate);
13074 if (PyErr_Occurred()) SWIG_fail;
13075 }
13076 {
13077 resultobj = SWIG_From_int((int)(result));
13078 }
13079 return resultobj;
13080 fail:
13081 return NULL;
13082 }
13083
13084
13085 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13086 PyObject *resultobj;
13087 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13088 int result;
13089 PyObject * obj0 = 0 ;
13090 char *kwnames[] = {
13091 (char *) "self", NULL
13092 };
13093
13094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13096 if (SWIG_arg_fail(1)) SWIG_fail;
13097 {
13098 PyThreadState* __tstate = wxPyBeginAllowThreads();
13099 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13100
13101 wxPyEndAllowThreads(__tstate);
13102 if (PyErr_Occurred()) SWIG_fail;
13103 }
13104 {
13105 resultobj = SWIG_From_int((int)(result));
13106 }
13107 return resultobj;
13108 fail:
13109 return NULL;
13110 }
13111
13112
13113 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13114 PyObject *resultobj;
13115 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13116 int result;
13117 PyObject * obj0 = 0 ;
13118 char *kwnames[] = {
13119 (char *) "self", NULL
13120 };
13121
13122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13124 if (SWIG_arg_fail(1)) SWIG_fail;
13125 {
13126 PyThreadState* __tstate = wxPyBeginAllowThreads();
13127 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13128
13129 wxPyEndAllowThreads(__tstate);
13130 if (PyErr_Occurred()) SWIG_fail;
13131 }
13132 {
13133 resultobj = SWIG_From_int((int)(result));
13134 }
13135 return resultobj;
13136 fail:
13137 return NULL;
13138 }
13139
13140
13141 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13142 PyObject *resultobj;
13143 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13144 int result;
13145 PyObject * obj0 = 0 ;
13146 char *kwnames[] = {
13147 (char *) "self", NULL
13148 };
13149
13150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13152 if (SWIG_arg_fail(1)) SWIG_fail;
13153 {
13154 PyThreadState* __tstate = wxPyBeginAllowThreads();
13155 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13156
13157 wxPyEndAllowThreads(__tstate);
13158 if (PyErr_Occurred()) SWIG_fail;
13159 }
13160 {
13161 resultobj = SWIG_From_int((int)(result));
13162 }
13163 return resultobj;
13164 fail:
13165 return NULL;
13166 }
13167
13168
13169 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj;
13171 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13172 int arg2 ;
13173 PyObject * obj0 = 0 ;
13174 PyObject * obj1 = 0 ;
13175 char *kwnames[] = {
13176 (char *) "self",(char *) "stick", NULL
13177 };
13178
13179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13181 if (SWIG_arg_fail(1)) SWIG_fail;
13182 {
13183 arg2 = (int)(SWIG_As_int(obj1));
13184 if (SWIG_arg_fail(2)) SWIG_fail;
13185 }
13186 {
13187 PyThreadState* __tstate = wxPyBeginAllowThreads();
13188 (arg1)->SetJoystick(arg2);
13189
13190 wxPyEndAllowThreads(__tstate);
13191 if (PyErr_Occurred()) SWIG_fail;
13192 }
13193 Py_INCREF(Py_None); resultobj = Py_None;
13194 return resultobj;
13195 fail:
13196 return NULL;
13197 }
13198
13199
13200 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13201 PyObject *resultobj;
13202 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13203 int arg2 ;
13204 PyObject * obj0 = 0 ;
13205 PyObject * obj1 = 0 ;
13206 char *kwnames[] = {
13207 (char *) "self",(char *) "state", NULL
13208 };
13209
13210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13212 if (SWIG_arg_fail(1)) SWIG_fail;
13213 {
13214 arg2 = (int)(SWIG_As_int(obj1));
13215 if (SWIG_arg_fail(2)) SWIG_fail;
13216 }
13217 {
13218 PyThreadState* __tstate = wxPyBeginAllowThreads();
13219 (arg1)->SetButtonState(arg2);
13220
13221 wxPyEndAllowThreads(__tstate);
13222 if (PyErr_Occurred()) SWIG_fail;
13223 }
13224 Py_INCREF(Py_None); resultobj = Py_None;
13225 return resultobj;
13226 fail:
13227 return NULL;
13228 }
13229
13230
13231 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13232 PyObject *resultobj;
13233 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13234 int arg2 ;
13235 PyObject * obj0 = 0 ;
13236 PyObject * obj1 = 0 ;
13237 char *kwnames[] = {
13238 (char *) "self",(char *) "change", NULL
13239 };
13240
13241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13243 if (SWIG_arg_fail(1)) SWIG_fail;
13244 {
13245 arg2 = (int)(SWIG_As_int(obj1));
13246 if (SWIG_arg_fail(2)) SWIG_fail;
13247 }
13248 {
13249 PyThreadState* __tstate = wxPyBeginAllowThreads();
13250 (arg1)->SetButtonChange(arg2);
13251
13252 wxPyEndAllowThreads(__tstate);
13253 if (PyErr_Occurred()) SWIG_fail;
13254 }
13255 Py_INCREF(Py_None); resultobj = Py_None;
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13263 PyObject *resultobj;
13264 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13265 wxPoint *arg2 = 0 ;
13266 wxPoint temp2 ;
13267 PyObject * obj0 = 0 ;
13268 PyObject * obj1 = 0 ;
13269 char *kwnames[] = {
13270 (char *) "self",(char *) "pos", NULL
13271 };
13272
13273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13275 if (SWIG_arg_fail(1)) SWIG_fail;
13276 {
13277 arg2 = &temp2;
13278 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13279 }
13280 {
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 (arg1)->SetPosition((wxPoint const &)*arg2);
13283
13284 wxPyEndAllowThreads(__tstate);
13285 if (PyErr_Occurred()) SWIG_fail;
13286 }
13287 Py_INCREF(Py_None); resultobj = Py_None;
13288 return resultobj;
13289 fail:
13290 return NULL;
13291 }
13292
13293
13294 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13295 PyObject *resultobj;
13296 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13297 int arg2 ;
13298 PyObject * obj0 = 0 ;
13299 PyObject * obj1 = 0 ;
13300 char *kwnames[] = {
13301 (char *) "self",(char *) "zPos", NULL
13302 };
13303
13304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13306 if (SWIG_arg_fail(1)) SWIG_fail;
13307 {
13308 arg2 = (int)(SWIG_As_int(obj1));
13309 if (SWIG_arg_fail(2)) SWIG_fail;
13310 }
13311 {
13312 PyThreadState* __tstate = wxPyBeginAllowThreads();
13313 (arg1)->SetZPosition(arg2);
13314
13315 wxPyEndAllowThreads(__tstate);
13316 if (PyErr_Occurred()) SWIG_fail;
13317 }
13318 Py_INCREF(Py_None); resultobj = Py_None;
13319 return resultobj;
13320 fail:
13321 return NULL;
13322 }
13323
13324
13325 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13326 PyObject *resultobj;
13327 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13328 bool result;
13329 PyObject * obj0 = 0 ;
13330 char *kwnames[] = {
13331 (char *) "self", NULL
13332 };
13333
13334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13336 if (SWIG_arg_fail(1)) SWIG_fail;
13337 {
13338 PyThreadState* __tstate = wxPyBeginAllowThreads();
13339 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13340
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 {
13345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13346 }
13347 return resultobj;
13348 fail:
13349 return NULL;
13350 }
13351
13352
13353 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13354 PyObject *resultobj;
13355 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13356 bool result;
13357 PyObject * obj0 = 0 ;
13358 char *kwnames[] = {
13359 (char *) "self", NULL
13360 };
13361
13362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13364 if (SWIG_arg_fail(1)) SWIG_fail;
13365 {
13366 PyThreadState* __tstate = wxPyBeginAllowThreads();
13367 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13368
13369 wxPyEndAllowThreads(__tstate);
13370 if (PyErr_Occurred()) SWIG_fail;
13371 }
13372 {
13373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13374 }
13375 return resultobj;
13376 fail:
13377 return NULL;
13378 }
13379
13380
13381 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13382 PyObject *resultobj;
13383 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13384 bool result;
13385 PyObject * obj0 = 0 ;
13386 char *kwnames[] = {
13387 (char *) "self", NULL
13388 };
13389
13390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13392 if (SWIG_arg_fail(1)) SWIG_fail;
13393 {
13394 PyThreadState* __tstate = wxPyBeginAllowThreads();
13395 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13396
13397 wxPyEndAllowThreads(__tstate);
13398 if (PyErr_Occurred()) SWIG_fail;
13399 }
13400 {
13401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13402 }
13403 return resultobj;
13404 fail:
13405 return NULL;
13406 }
13407
13408
13409 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13410 PyObject *resultobj;
13411 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13412 int arg2 = (int) wxJOY_BUTTON_ANY ;
13413 bool result;
13414 PyObject * obj0 = 0 ;
13415 PyObject * obj1 = 0 ;
13416 char *kwnames[] = {
13417 (char *) "self",(char *) "but", NULL
13418 };
13419
13420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13422 if (SWIG_arg_fail(1)) SWIG_fail;
13423 if (obj1) {
13424 {
13425 arg2 = (int)(SWIG_As_int(obj1));
13426 if (SWIG_arg_fail(2)) SWIG_fail;
13427 }
13428 }
13429 {
13430 PyThreadState* __tstate = wxPyBeginAllowThreads();
13431 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13432
13433 wxPyEndAllowThreads(__tstate);
13434 if (PyErr_Occurred()) SWIG_fail;
13435 }
13436 {
13437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13438 }
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13446 PyObject *resultobj;
13447 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13448 int arg2 = (int) wxJOY_BUTTON_ANY ;
13449 bool result;
13450 PyObject * obj0 = 0 ;
13451 PyObject * obj1 = 0 ;
13452 char *kwnames[] = {
13453 (char *) "self",(char *) "but", NULL
13454 };
13455
13456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13458 if (SWIG_arg_fail(1)) SWIG_fail;
13459 if (obj1) {
13460 {
13461 arg2 = (int)(SWIG_As_int(obj1));
13462 if (SWIG_arg_fail(2)) SWIG_fail;
13463 }
13464 }
13465 {
13466 PyThreadState* __tstate = wxPyBeginAllowThreads();
13467 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13468
13469 wxPyEndAllowThreads(__tstate);
13470 if (PyErr_Occurred()) SWIG_fail;
13471 }
13472 {
13473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13474 }
13475 return resultobj;
13476 fail:
13477 return NULL;
13478 }
13479
13480
13481 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj;
13483 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13484 int arg2 = (int) wxJOY_BUTTON_ANY ;
13485 bool result;
13486 PyObject * obj0 = 0 ;
13487 PyObject * obj1 = 0 ;
13488 char *kwnames[] = {
13489 (char *) "self",(char *) "but", NULL
13490 };
13491
13492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13494 if (SWIG_arg_fail(1)) SWIG_fail;
13495 if (obj1) {
13496 {
13497 arg2 = (int)(SWIG_As_int(obj1));
13498 if (SWIG_arg_fail(2)) SWIG_fail;
13499 }
13500 }
13501 {
13502 PyThreadState* __tstate = wxPyBeginAllowThreads();
13503 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13504
13505 wxPyEndAllowThreads(__tstate);
13506 if (PyErr_Occurred()) SWIG_fail;
13507 }
13508 {
13509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13510 }
13511 return resultobj;
13512 fail:
13513 return NULL;
13514 }
13515
13516
13517 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13518 PyObject *obj;
13519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13520 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13521 Py_INCREF(obj);
13522 return Py_BuildValue((char *)"");
13523 }
13524 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13525 PyObject *resultobj;
13526 wxString const &arg1_defvalue = wxPyEmptyString ;
13527 wxString *arg1 = (wxString *) &arg1_defvalue ;
13528 wxSound *result;
13529 bool temp1 = false ;
13530 PyObject * obj0 = 0 ;
13531 char *kwnames[] = {
13532 (char *) "fileName", NULL
13533 };
13534
13535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13536 if (obj0) {
13537 {
13538 arg1 = wxString_in_helper(obj0);
13539 if (arg1 == NULL) SWIG_fail;
13540 temp1 = true;
13541 }
13542 }
13543 {
13544 if (!wxPyCheckForApp()) SWIG_fail;
13545 PyThreadState* __tstate = wxPyBeginAllowThreads();
13546 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13547
13548 wxPyEndAllowThreads(__tstate);
13549 if (PyErr_Occurred()) SWIG_fail;
13550 }
13551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13552 {
13553 if (temp1)
13554 delete arg1;
13555 }
13556 return resultobj;
13557 fail:
13558 {
13559 if (temp1)
13560 delete arg1;
13561 }
13562 return NULL;
13563 }
13564
13565
13566 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13567 PyObject *resultobj;
13568 PyObject *arg1 = (PyObject *) 0 ;
13569 wxSound *result;
13570 PyObject * obj0 = 0 ;
13571 char *kwnames[] = {
13572 (char *) "data", NULL
13573 };
13574
13575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13576 arg1 = obj0;
13577 {
13578 if (!wxPyCheckForApp()) SWIG_fail;
13579 PyThreadState* __tstate = wxPyBeginAllowThreads();
13580 result = (wxSound *)new_wxSound(arg1);
13581
13582 wxPyEndAllowThreads(__tstate);
13583 if (PyErr_Occurred()) SWIG_fail;
13584 }
13585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13586 return resultobj;
13587 fail:
13588 return NULL;
13589 }
13590
13591
13592 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13593 PyObject *resultobj;
13594 wxSound *arg1 = (wxSound *) 0 ;
13595 PyObject * obj0 = 0 ;
13596 char *kwnames[] = {
13597 (char *) "self", NULL
13598 };
13599
13600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13602 if (SWIG_arg_fail(1)) SWIG_fail;
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 delete arg1;
13606
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 Py_INCREF(Py_None); resultobj = Py_None;
13611 return resultobj;
13612 fail:
13613 return NULL;
13614 }
13615
13616
13617 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13618 PyObject *resultobj;
13619 wxSound *arg1 = (wxSound *) 0 ;
13620 wxString *arg2 = 0 ;
13621 bool result;
13622 bool temp2 = false ;
13623 PyObject * obj0 = 0 ;
13624 PyObject * obj1 = 0 ;
13625 char *kwnames[] = {
13626 (char *) "self",(char *) "fileName", NULL
13627 };
13628
13629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13631 if (SWIG_arg_fail(1)) SWIG_fail;
13632 {
13633 arg2 = wxString_in_helper(obj1);
13634 if (arg2 == NULL) SWIG_fail;
13635 temp2 = true;
13636 }
13637 {
13638 PyThreadState* __tstate = wxPyBeginAllowThreads();
13639 result = (bool)(arg1)->Create((wxString const &)*arg2);
13640
13641 wxPyEndAllowThreads(__tstate);
13642 if (PyErr_Occurred()) SWIG_fail;
13643 }
13644 {
13645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13646 }
13647 {
13648 if (temp2)
13649 delete arg2;
13650 }
13651 return resultobj;
13652 fail:
13653 {
13654 if (temp2)
13655 delete arg2;
13656 }
13657 return NULL;
13658 }
13659
13660
13661 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13662 PyObject *resultobj;
13663 wxSound *arg1 = (wxSound *) 0 ;
13664 PyObject *arg2 = (PyObject *) 0 ;
13665 bool result;
13666 PyObject * obj0 = 0 ;
13667 PyObject * obj1 = 0 ;
13668 char *kwnames[] = {
13669 (char *) "self",(char *) "data", NULL
13670 };
13671
13672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13674 if (SWIG_arg_fail(1)) SWIG_fail;
13675 arg2 = obj1;
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 result = (bool)wxSound_CreateFromData(arg1,arg2);
13679
13680 wxPyEndAllowThreads(__tstate);
13681 if (PyErr_Occurred()) SWIG_fail;
13682 }
13683 {
13684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13685 }
13686 return resultobj;
13687 fail:
13688 return NULL;
13689 }
13690
13691
13692 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13693 PyObject *resultobj;
13694 wxSound *arg1 = (wxSound *) 0 ;
13695 bool result;
13696 PyObject * obj0 = 0 ;
13697 char *kwnames[] = {
13698 (char *) "self", NULL
13699 };
13700
13701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13703 if (SWIG_arg_fail(1)) SWIG_fail;
13704 {
13705 PyThreadState* __tstate = wxPyBeginAllowThreads();
13706 result = (bool)(arg1)->IsOk();
13707
13708 wxPyEndAllowThreads(__tstate);
13709 if (PyErr_Occurred()) SWIG_fail;
13710 }
13711 {
13712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13713 }
13714 return resultobj;
13715 fail:
13716 return NULL;
13717 }
13718
13719
13720 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13721 PyObject *resultobj;
13722 wxSound *arg1 = (wxSound *) 0 ;
13723 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13724 bool result;
13725 PyObject * obj0 = 0 ;
13726 PyObject * obj1 = 0 ;
13727 char *kwnames[] = {
13728 (char *) "self",(char *) "flags", NULL
13729 };
13730
13731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13733 if (SWIG_arg_fail(1)) SWIG_fail;
13734 if (obj1) {
13735 {
13736 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13737 if (SWIG_arg_fail(2)) SWIG_fail;
13738 }
13739 }
13740 {
13741 if (!wxPyCheckForApp()) SWIG_fail;
13742 PyThreadState* __tstate = wxPyBeginAllowThreads();
13743 result = (bool)((wxSound const *)arg1)->Play(arg2);
13744
13745 wxPyEndAllowThreads(__tstate);
13746 if (PyErr_Occurred()) SWIG_fail;
13747 }
13748 {
13749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13750 }
13751 return resultobj;
13752 fail:
13753 return NULL;
13754 }
13755
13756
13757 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj;
13759 wxString *arg1 = 0 ;
13760 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13761 bool result;
13762 bool temp1 = false ;
13763 PyObject * obj0 = 0 ;
13764 PyObject * obj1 = 0 ;
13765 char *kwnames[] = {
13766 (char *) "filename",(char *) "flags", NULL
13767 };
13768
13769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13770 {
13771 arg1 = wxString_in_helper(obj0);
13772 if (arg1 == NULL) SWIG_fail;
13773 temp1 = true;
13774 }
13775 if (obj1) {
13776 {
13777 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13778 if (SWIG_arg_fail(2)) SWIG_fail;
13779 }
13780 }
13781 {
13782 if (!wxPyCheckForApp()) SWIG_fail;
13783 PyThreadState* __tstate = wxPyBeginAllowThreads();
13784 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13785
13786 wxPyEndAllowThreads(__tstate);
13787 if (PyErr_Occurred()) SWIG_fail;
13788 }
13789 {
13790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13791 }
13792 {
13793 if (temp1)
13794 delete arg1;
13795 }
13796 return resultobj;
13797 fail:
13798 {
13799 if (temp1)
13800 delete arg1;
13801 }
13802 return NULL;
13803 }
13804
13805
13806 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13807 PyObject *resultobj;
13808 char *kwnames[] = {
13809 NULL
13810 };
13811
13812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13813 {
13814 if (!wxPyCheckForApp()) SWIG_fail;
13815 PyThreadState* __tstate = wxPyBeginAllowThreads();
13816 wxSound::Stop();
13817
13818 wxPyEndAllowThreads(__tstate);
13819 if (PyErr_Occurred()) SWIG_fail;
13820 }
13821 Py_INCREF(Py_None); resultobj = Py_None;
13822 return resultobj;
13823 fail:
13824 return NULL;
13825 }
13826
13827
13828 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13829 PyObject *obj;
13830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13831 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13832 Py_INCREF(obj);
13833 return Py_BuildValue((char *)"");
13834 }
13835 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13836 PyObject *resultobj;
13837 wxString *arg1 = 0 ;
13838 wxString *arg2 = 0 ;
13839 wxString *arg3 = 0 ;
13840 wxString *arg4 = 0 ;
13841 wxFileTypeInfo *result;
13842 bool temp1 = false ;
13843 bool temp2 = false ;
13844 bool temp3 = false ;
13845 bool temp4 = false ;
13846 PyObject * obj0 = 0 ;
13847 PyObject * obj1 = 0 ;
13848 PyObject * obj2 = 0 ;
13849 PyObject * obj3 = 0 ;
13850 char *kwnames[] = {
13851 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13852 };
13853
13854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13855 {
13856 arg1 = wxString_in_helper(obj0);
13857 if (arg1 == NULL) SWIG_fail;
13858 temp1 = true;
13859 }
13860 {
13861 arg2 = wxString_in_helper(obj1);
13862 if (arg2 == NULL) SWIG_fail;
13863 temp2 = true;
13864 }
13865 {
13866 arg3 = wxString_in_helper(obj2);
13867 if (arg3 == NULL) SWIG_fail;
13868 temp3 = true;
13869 }
13870 {
13871 arg4 = wxString_in_helper(obj3);
13872 if (arg4 == NULL) SWIG_fail;
13873 temp4 = true;
13874 }
13875 {
13876 PyThreadState* __tstate = wxPyBeginAllowThreads();
13877 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13878
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13883 {
13884 if (temp1)
13885 delete arg1;
13886 }
13887 {
13888 if (temp2)
13889 delete arg2;
13890 }
13891 {
13892 if (temp3)
13893 delete arg3;
13894 }
13895 {
13896 if (temp4)
13897 delete arg4;
13898 }
13899 return resultobj;
13900 fail:
13901 {
13902 if (temp1)
13903 delete arg1;
13904 }
13905 {
13906 if (temp2)
13907 delete arg2;
13908 }
13909 {
13910 if (temp3)
13911 delete arg3;
13912 }
13913 {
13914 if (temp4)
13915 delete arg4;
13916 }
13917 return NULL;
13918 }
13919
13920
13921 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13922 PyObject *resultobj;
13923 wxArrayString *arg1 = 0 ;
13924 wxFileTypeInfo *result;
13925 bool temp1 = false ;
13926 PyObject * obj0 = 0 ;
13927 char *kwnames[] = {
13928 (char *) "sArray", NULL
13929 };
13930
13931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13932 {
13933 if (! PySequence_Check(obj0)) {
13934 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13935 SWIG_fail;
13936 }
13937 arg1 = new wxArrayString;
13938 temp1 = true;
13939 int i, len=PySequence_Length(obj0);
13940 for (i=0; i<len; i++) {
13941 PyObject* item = PySequence_GetItem(obj0, i);
13942 #if wxUSE_UNICODE
13943 PyObject* str = PyObject_Unicode(item);
13944 #else
13945 PyObject* str = PyObject_Str(item);
13946 #endif
13947 if (PyErr_Occurred()) SWIG_fail;
13948 arg1->Add(Py2wxString(str));
13949 Py_DECREF(item);
13950 Py_DECREF(str);
13951 }
13952 }
13953 {
13954 PyThreadState* __tstate = wxPyBeginAllowThreads();
13955 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13956
13957 wxPyEndAllowThreads(__tstate);
13958 if (PyErr_Occurred()) SWIG_fail;
13959 }
13960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13961 {
13962 if (temp1) delete arg1;
13963 }
13964 return resultobj;
13965 fail:
13966 {
13967 if (temp1) delete arg1;
13968 }
13969 return NULL;
13970 }
13971
13972
13973 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13974 PyObject *resultobj;
13975 wxFileTypeInfo *result;
13976 char *kwnames[] = {
13977 NULL
13978 };
13979
13980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13981 {
13982 PyThreadState* __tstate = wxPyBeginAllowThreads();
13983 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13984
13985 wxPyEndAllowThreads(__tstate);
13986 if (PyErr_Occurred()) SWIG_fail;
13987 }
13988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13989 return resultobj;
13990 fail:
13991 return NULL;
13992 }
13993
13994
13995 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13996 PyObject *resultobj;
13997 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13998 bool result;
13999 PyObject * obj0 = 0 ;
14000 char *kwnames[] = {
14001 (char *) "self", NULL
14002 };
14003
14004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
14005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14006 if (SWIG_arg_fail(1)) SWIG_fail;
14007 {
14008 PyThreadState* __tstate = wxPyBeginAllowThreads();
14009 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
14010
14011 wxPyEndAllowThreads(__tstate);
14012 if (PyErr_Occurred()) SWIG_fail;
14013 }
14014 {
14015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14016 }
14017 return resultobj;
14018 fail:
14019 return NULL;
14020 }
14021
14022
14023 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14024 PyObject *resultobj;
14025 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14026 wxString *arg2 = 0 ;
14027 int arg3 = (int) 0 ;
14028 bool temp2 = false ;
14029 PyObject * obj0 = 0 ;
14030 PyObject * obj1 = 0 ;
14031 PyObject * obj2 = 0 ;
14032 char *kwnames[] = {
14033 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
14034 };
14035
14036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14038 if (SWIG_arg_fail(1)) SWIG_fail;
14039 {
14040 arg2 = wxString_in_helper(obj1);
14041 if (arg2 == NULL) SWIG_fail;
14042 temp2 = true;
14043 }
14044 if (obj2) {
14045 {
14046 arg3 = (int)(SWIG_As_int(obj2));
14047 if (SWIG_arg_fail(3)) SWIG_fail;
14048 }
14049 }
14050 {
14051 PyThreadState* __tstate = wxPyBeginAllowThreads();
14052 (arg1)->SetIcon((wxString const &)*arg2,arg3);
14053
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 Py_INCREF(Py_None); resultobj = Py_None;
14058 {
14059 if (temp2)
14060 delete arg2;
14061 }
14062 return resultobj;
14063 fail:
14064 {
14065 if (temp2)
14066 delete arg2;
14067 }
14068 return NULL;
14069 }
14070
14071
14072 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14073 PyObject *resultobj;
14074 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14075 wxString *arg2 = 0 ;
14076 bool temp2 = false ;
14077 PyObject * obj0 = 0 ;
14078 PyObject * obj1 = 0 ;
14079 char *kwnames[] = {
14080 (char *) "self",(char *) "shortDesc", NULL
14081 };
14082
14083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14085 if (SWIG_arg_fail(1)) SWIG_fail;
14086 {
14087 arg2 = wxString_in_helper(obj1);
14088 if (arg2 == NULL) SWIG_fail;
14089 temp2 = true;
14090 }
14091 {
14092 PyThreadState* __tstate = wxPyBeginAllowThreads();
14093 (arg1)->SetShortDesc((wxString const &)*arg2);
14094
14095 wxPyEndAllowThreads(__tstate);
14096 if (PyErr_Occurred()) SWIG_fail;
14097 }
14098 Py_INCREF(Py_None); resultobj = Py_None;
14099 {
14100 if (temp2)
14101 delete arg2;
14102 }
14103 return resultobj;
14104 fail:
14105 {
14106 if (temp2)
14107 delete arg2;
14108 }
14109 return NULL;
14110 }
14111
14112
14113 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj;
14115 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14116 wxString *result;
14117 PyObject * obj0 = 0 ;
14118 char *kwnames[] = {
14119 (char *) "self", NULL
14120 };
14121
14122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14124 if (SWIG_arg_fail(1)) SWIG_fail;
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 {
14128 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14129 result = (wxString *) &_result_ref;
14130 }
14131
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 {
14136 #if wxUSE_UNICODE
14137 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14138 #else
14139 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14140 #endif
14141 }
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14149 PyObject *resultobj;
14150 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14151 wxString *result;
14152 PyObject * obj0 = 0 ;
14153 char *kwnames[] = {
14154 (char *) "self", NULL
14155 };
14156
14157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14159 if (SWIG_arg_fail(1)) SWIG_fail;
14160 {
14161 PyThreadState* __tstate = wxPyBeginAllowThreads();
14162 {
14163 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14164 result = (wxString *) &_result_ref;
14165 }
14166
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 {
14171 #if wxUSE_UNICODE
14172 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14173 #else
14174 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14175 #endif
14176 }
14177 return resultobj;
14178 fail:
14179 return NULL;
14180 }
14181
14182
14183 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14184 PyObject *resultobj;
14185 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14186 wxString *result;
14187 PyObject * obj0 = 0 ;
14188 char *kwnames[] = {
14189 (char *) "self", NULL
14190 };
14191
14192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14194 if (SWIG_arg_fail(1)) SWIG_fail;
14195 {
14196 PyThreadState* __tstate = wxPyBeginAllowThreads();
14197 {
14198 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14199 result = (wxString *) &_result_ref;
14200 }
14201
14202 wxPyEndAllowThreads(__tstate);
14203 if (PyErr_Occurred()) SWIG_fail;
14204 }
14205 {
14206 #if wxUSE_UNICODE
14207 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14208 #else
14209 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14210 #endif
14211 }
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14219 PyObject *resultobj;
14220 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14221 wxString *result;
14222 PyObject * obj0 = 0 ;
14223 char *kwnames[] = {
14224 (char *) "self", NULL
14225 };
14226
14227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14229 if (SWIG_arg_fail(1)) SWIG_fail;
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 {
14233 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14234 result = (wxString *) &_result_ref;
14235 }
14236
14237 wxPyEndAllowThreads(__tstate);
14238 if (PyErr_Occurred()) SWIG_fail;
14239 }
14240 {
14241 #if wxUSE_UNICODE
14242 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14243 #else
14244 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14245 #endif
14246 }
14247 return resultobj;
14248 fail:
14249 return NULL;
14250 }
14251
14252
14253 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14254 PyObject *resultobj;
14255 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14256 wxString *result;
14257 PyObject * obj0 = 0 ;
14258 char *kwnames[] = {
14259 (char *) "self", NULL
14260 };
14261
14262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14264 if (SWIG_arg_fail(1)) SWIG_fail;
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 {
14268 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14269 result = (wxString *) &_result_ref;
14270 }
14271
14272 wxPyEndAllowThreads(__tstate);
14273 if (PyErr_Occurred()) SWIG_fail;
14274 }
14275 {
14276 #if wxUSE_UNICODE
14277 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14278 #else
14279 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14280 #endif
14281 }
14282 return resultobj;
14283 fail:
14284 return NULL;
14285 }
14286
14287
14288 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14289 PyObject *resultobj;
14290 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14291 wxArrayString *result;
14292 PyObject * obj0 = 0 ;
14293 char *kwnames[] = {
14294 (char *) "self", NULL
14295 };
14296
14297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14299 if (SWIG_arg_fail(1)) SWIG_fail;
14300 {
14301 PyThreadState* __tstate = wxPyBeginAllowThreads();
14302 {
14303 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14304 result = (wxArrayString *) &_result_ref;
14305 }
14306
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 {
14311 resultobj = wxArrayString2PyList_helper(*result);
14312 }
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj;
14321 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14322 int result;
14323 PyObject * obj0 = 0 ;
14324 char *kwnames[] = {
14325 (char *) "self", NULL
14326 };
14327
14328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14330 if (SWIG_arg_fail(1)) SWIG_fail;
14331 {
14332 PyThreadState* __tstate = wxPyBeginAllowThreads();
14333 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14334
14335 wxPyEndAllowThreads(__tstate);
14336 if (PyErr_Occurred()) SWIG_fail;
14337 }
14338 {
14339 resultobj = SWIG_From_int((int)(result));
14340 }
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj;
14349 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14350 wxString *result;
14351 PyObject * obj0 = 0 ;
14352 char *kwnames[] = {
14353 (char *) "self", NULL
14354 };
14355
14356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14358 if (SWIG_arg_fail(1)) SWIG_fail;
14359 {
14360 PyThreadState* __tstate = wxPyBeginAllowThreads();
14361 {
14362 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14363 result = (wxString *) &_result_ref;
14364 }
14365
14366 wxPyEndAllowThreads(__tstate);
14367 if (PyErr_Occurred()) SWIG_fail;
14368 }
14369 {
14370 #if wxUSE_UNICODE
14371 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14372 #else
14373 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14374 #endif
14375 }
14376 return resultobj;
14377 fail:
14378 return NULL;
14379 }
14380
14381
14382 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14383 PyObject *resultobj;
14384 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14385 int result;
14386 PyObject * obj0 = 0 ;
14387 char *kwnames[] = {
14388 (char *) "self", NULL
14389 };
14390
14391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14393 if (SWIG_arg_fail(1)) SWIG_fail;
14394 {
14395 PyThreadState* __tstate = wxPyBeginAllowThreads();
14396 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14397
14398 wxPyEndAllowThreads(__tstate);
14399 if (PyErr_Occurred()) SWIG_fail;
14400 }
14401 {
14402 resultobj = SWIG_From_int((int)(result));
14403 }
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14411 PyObject *obj;
14412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14413 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14414 Py_INCREF(obj);
14415 return Py_BuildValue((char *)"");
14416 }
14417 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14418 PyObject *resultobj;
14419 wxFileTypeInfo *arg1 = 0 ;
14420 wxFileType *result;
14421 PyObject * obj0 = 0 ;
14422 char *kwnames[] = {
14423 (char *) "ftInfo", NULL
14424 };
14425
14426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14427 {
14428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14429 if (SWIG_arg_fail(1)) SWIG_fail;
14430 if (arg1 == NULL) {
14431 SWIG_null_ref("wxFileTypeInfo");
14432 }
14433 if (SWIG_arg_fail(1)) SWIG_fail;
14434 }
14435 {
14436 PyThreadState* __tstate = wxPyBeginAllowThreads();
14437 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14438
14439 wxPyEndAllowThreads(__tstate);
14440 if (PyErr_Occurred()) SWIG_fail;
14441 }
14442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14443 return resultobj;
14444 fail:
14445 return NULL;
14446 }
14447
14448
14449 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj;
14451 wxFileType *arg1 = (wxFileType *) 0 ;
14452 PyObject * obj0 = 0 ;
14453 char *kwnames[] = {
14454 (char *) "self", NULL
14455 };
14456
14457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14459 if (SWIG_arg_fail(1)) SWIG_fail;
14460 {
14461 PyThreadState* __tstate = wxPyBeginAllowThreads();
14462 delete arg1;
14463
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 Py_INCREF(Py_None); resultobj = Py_None;
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj;
14476 wxFileType *arg1 = (wxFileType *) 0 ;
14477 PyObject *result;
14478 PyObject * obj0 = 0 ;
14479 char *kwnames[] = {
14480 (char *) "self", NULL
14481 };
14482
14483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14485 if (SWIG_arg_fail(1)) SWIG_fail;
14486 {
14487 PyThreadState* __tstate = wxPyBeginAllowThreads();
14488 result = (PyObject *)wxFileType_GetMimeType(arg1);
14489
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 resultobj = result;
14494 return resultobj;
14495 fail:
14496 return NULL;
14497 }
14498
14499
14500 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14501 PyObject *resultobj;
14502 wxFileType *arg1 = (wxFileType *) 0 ;
14503 PyObject *result;
14504 PyObject * obj0 = 0 ;
14505 char *kwnames[] = {
14506 (char *) "self", NULL
14507 };
14508
14509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14511 if (SWIG_arg_fail(1)) SWIG_fail;
14512 {
14513 PyThreadState* __tstate = wxPyBeginAllowThreads();
14514 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14515
14516 wxPyEndAllowThreads(__tstate);
14517 if (PyErr_Occurred()) SWIG_fail;
14518 }
14519 resultobj = result;
14520 return resultobj;
14521 fail:
14522 return NULL;
14523 }
14524
14525
14526 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14527 PyObject *resultobj;
14528 wxFileType *arg1 = (wxFileType *) 0 ;
14529 PyObject *result;
14530 PyObject * obj0 = 0 ;
14531 char *kwnames[] = {
14532 (char *) "self", NULL
14533 };
14534
14535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14537 if (SWIG_arg_fail(1)) SWIG_fail;
14538 {
14539 PyThreadState* __tstate = wxPyBeginAllowThreads();
14540 result = (PyObject *)wxFileType_GetExtensions(arg1);
14541
14542 wxPyEndAllowThreads(__tstate);
14543 if (PyErr_Occurred()) SWIG_fail;
14544 }
14545 resultobj = result;
14546 return resultobj;
14547 fail:
14548 return NULL;
14549 }
14550
14551
14552 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14553 PyObject *resultobj;
14554 wxFileType *arg1 = (wxFileType *) 0 ;
14555 wxIcon *result;
14556 PyObject * obj0 = 0 ;
14557 char *kwnames[] = {
14558 (char *) "self", NULL
14559 };
14560
14561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14563 if (SWIG_arg_fail(1)) SWIG_fail;
14564 {
14565 PyThreadState* __tstate = wxPyBeginAllowThreads();
14566 result = (wxIcon *)wxFileType_GetIcon(arg1);
14567
14568 wxPyEndAllowThreads(__tstate);
14569 if (PyErr_Occurred()) SWIG_fail;
14570 }
14571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14572 return resultobj;
14573 fail:
14574 return NULL;
14575 }
14576
14577
14578 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14579 PyObject *resultobj;
14580 wxFileType *arg1 = (wxFileType *) 0 ;
14581 PyObject *result;
14582 PyObject * obj0 = 0 ;
14583 char *kwnames[] = {
14584 (char *) "self", NULL
14585 };
14586
14587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14589 if (SWIG_arg_fail(1)) SWIG_fail;
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14593
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 resultobj = result;
14598 return resultobj;
14599 fail:
14600 return NULL;
14601 }
14602
14603
14604 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14605 PyObject *resultobj;
14606 wxFileType *arg1 = (wxFileType *) 0 ;
14607 PyObject *result;
14608 PyObject * obj0 = 0 ;
14609 char *kwnames[] = {
14610 (char *) "self", NULL
14611 };
14612
14613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14615 if (SWIG_arg_fail(1)) SWIG_fail;
14616 {
14617 PyThreadState* __tstate = wxPyBeginAllowThreads();
14618 result = (PyObject *)wxFileType_GetDescription(arg1);
14619
14620 wxPyEndAllowThreads(__tstate);
14621 if (PyErr_Occurred()) SWIG_fail;
14622 }
14623 resultobj = result;
14624 return resultobj;
14625 fail:
14626 return NULL;
14627 }
14628
14629
14630 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14631 PyObject *resultobj;
14632 wxFileType *arg1 = (wxFileType *) 0 ;
14633 wxString *arg2 = 0 ;
14634 wxString const &arg3_defvalue = wxPyEmptyString ;
14635 wxString *arg3 = (wxString *) &arg3_defvalue ;
14636 PyObject *result;
14637 bool temp2 = false ;
14638 bool temp3 = false ;
14639 PyObject * obj0 = 0 ;
14640 PyObject * obj1 = 0 ;
14641 PyObject * obj2 = 0 ;
14642 char *kwnames[] = {
14643 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14644 };
14645
14646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14648 if (SWIG_arg_fail(1)) SWIG_fail;
14649 {
14650 arg2 = wxString_in_helper(obj1);
14651 if (arg2 == NULL) SWIG_fail;
14652 temp2 = true;
14653 }
14654 if (obj2) {
14655 {
14656 arg3 = wxString_in_helper(obj2);
14657 if (arg3 == NULL) SWIG_fail;
14658 temp3 = true;
14659 }
14660 }
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14664
14665 wxPyEndAllowThreads(__tstate);
14666 if (PyErr_Occurred()) SWIG_fail;
14667 }
14668 resultobj = result;
14669 {
14670 if (temp2)
14671 delete arg2;
14672 }
14673 {
14674 if (temp3)
14675 delete arg3;
14676 }
14677 return resultobj;
14678 fail:
14679 {
14680 if (temp2)
14681 delete arg2;
14682 }
14683 {
14684 if (temp3)
14685 delete arg3;
14686 }
14687 return NULL;
14688 }
14689
14690
14691 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14692 PyObject *resultobj;
14693 wxFileType *arg1 = (wxFileType *) 0 ;
14694 wxString *arg2 = 0 ;
14695 wxString const &arg3_defvalue = wxPyEmptyString ;
14696 wxString *arg3 = (wxString *) &arg3_defvalue ;
14697 PyObject *result;
14698 bool temp2 = false ;
14699 bool temp3 = false ;
14700 PyObject * obj0 = 0 ;
14701 PyObject * obj1 = 0 ;
14702 PyObject * obj2 = 0 ;
14703 char *kwnames[] = {
14704 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14705 };
14706
14707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14709 if (SWIG_arg_fail(1)) SWIG_fail;
14710 {
14711 arg2 = wxString_in_helper(obj1);
14712 if (arg2 == NULL) SWIG_fail;
14713 temp2 = true;
14714 }
14715 if (obj2) {
14716 {
14717 arg3 = wxString_in_helper(obj2);
14718 if (arg3 == NULL) SWIG_fail;
14719 temp3 = true;
14720 }
14721 }
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14725
14726 wxPyEndAllowThreads(__tstate);
14727 if (PyErr_Occurred()) SWIG_fail;
14728 }
14729 resultobj = result;
14730 {
14731 if (temp2)
14732 delete arg2;
14733 }
14734 {
14735 if (temp3)
14736 delete arg3;
14737 }
14738 return resultobj;
14739 fail:
14740 {
14741 if (temp2)
14742 delete arg2;
14743 }
14744 {
14745 if (temp3)
14746 delete arg3;
14747 }
14748 return NULL;
14749 }
14750
14751
14752 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14753 PyObject *resultobj;
14754 wxFileType *arg1 = (wxFileType *) 0 ;
14755 wxString *arg2 = 0 ;
14756 wxString const &arg3_defvalue = wxPyEmptyString ;
14757 wxString *arg3 = (wxString *) &arg3_defvalue ;
14758 PyObject *result;
14759 bool temp2 = false ;
14760 bool temp3 = false ;
14761 PyObject * obj0 = 0 ;
14762 PyObject * obj1 = 0 ;
14763 PyObject * obj2 = 0 ;
14764 char *kwnames[] = {
14765 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14766 };
14767
14768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14770 if (SWIG_arg_fail(1)) SWIG_fail;
14771 {
14772 arg2 = wxString_in_helper(obj1);
14773 if (arg2 == NULL) SWIG_fail;
14774 temp2 = true;
14775 }
14776 if (obj2) {
14777 {
14778 arg3 = wxString_in_helper(obj2);
14779 if (arg3 == NULL) SWIG_fail;
14780 temp3 = true;
14781 }
14782 }
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14786
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 resultobj = result;
14791 {
14792 if (temp2)
14793 delete arg2;
14794 }
14795 {
14796 if (temp3)
14797 delete arg3;
14798 }
14799 return resultobj;
14800 fail:
14801 {
14802 if (temp2)
14803 delete arg2;
14804 }
14805 {
14806 if (temp3)
14807 delete arg3;
14808 }
14809 return NULL;
14810 }
14811
14812
14813 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14814 PyObject *resultobj;
14815 wxFileType *arg1 = (wxFileType *) 0 ;
14816 wxString *arg2 = 0 ;
14817 wxString *arg3 = 0 ;
14818 bool arg4 = (bool) true ;
14819 bool result;
14820 bool temp2 = false ;
14821 bool temp3 = false ;
14822 PyObject * obj0 = 0 ;
14823 PyObject * obj1 = 0 ;
14824 PyObject * obj2 = 0 ;
14825 PyObject * obj3 = 0 ;
14826 char *kwnames[] = {
14827 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14828 };
14829
14830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14832 if (SWIG_arg_fail(1)) SWIG_fail;
14833 {
14834 arg2 = wxString_in_helper(obj1);
14835 if (arg2 == NULL) SWIG_fail;
14836 temp2 = true;
14837 }
14838 {
14839 arg3 = wxString_in_helper(obj2);
14840 if (arg3 == NULL) SWIG_fail;
14841 temp3 = true;
14842 }
14843 if (obj3) {
14844 {
14845 arg4 = (bool)(SWIG_As_bool(obj3));
14846 if (SWIG_arg_fail(4)) SWIG_fail;
14847 }
14848 }
14849 {
14850 PyThreadState* __tstate = wxPyBeginAllowThreads();
14851 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14852
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 {
14857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14858 }
14859 {
14860 if (temp2)
14861 delete arg2;
14862 }
14863 {
14864 if (temp3)
14865 delete arg3;
14866 }
14867 return resultobj;
14868 fail:
14869 {
14870 if (temp2)
14871 delete arg2;
14872 }
14873 {
14874 if (temp3)
14875 delete arg3;
14876 }
14877 return NULL;
14878 }
14879
14880
14881 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14882 PyObject *resultobj;
14883 wxFileType *arg1 = (wxFileType *) 0 ;
14884 wxString const &arg2_defvalue = wxPyEmptyString ;
14885 wxString *arg2 = (wxString *) &arg2_defvalue ;
14886 int arg3 = (int) 0 ;
14887 bool result;
14888 bool temp2 = false ;
14889 PyObject * obj0 = 0 ;
14890 PyObject * obj1 = 0 ;
14891 PyObject * obj2 = 0 ;
14892 char *kwnames[] = {
14893 (char *) "self",(char *) "cmd",(char *) "index", NULL
14894 };
14895
14896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14898 if (SWIG_arg_fail(1)) SWIG_fail;
14899 if (obj1) {
14900 {
14901 arg2 = wxString_in_helper(obj1);
14902 if (arg2 == NULL) SWIG_fail;
14903 temp2 = true;
14904 }
14905 }
14906 if (obj2) {
14907 {
14908 arg3 = (int)(SWIG_As_int(obj2));
14909 if (SWIG_arg_fail(3)) SWIG_fail;
14910 }
14911 }
14912 {
14913 PyThreadState* __tstate = wxPyBeginAllowThreads();
14914 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14915
14916 wxPyEndAllowThreads(__tstate);
14917 if (PyErr_Occurred()) SWIG_fail;
14918 }
14919 {
14920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14921 }
14922 {
14923 if (temp2)
14924 delete arg2;
14925 }
14926 return resultobj;
14927 fail:
14928 {
14929 if (temp2)
14930 delete arg2;
14931 }
14932 return NULL;
14933 }
14934
14935
14936 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14937 PyObject *resultobj;
14938 wxFileType *arg1 = (wxFileType *) 0 ;
14939 bool result;
14940 PyObject * obj0 = 0 ;
14941 char *kwnames[] = {
14942 (char *) "self", NULL
14943 };
14944
14945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14947 if (SWIG_arg_fail(1)) SWIG_fail;
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 result = (bool)(arg1)->Unassociate();
14951
14952 wxPyEndAllowThreads(__tstate);
14953 if (PyErr_Occurred()) SWIG_fail;
14954 }
14955 {
14956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14957 }
14958 return resultobj;
14959 fail:
14960 return NULL;
14961 }
14962
14963
14964 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14965 PyObject *resultobj;
14966 wxString *arg1 = 0 ;
14967 wxString *arg2 = 0 ;
14968 wxString const &arg3_defvalue = wxPyEmptyString ;
14969 wxString *arg3 = (wxString *) &arg3_defvalue ;
14970 wxString result;
14971 bool temp1 = false ;
14972 bool temp2 = false ;
14973 bool temp3 = false ;
14974 PyObject * obj0 = 0 ;
14975 PyObject * obj1 = 0 ;
14976 PyObject * obj2 = 0 ;
14977 char *kwnames[] = {
14978 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14979 };
14980
14981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14982 {
14983 arg1 = wxString_in_helper(obj0);
14984 if (arg1 == NULL) SWIG_fail;
14985 temp1 = true;
14986 }
14987 {
14988 arg2 = wxString_in_helper(obj1);
14989 if (arg2 == NULL) SWIG_fail;
14990 temp2 = true;
14991 }
14992 if (obj2) {
14993 {
14994 arg3 = wxString_in_helper(obj2);
14995 if (arg3 == NULL) SWIG_fail;
14996 temp3 = true;
14997 }
14998 }
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15002
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 {
15007 #if wxUSE_UNICODE
15008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15009 #else
15010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15011 #endif
15012 }
15013 {
15014 if (temp1)
15015 delete arg1;
15016 }
15017 {
15018 if (temp2)
15019 delete arg2;
15020 }
15021 {
15022 if (temp3)
15023 delete arg3;
15024 }
15025 return resultobj;
15026 fail:
15027 {
15028 if (temp1)
15029 delete arg1;
15030 }
15031 {
15032 if (temp2)
15033 delete arg2;
15034 }
15035 {
15036 if (temp3)
15037 delete arg3;
15038 }
15039 return NULL;
15040 }
15041
15042
15043 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
15044 PyObject *obj;
15045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15046 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
15047 Py_INCREF(obj);
15048 return Py_BuildValue((char *)"");
15049 }
15050 static int _wrap_TheMimeTypesManager_set(PyObject *) {
15051 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
15052 return 1;
15053 }
15054
15055
15056 static PyObject *_wrap_TheMimeTypesManager_get(void) {
15057 PyObject *pyobj;
15058
15059 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
15060 return pyobj;
15061 }
15062
15063
15064 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj;
15066 wxString *arg1 = 0 ;
15067 wxString *arg2 = 0 ;
15068 bool result;
15069 bool temp1 = false ;
15070 bool temp2 = false ;
15071 PyObject * obj0 = 0 ;
15072 PyObject * obj1 = 0 ;
15073 char *kwnames[] = {
15074 (char *) "mimeType",(char *) "wildcard", NULL
15075 };
15076
15077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15078 {
15079 arg1 = wxString_in_helper(obj0);
15080 if (arg1 == NULL) SWIG_fail;
15081 temp1 = true;
15082 }
15083 {
15084 arg2 = wxString_in_helper(obj1);
15085 if (arg2 == NULL) SWIG_fail;
15086 temp2 = true;
15087 }
15088 {
15089 PyThreadState* __tstate = wxPyBeginAllowThreads();
15090 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15091
15092 wxPyEndAllowThreads(__tstate);
15093 if (PyErr_Occurred()) SWIG_fail;
15094 }
15095 {
15096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15097 }
15098 {
15099 if (temp1)
15100 delete arg1;
15101 }
15102 {
15103 if (temp2)
15104 delete arg2;
15105 }
15106 return resultobj;
15107 fail:
15108 {
15109 if (temp1)
15110 delete arg1;
15111 }
15112 {
15113 if (temp2)
15114 delete arg2;
15115 }
15116 return NULL;
15117 }
15118
15119
15120 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15121 PyObject *resultobj;
15122 wxMimeTypesManager *result;
15123 char *kwnames[] = {
15124 NULL
15125 };
15126
15127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15136 return resultobj;
15137 fail:
15138 return NULL;
15139 }
15140
15141
15142 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15143 PyObject *resultobj;
15144 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15145 int arg2 = (int) wxMAILCAP_ALL ;
15146 wxString const &arg3_defvalue = wxPyEmptyString ;
15147 wxString *arg3 = (wxString *) &arg3_defvalue ;
15148 bool temp3 = false ;
15149 PyObject * obj0 = 0 ;
15150 PyObject * obj1 = 0 ;
15151 PyObject * obj2 = 0 ;
15152 char *kwnames[] = {
15153 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15154 };
15155
15156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15158 if (SWIG_arg_fail(1)) SWIG_fail;
15159 if (obj1) {
15160 {
15161 arg2 = (int)(SWIG_As_int(obj1));
15162 if (SWIG_arg_fail(2)) SWIG_fail;
15163 }
15164 }
15165 if (obj2) {
15166 {
15167 arg3 = wxString_in_helper(obj2);
15168 if (arg3 == NULL) SWIG_fail;
15169 temp3 = true;
15170 }
15171 }
15172 {
15173 PyThreadState* __tstate = wxPyBeginAllowThreads();
15174 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15175
15176 wxPyEndAllowThreads(__tstate);
15177 if (PyErr_Occurred()) SWIG_fail;
15178 }
15179 Py_INCREF(Py_None); resultobj = Py_None;
15180 {
15181 if (temp3)
15182 delete arg3;
15183 }
15184 return resultobj;
15185 fail:
15186 {
15187 if (temp3)
15188 delete arg3;
15189 }
15190 return NULL;
15191 }
15192
15193
15194 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15195 PyObject *resultobj;
15196 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15197 PyObject * obj0 = 0 ;
15198 char *kwnames[] = {
15199 (char *) "self", NULL
15200 };
15201
15202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15204 if (SWIG_arg_fail(1)) SWIG_fail;
15205 {
15206 PyThreadState* __tstate = wxPyBeginAllowThreads();
15207 (arg1)->ClearData();
15208
15209 wxPyEndAllowThreads(__tstate);
15210 if (PyErr_Occurred()) SWIG_fail;
15211 }
15212 Py_INCREF(Py_None); resultobj = Py_None;
15213 return resultobj;
15214 fail:
15215 return NULL;
15216 }
15217
15218
15219 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj;
15221 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15222 wxString *arg2 = 0 ;
15223 wxFileType *result;
15224 bool temp2 = false ;
15225 PyObject * obj0 = 0 ;
15226 PyObject * obj1 = 0 ;
15227 char *kwnames[] = {
15228 (char *) "self",(char *) "ext", NULL
15229 };
15230
15231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15233 if (SWIG_arg_fail(1)) SWIG_fail;
15234 {
15235 arg2 = wxString_in_helper(obj1);
15236 if (arg2 == NULL) SWIG_fail;
15237 temp2 = true;
15238 }
15239 {
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15242
15243 wxPyEndAllowThreads(__tstate);
15244 if (PyErr_Occurred()) SWIG_fail;
15245 }
15246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15247 {
15248 if (temp2)
15249 delete arg2;
15250 }
15251 return resultobj;
15252 fail:
15253 {
15254 if (temp2)
15255 delete arg2;
15256 }
15257 return NULL;
15258 }
15259
15260
15261 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15262 PyObject *resultobj;
15263 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15264 wxString *arg2 = 0 ;
15265 wxFileType *result;
15266 bool temp2 = false ;
15267 PyObject * obj0 = 0 ;
15268 PyObject * obj1 = 0 ;
15269 char *kwnames[] = {
15270 (char *) "self",(char *) "mimeType", NULL
15271 };
15272
15273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15275 if (SWIG_arg_fail(1)) SWIG_fail;
15276 {
15277 arg2 = wxString_in_helper(obj1);
15278 if (arg2 == NULL) SWIG_fail;
15279 temp2 = true;
15280 }
15281 {
15282 PyThreadState* __tstate = wxPyBeginAllowThreads();
15283 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15284
15285 wxPyEndAllowThreads(__tstate);
15286 if (PyErr_Occurred()) SWIG_fail;
15287 }
15288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15289 {
15290 if (temp2)
15291 delete arg2;
15292 }
15293 return resultobj;
15294 fail:
15295 {
15296 if (temp2)
15297 delete arg2;
15298 }
15299 return NULL;
15300 }
15301
15302
15303 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15304 PyObject *resultobj;
15305 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15306 wxString *arg2 = 0 ;
15307 bool arg3 = (bool) false ;
15308 bool result;
15309 bool temp2 = false ;
15310 PyObject * obj0 = 0 ;
15311 PyObject * obj1 = 0 ;
15312 PyObject * obj2 = 0 ;
15313 char *kwnames[] = {
15314 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15315 };
15316
15317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15319 if (SWIG_arg_fail(1)) SWIG_fail;
15320 {
15321 arg2 = wxString_in_helper(obj1);
15322 if (arg2 == NULL) SWIG_fail;
15323 temp2 = true;
15324 }
15325 if (obj2) {
15326 {
15327 arg3 = (bool)(SWIG_As_bool(obj2));
15328 if (SWIG_arg_fail(3)) SWIG_fail;
15329 }
15330 }
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15334
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 {
15339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15340 }
15341 {
15342 if (temp2)
15343 delete arg2;
15344 }
15345 return resultobj;
15346 fail:
15347 {
15348 if (temp2)
15349 delete arg2;
15350 }
15351 return NULL;
15352 }
15353
15354
15355 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15356 PyObject *resultobj;
15357 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15358 wxString *arg2 = 0 ;
15359 bool result;
15360 bool temp2 = false ;
15361 PyObject * obj0 = 0 ;
15362 PyObject * obj1 = 0 ;
15363 char *kwnames[] = {
15364 (char *) "self",(char *) "filename", NULL
15365 };
15366
15367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15369 if (SWIG_arg_fail(1)) SWIG_fail;
15370 {
15371 arg2 = wxString_in_helper(obj1);
15372 if (arg2 == NULL) SWIG_fail;
15373 temp2 = true;
15374 }
15375 {
15376 PyThreadState* __tstate = wxPyBeginAllowThreads();
15377 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15378
15379 wxPyEndAllowThreads(__tstate);
15380 if (PyErr_Occurred()) SWIG_fail;
15381 }
15382 {
15383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15384 }
15385 {
15386 if (temp2)
15387 delete arg2;
15388 }
15389 return resultobj;
15390 fail:
15391 {
15392 if (temp2)
15393 delete arg2;
15394 }
15395 return NULL;
15396 }
15397
15398
15399 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15400 PyObject *resultobj;
15401 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15402 PyObject *result;
15403 PyObject * obj0 = 0 ;
15404 char *kwnames[] = {
15405 (char *) "self", NULL
15406 };
15407
15408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15410 if (SWIG_arg_fail(1)) SWIG_fail;
15411 {
15412 PyThreadState* __tstate = wxPyBeginAllowThreads();
15413 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15414
15415 wxPyEndAllowThreads(__tstate);
15416 if (PyErr_Occurred()) SWIG_fail;
15417 }
15418 resultobj = result;
15419 return resultobj;
15420 fail:
15421 return NULL;
15422 }
15423
15424
15425 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15426 PyObject *resultobj;
15427 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15428 wxFileTypeInfo *arg2 = 0 ;
15429 PyObject * obj0 = 0 ;
15430 PyObject * obj1 = 0 ;
15431 char *kwnames[] = {
15432 (char *) "self",(char *) "ft", NULL
15433 };
15434
15435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15437 if (SWIG_arg_fail(1)) SWIG_fail;
15438 {
15439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15440 if (SWIG_arg_fail(2)) SWIG_fail;
15441 if (arg2 == NULL) {
15442 SWIG_null_ref("wxFileTypeInfo");
15443 }
15444 if (SWIG_arg_fail(2)) SWIG_fail;
15445 }
15446 {
15447 PyThreadState* __tstate = wxPyBeginAllowThreads();
15448 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15449
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 Py_INCREF(Py_None); resultobj = Py_None;
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15461 PyObject *resultobj;
15462 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15463 wxFileTypeInfo *arg2 = 0 ;
15464 wxFileType *result;
15465 PyObject * obj0 = 0 ;
15466 PyObject * obj1 = 0 ;
15467 char *kwnames[] = {
15468 (char *) "self",(char *) "ftInfo", NULL
15469 };
15470
15471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15473 if (SWIG_arg_fail(1)) SWIG_fail;
15474 {
15475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15476 if (SWIG_arg_fail(2)) SWIG_fail;
15477 if (arg2 == NULL) {
15478 SWIG_null_ref("wxFileTypeInfo");
15479 }
15480 if (SWIG_arg_fail(2)) SWIG_fail;
15481 }
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15485
15486 wxPyEndAllowThreads(__tstate);
15487 if (PyErr_Occurred()) SWIG_fail;
15488 }
15489 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15490 return resultobj;
15491 fail:
15492 return NULL;
15493 }
15494
15495
15496 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15497 PyObject *resultobj;
15498 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15499 wxFileType *arg2 = (wxFileType *) 0 ;
15500 bool result;
15501 PyObject * obj0 = 0 ;
15502 PyObject * obj1 = 0 ;
15503 char *kwnames[] = {
15504 (char *) "self",(char *) "ft", NULL
15505 };
15506
15507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15509 if (SWIG_arg_fail(1)) SWIG_fail;
15510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15511 if (SWIG_arg_fail(2)) SWIG_fail;
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 result = (bool)(arg1)->Unassociate(arg2);
15515
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 {
15520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15521 }
15522 return resultobj;
15523 fail:
15524 return NULL;
15525 }
15526
15527
15528 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15529 PyObject *resultobj;
15530 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15531 PyObject * obj0 = 0 ;
15532 char *kwnames[] = {
15533 (char *) "self", NULL
15534 };
15535
15536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15538 if (SWIG_arg_fail(1)) SWIG_fail;
15539 {
15540 PyThreadState* __tstate = wxPyBeginAllowThreads();
15541 delete arg1;
15542
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 Py_INCREF(Py_None); resultobj = Py_None;
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15554 PyObject *obj;
15555 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15556 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15557 Py_INCREF(obj);
15558 return Py_BuildValue((char *)"");
15559 }
15560 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15561 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15562 return 1;
15563 }
15564
15565
15566 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15567 PyObject *pyobj;
15568
15569 {
15570 #if wxUSE_UNICODE
15571 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15572 #else
15573 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15574 #endif
15575 }
15576 return pyobj;
15577 }
15578
15579
15580 static int _wrap_ART_MENU_set(PyObject *) {
15581 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15582 return 1;
15583 }
15584
15585
15586 static PyObject *_wrap_ART_MENU_get(void) {
15587 PyObject *pyobj;
15588
15589 {
15590 #if wxUSE_UNICODE
15591 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15592 #else
15593 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15594 #endif
15595 }
15596 return pyobj;
15597 }
15598
15599
15600 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15601 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15602 return 1;
15603 }
15604
15605
15606 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15607 PyObject *pyobj;
15608
15609 {
15610 #if wxUSE_UNICODE
15611 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15612 #else
15613 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15614 #endif
15615 }
15616 return pyobj;
15617 }
15618
15619
15620 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15621 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15622 return 1;
15623 }
15624
15625
15626 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15627 PyObject *pyobj;
15628
15629 {
15630 #if wxUSE_UNICODE
15631 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15632 #else
15633 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15634 #endif
15635 }
15636 return pyobj;
15637 }
15638
15639
15640 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15641 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15642 return 1;
15643 }
15644
15645
15646 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15647 PyObject *pyobj;
15648
15649 {
15650 #if wxUSE_UNICODE
15651 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15652 #else
15653 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15654 #endif
15655 }
15656 return pyobj;
15657 }
15658
15659
15660 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15661 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15662 return 1;
15663 }
15664
15665
15666 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15667 PyObject *pyobj;
15668
15669 {
15670 #if wxUSE_UNICODE
15671 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15672 #else
15673 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15674 #endif
15675 }
15676 return pyobj;
15677 }
15678
15679
15680 static int _wrap_ART_BUTTON_set(PyObject *) {
15681 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15682 return 1;
15683 }
15684
15685
15686 static PyObject *_wrap_ART_BUTTON_get(void) {
15687 PyObject *pyobj;
15688
15689 {
15690 #if wxUSE_UNICODE
15691 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15692 #else
15693 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15694 #endif
15695 }
15696 return pyobj;
15697 }
15698
15699
15700 static int _wrap_ART_OTHER_set(PyObject *) {
15701 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15702 return 1;
15703 }
15704
15705
15706 static PyObject *_wrap_ART_OTHER_get(void) {
15707 PyObject *pyobj;
15708
15709 {
15710 #if wxUSE_UNICODE
15711 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15712 #else
15713 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15714 #endif
15715 }
15716 return pyobj;
15717 }
15718
15719
15720 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15721 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15722 return 1;
15723 }
15724
15725
15726 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15727 PyObject *pyobj;
15728
15729 {
15730 #if wxUSE_UNICODE
15731 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15732 #else
15733 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15734 #endif
15735 }
15736 return pyobj;
15737 }
15738
15739
15740 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15741 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15742 return 1;
15743 }
15744
15745
15746 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15747 PyObject *pyobj;
15748
15749 {
15750 #if wxUSE_UNICODE
15751 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15752 #else
15753 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15754 #endif
15755 }
15756 return pyobj;
15757 }
15758
15759
15760 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15761 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15762 return 1;
15763 }
15764
15765
15766 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15767 PyObject *pyobj;
15768
15769 {
15770 #if wxUSE_UNICODE
15771 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15772 #else
15773 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15774 #endif
15775 }
15776 return pyobj;
15777 }
15778
15779
15780 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15781 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15782 return 1;
15783 }
15784
15785
15786 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15787 PyObject *pyobj;
15788
15789 {
15790 #if wxUSE_UNICODE
15791 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15792 #else
15793 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15794 #endif
15795 }
15796 return pyobj;
15797 }
15798
15799
15800 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15801 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15802 return 1;
15803 }
15804
15805
15806 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15807 PyObject *pyobj;
15808
15809 {
15810 #if wxUSE_UNICODE
15811 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15812 #else
15813 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15814 #endif
15815 }
15816 return pyobj;
15817 }
15818
15819
15820 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15821 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15822 return 1;
15823 }
15824
15825
15826 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15827 PyObject *pyobj;
15828
15829 {
15830 #if wxUSE_UNICODE
15831 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15832 #else
15833 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15834 #endif
15835 }
15836 return pyobj;
15837 }
15838
15839
15840 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15841 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15842 return 1;
15843 }
15844
15845
15846 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15847 PyObject *pyobj;
15848
15849 {
15850 #if wxUSE_UNICODE
15851 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15852 #else
15853 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15854 #endif
15855 }
15856 return pyobj;
15857 }
15858
15859
15860 static int _wrap_ART_GO_BACK_set(PyObject *) {
15861 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15862 return 1;
15863 }
15864
15865
15866 static PyObject *_wrap_ART_GO_BACK_get(void) {
15867 PyObject *pyobj;
15868
15869 {
15870 #if wxUSE_UNICODE
15871 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15872 #else
15873 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15874 #endif
15875 }
15876 return pyobj;
15877 }
15878
15879
15880 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15881 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15882 return 1;
15883 }
15884
15885
15886 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15887 PyObject *pyobj;
15888
15889 {
15890 #if wxUSE_UNICODE
15891 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15892 #else
15893 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15894 #endif
15895 }
15896 return pyobj;
15897 }
15898
15899
15900 static int _wrap_ART_GO_UP_set(PyObject *) {
15901 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15902 return 1;
15903 }
15904
15905
15906 static PyObject *_wrap_ART_GO_UP_get(void) {
15907 PyObject *pyobj;
15908
15909 {
15910 #if wxUSE_UNICODE
15911 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15912 #else
15913 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15914 #endif
15915 }
15916 return pyobj;
15917 }
15918
15919
15920 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15921 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15922 return 1;
15923 }
15924
15925
15926 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15927 PyObject *pyobj;
15928
15929 {
15930 #if wxUSE_UNICODE
15931 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15932 #else
15933 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15934 #endif
15935 }
15936 return pyobj;
15937 }
15938
15939
15940 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15941 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15942 return 1;
15943 }
15944
15945
15946 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15947 PyObject *pyobj;
15948
15949 {
15950 #if wxUSE_UNICODE
15951 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15952 #else
15953 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15954 #endif
15955 }
15956 return pyobj;
15957 }
15958
15959
15960 static int _wrap_ART_GO_HOME_set(PyObject *) {
15961 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15962 return 1;
15963 }
15964
15965
15966 static PyObject *_wrap_ART_GO_HOME_get(void) {
15967 PyObject *pyobj;
15968
15969 {
15970 #if wxUSE_UNICODE
15971 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15972 #else
15973 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15974 #endif
15975 }
15976 return pyobj;
15977 }
15978
15979
15980 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15981 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15982 return 1;
15983 }
15984
15985
15986 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15987 PyObject *pyobj;
15988
15989 {
15990 #if wxUSE_UNICODE
15991 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15992 #else
15993 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15994 #endif
15995 }
15996 return pyobj;
15997 }
15998
15999
16000 static int _wrap_ART_PRINT_set(PyObject *) {
16001 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
16002 return 1;
16003 }
16004
16005
16006 static PyObject *_wrap_ART_PRINT_get(void) {
16007 PyObject *pyobj;
16008
16009 {
16010 #if wxUSE_UNICODE
16011 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16012 #else
16013 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16014 #endif
16015 }
16016 return pyobj;
16017 }
16018
16019
16020 static int _wrap_ART_HELP_set(PyObject *) {
16021 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
16022 return 1;
16023 }
16024
16025
16026 static PyObject *_wrap_ART_HELP_get(void) {
16027 PyObject *pyobj;
16028
16029 {
16030 #if wxUSE_UNICODE
16031 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16032 #else
16033 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16034 #endif
16035 }
16036 return pyobj;
16037 }
16038
16039
16040 static int _wrap_ART_TIP_set(PyObject *) {
16041 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16042 return 1;
16043 }
16044
16045
16046 static PyObject *_wrap_ART_TIP_get(void) {
16047 PyObject *pyobj;
16048
16049 {
16050 #if wxUSE_UNICODE
16051 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16052 #else
16053 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16054 #endif
16055 }
16056 return pyobj;
16057 }
16058
16059
16060 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16061 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16062 return 1;
16063 }
16064
16065
16066 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16067 PyObject *pyobj;
16068
16069 {
16070 #if wxUSE_UNICODE
16071 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16072 #else
16073 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16074 #endif
16075 }
16076 return pyobj;
16077 }
16078
16079
16080 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16081 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16082 return 1;
16083 }
16084
16085
16086 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16087 PyObject *pyobj;
16088
16089 {
16090 #if wxUSE_UNICODE
16091 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16092 #else
16093 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16094 #endif
16095 }
16096 return pyobj;
16097 }
16098
16099
16100 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16101 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16102 return 1;
16103 }
16104
16105
16106 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16107 PyObject *pyobj;
16108
16109 {
16110 #if wxUSE_UNICODE
16111 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16112 #else
16113 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16114 #endif
16115 }
16116 return pyobj;
16117 }
16118
16119
16120 static int _wrap_ART_HARDDISK_set(PyObject *) {
16121 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16122 return 1;
16123 }
16124
16125
16126 static PyObject *_wrap_ART_HARDDISK_get(void) {
16127 PyObject *pyobj;
16128
16129 {
16130 #if wxUSE_UNICODE
16131 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16132 #else
16133 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16134 #endif
16135 }
16136 return pyobj;
16137 }
16138
16139
16140 static int _wrap_ART_FLOPPY_set(PyObject *) {
16141 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16142 return 1;
16143 }
16144
16145
16146 static PyObject *_wrap_ART_FLOPPY_get(void) {
16147 PyObject *pyobj;
16148
16149 {
16150 #if wxUSE_UNICODE
16151 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16152 #else
16153 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16154 #endif
16155 }
16156 return pyobj;
16157 }
16158
16159
16160 static int _wrap_ART_CDROM_set(PyObject *) {
16161 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16162 return 1;
16163 }
16164
16165
16166 static PyObject *_wrap_ART_CDROM_get(void) {
16167 PyObject *pyobj;
16168
16169 {
16170 #if wxUSE_UNICODE
16171 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16172 #else
16173 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16174 #endif
16175 }
16176 return pyobj;
16177 }
16178
16179
16180 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16181 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16182 return 1;
16183 }
16184
16185
16186 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16187 PyObject *pyobj;
16188
16189 {
16190 #if wxUSE_UNICODE
16191 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16192 #else
16193 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16194 #endif
16195 }
16196 return pyobj;
16197 }
16198
16199
16200 static int _wrap_ART_FOLDER_set(PyObject *) {
16201 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16202 return 1;
16203 }
16204
16205
16206 static PyObject *_wrap_ART_FOLDER_get(void) {
16207 PyObject *pyobj;
16208
16209 {
16210 #if wxUSE_UNICODE
16211 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16212 #else
16213 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16214 #endif
16215 }
16216 return pyobj;
16217 }
16218
16219
16220 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16221 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16222 return 1;
16223 }
16224
16225
16226 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16227 PyObject *pyobj;
16228
16229 {
16230 #if wxUSE_UNICODE
16231 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16232 #else
16233 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16234 #endif
16235 }
16236 return pyobj;
16237 }
16238
16239
16240 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16241 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16242 return 1;
16243 }
16244
16245
16246 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16247 PyObject *pyobj;
16248
16249 {
16250 #if wxUSE_UNICODE
16251 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16252 #else
16253 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16254 #endif
16255 }
16256 return pyobj;
16257 }
16258
16259
16260 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16261 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16262 return 1;
16263 }
16264
16265
16266 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16267 PyObject *pyobj;
16268
16269 {
16270 #if wxUSE_UNICODE
16271 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16272 #else
16273 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16274 #endif
16275 }
16276 return pyobj;
16277 }
16278
16279
16280 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16281 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16282 return 1;
16283 }
16284
16285
16286 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16287 PyObject *pyobj;
16288
16289 {
16290 #if wxUSE_UNICODE
16291 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16292 #else
16293 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16294 #endif
16295 }
16296 return pyobj;
16297 }
16298
16299
16300 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16301 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16302 return 1;
16303 }
16304
16305
16306 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16307 PyObject *pyobj;
16308
16309 {
16310 #if wxUSE_UNICODE
16311 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16312 #else
16313 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16314 #endif
16315 }
16316 return pyobj;
16317 }
16318
16319
16320 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16321 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16322 return 1;
16323 }
16324
16325
16326 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16327 PyObject *pyobj;
16328
16329 {
16330 #if wxUSE_UNICODE
16331 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16332 #else
16333 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16334 #endif
16335 }
16336 return pyobj;
16337 }
16338
16339
16340 static int _wrap_ART_ERROR_set(PyObject *) {
16341 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16342 return 1;
16343 }
16344
16345
16346 static PyObject *_wrap_ART_ERROR_get(void) {
16347 PyObject *pyobj;
16348
16349 {
16350 #if wxUSE_UNICODE
16351 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16352 #else
16353 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16354 #endif
16355 }
16356 return pyobj;
16357 }
16358
16359
16360 static int _wrap_ART_QUESTION_set(PyObject *) {
16361 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16362 return 1;
16363 }
16364
16365
16366 static PyObject *_wrap_ART_QUESTION_get(void) {
16367 PyObject *pyobj;
16368
16369 {
16370 #if wxUSE_UNICODE
16371 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16372 #else
16373 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16374 #endif
16375 }
16376 return pyobj;
16377 }
16378
16379
16380 static int _wrap_ART_WARNING_set(PyObject *) {
16381 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16382 return 1;
16383 }
16384
16385
16386 static PyObject *_wrap_ART_WARNING_get(void) {
16387 PyObject *pyobj;
16388
16389 {
16390 #if wxUSE_UNICODE
16391 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16392 #else
16393 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16394 #endif
16395 }
16396 return pyobj;
16397 }
16398
16399
16400 static int _wrap_ART_INFORMATION_set(PyObject *) {
16401 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16402 return 1;
16403 }
16404
16405
16406 static PyObject *_wrap_ART_INFORMATION_get(void) {
16407 PyObject *pyobj;
16408
16409 {
16410 #if wxUSE_UNICODE
16411 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16412 #else
16413 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16414 #endif
16415 }
16416 return pyobj;
16417 }
16418
16419
16420 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16421 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16422 return 1;
16423 }
16424
16425
16426 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16427 PyObject *pyobj;
16428
16429 {
16430 #if wxUSE_UNICODE
16431 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16432 #else
16433 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16434 #endif
16435 }
16436 return pyobj;
16437 }
16438
16439
16440 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16441 PyObject *resultobj;
16442 wxPyArtProvider *result;
16443 char *kwnames[] = {
16444 NULL
16445 };
16446
16447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16448 {
16449 if (!wxPyCheckForApp()) SWIG_fail;
16450 PyThreadState* __tstate = wxPyBeginAllowThreads();
16451 result = (wxPyArtProvider *)new wxPyArtProvider();
16452
16453 wxPyEndAllowThreads(__tstate);
16454 if (PyErr_Occurred()) SWIG_fail;
16455 }
16456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16457 return resultobj;
16458 fail:
16459 return NULL;
16460 }
16461
16462
16463 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16464 PyObject *resultobj;
16465 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16466 PyObject *arg2 = (PyObject *) 0 ;
16467 PyObject *arg3 = (PyObject *) 0 ;
16468 PyObject * obj0 = 0 ;
16469 PyObject * obj1 = 0 ;
16470 PyObject * obj2 = 0 ;
16471 char *kwnames[] = {
16472 (char *) "self",(char *) "self",(char *) "_class", NULL
16473 };
16474
16475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16477 if (SWIG_arg_fail(1)) SWIG_fail;
16478 arg2 = obj1;
16479 arg3 = obj2;
16480 {
16481 PyThreadState* __tstate = wxPyBeginAllowThreads();
16482 (arg1)->_setCallbackInfo(arg2,arg3);
16483
16484 wxPyEndAllowThreads(__tstate);
16485 if (PyErr_Occurred()) SWIG_fail;
16486 }
16487 Py_INCREF(Py_None); resultobj = Py_None;
16488 return resultobj;
16489 fail:
16490 return NULL;
16491 }
16492
16493
16494 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16495 PyObject *resultobj;
16496 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16497 PyObject * obj0 = 0 ;
16498 char *kwnames[] = {
16499 (char *) "provider", NULL
16500 };
16501
16502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16504 if (SWIG_arg_fail(1)) SWIG_fail;
16505 {
16506 PyThreadState* __tstate = wxPyBeginAllowThreads();
16507 wxPyArtProvider::PushProvider(arg1);
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_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj;
16521 bool result;
16522 char *kwnames[] = {
16523 NULL
16524 };
16525
16526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16527 {
16528 PyThreadState* __tstate = wxPyBeginAllowThreads();
16529 result = (bool)wxPyArtProvider::PopProvider();
16530
16531 wxPyEndAllowThreads(__tstate);
16532 if (PyErr_Occurred()) SWIG_fail;
16533 }
16534 {
16535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16536 }
16537 return resultobj;
16538 fail:
16539 return NULL;
16540 }
16541
16542
16543 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16544 PyObject *resultobj;
16545 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16546 bool result;
16547 PyObject * obj0 = 0 ;
16548 char *kwnames[] = {
16549 (char *) "provider", NULL
16550 };
16551
16552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16554 if (SWIG_arg_fail(1)) SWIG_fail;
16555 {
16556 PyThreadState* __tstate = wxPyBeginAllowThreads();
16557 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16558
16559 wxPyEndAllowThreads(__tstate);
16560 if (PyErr_Occurred()) SWIG_fail;
16561 }
16562 {
16563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16564 }
16565 return resultobj;
16566 fail:
16567 return NULL;
16568 }
16569
16570
16571 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16572 PyObject *resultobj;
16573 wxString *arg1 = 0 ;
16574 wxString const &arg2_defvalue = wxPyART_OTHER ;
16575 wxString *arg2 = (wxString *) &arg2_defvalue ;
16576 wxSize const &arg3_defvalue = wxDefaultSize ;
16577 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16578 wxBitmap result;
16579 bool temp1 = false ;
16580 bool temp2 = false ;
16581 wxSize temp3 ;
16582 PyObject * obj0 = 0 ;
16583 PyObject * obj1 = 0 ;
16584 PyObject * obj2 = 0 ;
16585 char *kwnames[] = {
16586 (char *) "id",(char *) "client",(char *) "size", NULL
16587 };
16588
16589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16590 {
16591 arg1 = wxString_in_helper(obj0);
16592 if (arg1 == NULL) SWIG_fail;
16593 temp1 = true;
16594 }
16595 if (obj1) {
16596 {
16597 arg2 = wxString_in_helper(obj1);
16598 if (arg2 == NULL) SWIG_fail;
16599 temp2 = true;
16600 }
16601 }
16602 if (obj2) {
16603 {
16604 arg3 = &temp3;
16605 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16606 }
16607 }
16608 {
16609 if (!wxPyCheckForApp()) SWIG_fail;
16610 PyThreadState* __tstate = wxPyBeginAllowThreads();
16611 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16612
16613 wxPyEndAllowThreads(__tstate);
16614 if (PyErr_Occurred()) SWIG_fail;
16615 }
16616 {
16617 wxBitmap * resultptr;
16618 resultptr = new wxBitmap((wxBitmap &)(result));
16619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16620 }
16621 {
16622 if (temp1)
16623 delete arg1;
16624 }
16625 {
16626 if (temp2)
16627 delete arg2;
16628 }
16629 return resultobj;
16630 fail:
16631 {
16632 if (temp1)
16633 delete arg1;
16634 }
16635 {
16636 if (temp2)
16637 delete arg2;
16638 }
16639 return NULL;
16640 }
16641
16642
16643 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16644 PyObject *resultobj;
16645 wxString *arg1 = 0 ;
16646 wxString const &arg2_defvalue = wxPyART_OTHER ;
16647 wxString *arg2 = (wxString *) &arg2_defvalue ;
16648 wxSize const &arg3_defvalue = wxDefaultSize ;
16649 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16650 wxIcon result;
16651 bool temp1 = false ;
16652 bool temp2 = false ;
16653 wxSize temp3 ;
16654 PyObject * obj0 = 0 ;
16655 PyObject * obj1 = 0 ;
16656 PyObject * obj2 = 0 ;
16657 char *kwnames[] = {
16658 (char *) "id",(char *) "client",(char *) "size", NULL
16659 };
16660
16661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16662 {
16663 arg1 = wxString_in_helper(obj0);
16664 if (arg1 == NULL) SWIG_fail;
16665 temp1 = true;
16666 }
16667 if (obj1) {
16668 {
16669 arg2 = wxString_in_helper(obj1);
16670 if (arg2 == NULL) SWIG_fail;
16671 temp2 = true;
16672 }
16673 }
16674 if (obj2) {
16675 {
16676 arg3 = &temp3;
16677 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16678 }
16679 }
16680 {
16681 if (!wxPyCheckForApp()) SWIG_fail;
16682 PyThreadState* __tstate = wxPyBeginAllowThreads();
16683 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16684
16685 wxPyEndAllowThreads(__tstate);
16686 if (PyErr_Occurred()) SWIG_fail;
16687 }
16688 {
16689 wxIcon * resultptr;
16690 resultptr = new wxIcon((wxIcon &)(result));
16691 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16692 }
16693 {
16694 if (temp1)
16695 delete arg1;
16696 }
16697 {
16698 if (temp2)
16699 delete arg2;
16700 }
16701 return resultobj;
16702 fail:
16703 {
16704 if (temp1)
16705 delete arg1;
16706 }
16707 {
16708 if (temp2)
16709 delete arg2;
16710 }
16711 return NULL;
16712 }
16713
16714
16715 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16716 PyObject *resultobj;
16717 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16718 PyObject * obj0 = 0 ;
16719 char *kwnames[] = {
16720 (char *) "self", NULL
16721 };
16722
16723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16725 if (SWIG_arg_fail(1)) SWIG_fail;
16726 {
16727 PyThreadState* __tstate = wxPyBeginAllowThreads();
16728 wxPyArtProvider_Destroy(arg1);
16729
16730 wxPyEndAllowThreads(__tstate);
16731 if (PyErr_Occurred()) SWIG_fail;
16732 }
16733 Py_INCREF(Py_None); resultobj = Py_None;
16734 return resultobj;
16735 fail:
16736 return NULL;
16737 }
16738
16739
16740 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16741 PyObject *obj;
16742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16743 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16744 Py_INCREF(obj);
16745 return Py_BuildValue((char *)"");
16746 }
16747 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj;
16749 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16750 PyObject * obj0 = 0 ;
16751 char *kwnames[] = {
16752 (char *) "self", NULL
16753 };
16754
16755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16757 if (SWIG_arg_fail(1)) SWIG_fail;
16758 {
16759 PyThreadState* __tstate = wxPyBeginAllowThreads();
16760 delete arg1;
16761
16762 wxPyEndAllowThreads(__tstate);
16763 if (PyErr_Occurred()) SWIG_fail;
16764 }
16765 Py_INCREF(Py_None); resultobj = Py_None;
16766 return resultobj;
16767 fail:
16768 return NULL;
16769 }
16770
16771
16772 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16773 PyObject *resultobj;
16774 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16775 wxConfigBase *result;
16776 PyObject * obj0 = 0 ;
16777 char *kwnames[] = {
16778 (char *) "config", NULL
16779 };
16780
16781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16783 if (SWIG_arg_fail(1)) SWIG_fail;
16784 {
16785 PyThreadState* __tstate = wxPyBeginAllowThreads();
16786 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16787
16788 wxPyEndAllowThreads(__tstate);
16789 if (PyErr_Occurred()) SWIG_fail;
16790 }
16791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16792 return resultobj;
16793 fail:
16794 return NULL;
16795 }
16796
16797
16798 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16799 PyObject *resultobj;
16800 bool arg1 = (bool) true ;
16801 wxConfigBase *result;
16802 PyObject * obj0 = 0 ;
16803 char *kwnames[] = {
16804 (char *) "createOnDemand", NULL
16805 };
16806
16807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16808 if (obj0) {
16809 {
16810 arg1 = (bool)(SWIG_As_bool(obj0));
16811 if (SWIG_arg_fail(1)) SWIG_fail;
16812 }
16813 }
16814 {
16815 PyThreadState* __tstate = wxPyBeginAllowThreads();
16816 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16817
16818 wxPyEndAllowThreads(__tstate);
16819 if (PyErr_Occurred()) SWIG_fail;
16820 }
16821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16822 return resultobj;
16823 fail:
16824 return NULL;
16825 }
16826
16827
16828 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16829 PyObject *resultobj;
16830 wxConfigBase *result;
16831 char *kwnames[] = {
16832 NULL
16833 };
16834
16835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16836 {
16837 PyThreadState* __tstate = wxPyBeginAllowThreads();
16838 result = (wxConfigBase *)wxConfigBase::Create();
16839
16840 wxPyEndAllowThreads(__tstate);
16841 if (PyErr_Occurred()) SWIG_fail;
16842 }
16843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16844 return resultobj;
16845 fail:
16846 return NULL;
16847 }
16848
16849
16850 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16851 PyObject *resultobj;
16852 char *kwnames[] = {
16853 NULL
16854 };
16855
16856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16857 {
16858 PyThreadState* __tstate = wxPyBeginAllowThreads();
16859 wxConfigBase::DontCreateOnDemand();
16860
16861 wxPyEndAllowThreads(__tstate);
16862 if (PyErr_Occurred()) SWIG_fail;
16863 }
16864 Py_INCREF(Py_None); resultobj = Py_None;
16865 return resultobj;
16866 fail:
16867 return NULL;
16868 }
16869
16870
16871 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16872 PyObject *resultobj;
16873 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16874 wxString *arg2 = 0 ;
16875 bool temp2 = false ;
16876 PyObject * obj0 = 0 ;
16877 PyObject * obj1 = 0 ;
16878 char *kwnames[] = {
16879 (char *) "self",(char *) "path", NULL
16880 };
16881
16882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16884 if (SWIG_arg_fail(1)) SWIG_fail;
16885 {
16886 arg2 = wxString_in_helper(obj1);
16887 if (arg2 == NULL) SWIG_fail;
16888 temp2 = true;
16889 }
16890 {
16891 PyThreadState* __tstate = wxPyBeginAllowThreads();
16892 (arg1)->SetPath((wxString const &)*arg2);
16893
16894 wxPyEndAllowThreads(__tstate);
16895 if (PyErr_Occurred()) SWIG_fail;
16896 }
16897 Py_INCREF(Py_None); resultobj = Py_None;
16898 {
16899 if (temp2)
16900 delete arg2;
16901 }
16902 return resultobj;
16903 fail:
16904 {
16905 if (temp2)
16906 delete arg2;
16907 }
16908 return NULL;
16909 }
16910
16911
16912 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16913 PyObject *resultobj;
16914 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16915 wxString *result;
16916 PyObject * obj0 = 0 ;
16917 char *kwnames[] = {
16918 (char *) "self", NULL
16919 };
16920
16921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16923 if (SWIG_arg_fail(1)) SWIG_fail;
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 {
16927 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16928 result = (wxString *) &_result_ref;
16929 }
16930
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 {
16935 #if wxUSE_UNICODE
16936 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16937 #else
16938 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16939 #endif
16940 }
16941 return resultobj;
16942 fail:
16943 return NULL;
16944 }
16945
16946
16947 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16948 PyObject *resultobj;
16949 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16950 PyObject *result;
16951 PyObject * obj0 = 0 ;
16952 char *kwnames[] = {
16953 (char *) "self", NULL
16954 };
16955
16956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16958 if (SWIG_arg_fail(1)) SWIG_fail;
16959 {
16960 PyThreadState* __tstate = wxPyBeginAllowThreads();
16961 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16962
16963 wxPyEndAllowThreads(__tstate);
16964 if (PyErr_Occurred()) SWIG_fail;
16965 }
16966 resultobj = result;
16967 return resultobj;
16968 fail:
16969 return NULL;
16970 }
16971
16972
16973 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16974 PyObject *resultobj;
16975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16976 long arg2 ;
16977 PyObject *result;
16978 PyObject * obj0 = 0 ;
16979 PyObject * obj1 = 0 ;
16980 char *kwnames[] = {
16981 (char *) "self",(char *) "index", NULL
16982 };
16983
16984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16986 if (SWIG_arg_fail(1)) SWIG_fail;
16987 {
16988 arg2 = (long)(SWIG_As_long(obj1));
16989 if (SWIG_arg_fail(2)) SWIG_fail;
16990 }
16991 {
16992 PyThreadState* __tstate = wxPyBeginAllowThreads();
16993 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16994
16995 wxPyEndAllowThreads(__tstate);
16996 if (PyErr_Occurred()) SWIG_fail;
16997 }
16998 resultobj = result;
16999 return resultobj;
17000 fail:
17001 return NULL;
17002 }
17003
17004
17005 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17006 PyObject *resultobj;
17007 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17008 PyObject *result;
17009 PyObject * obj0 = 0 ;
17010 char *kwnames[] = {
17011 (char *) "self", NULL
17012 };
17013
17014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17016 if (SWIG_arg_fail(1)) SWIG_fail;
17017 {
17018 PyThreadState* __tstate = wxPyBeginAllowThreads();
17019 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17020
17021 wxPyEndAllowThreads(__tstate);
17022 if (PyErr_Occurred()) SWIG_fail;
17023 }
17024 resultobj = result;
17025 return resultobj;
17026 fail:
17027 return NULL;
17028 }
17029
17030
17031 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17032 PyObject *resultobj;
17033 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17034 long arg2 ;
17035 PyObject *result;
17036 PyObject * obj0 = 0 ;
17037 PyObject * obj1 = 0 ;
17038 char *kwnames[] = {
17039 (char *) "self",(char *) "index", NULL
17040 };
17041
17042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17044 if (SWIG_arg_fail(1)) SWIG_fail;
17045 {
17046 arg2 = (long)(SWIG_As_long(obj1));
17047 if (SWIG_arg_fail(2)) SWIG_fail;
17048 }
17049 {
17050 PyThreadState* __tstate = wxPyBeginAllowThreads();
17051 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17052
17053 wxPyEndAllowThreads(__tstate);
17054 if (PyErr_Occurred()) SWIG_fail;
17055 }
17056 resultobj = result;
17057 return resultobj;
17058 fail:
17059 return NULL;
17060 }
17061
17062
17063 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17064 PyObject *resultobj;
17065 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17066 bool arg2 = (bool) false ;
17067 size_t result;
17068 PyObject * obj0 = 0 ;
17069 PyObject * obj1 = 0 ;
17070 char *kwnames[] = {
17071 (char *) "self",(char *) "recursive", NULL
17072 };
17073
17074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17076 if (SWIG_arg_fail(1)) SWIG_fail;
17077 if (obj1) {
17078 {
17079 arg2 = (bool)(SWIG_As_bool(obj1));
17080 if (SWIG_arg_fail(2)) SWIG_fail;
17081 }
17082 }
17083 {
17084 PyThreadState* __tstate = wxPyBeginAllowThreads();
17085 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17086
17087 wxPyEndAllowThreads(__tstate);
17088 if (PyErr_Occurred()) SWIG_fail;
17089 }
17090 {
17091 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17092 }
17093 return resultobj;
17094 fail:
17095 return NULL;
17096 }
17097
17098
17099 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17100 PyObject *resultobj;
17101 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17102 bool arg2 = (bool) false ;
17103 size_t result;
17104 PyObject * obj0 = 0 ;
17105 PyObject * obj1 = 0 ;
17106 char *kwnames[] = {
17107 (char *) "self",(char *) "recursive", NULL
17108 };
17109
17110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17112 if (SWIG_arg_fail(1)) SWIG_fail;
17113 if (obj1) {
17114 {
17115 arg2 = (bool)(SWIG_As_bool(obj1));
17116 if (SWIG_arg_fail(2)) SWIG_fail;
17117 }
17118 }
17119 {
17120 PyThreadState* __tstate = wxPyBeginAllowThreads();
17121 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17122
17123 wxPyEndAllowThreads(__tstate);
17124 if (PyErr_Occurred()) SWIG_fail;
17125 }
17126 {
17127 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17128 }
17129 return resultobj;
17130 fail:
17131 return NULL;
17132 }
17133
17134
17135 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17136 PyObject *resultobj;
17137 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17138 wxString *arg2 = 0 ;
17139 bool result;
17140 bool temp2 = false ;
17141 PyObject * obj0 = 0 ;
17142 PyObject * obj1 = 0 ;
17143 char *kwnames[] = {
17144 (char *) "self",(char *) "name", NULL
17145 };
17146
17147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17149 if (SWIG_arg_fail(1)) SWIG_fail;
17150 {
17151 arg2 = wxString_in_helper(obj1);
17152 if (arg2 == NULL) SWIG_fail;
17153 temp2 = true;
17154 }
17155 {
17156 PyThreadState* __tstate = wxPyBeginAllowThreads();
17157 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17158
17159 wxPyEndAllowThreads(__tstate);
17160 if (PyErr_Occurred()) SWIG_fail;
17161 }
17162 {
17163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17164 }
17165 {
17166 if (temp2)
17167 delete arg2;
17168 }
17169 return resultobj;
17170 fail:
17171 {
17172 if (temp2)
17173 delete arg2;
17174 }
17175 return NULL;
17176 }
17177
17178
17179 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17180 PyObject *resultobj;
17181 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17182 wxString *arg2 = 0 ;
17183 bool result;
17184 bool temp2 = false ;
17185 PyObject * obj0 = 0 ;
17186 PyObject * obj1 = 0 ;
17187 char *kwnames[] = {
17188 (char *) "self",(char *) "name", NULL
17189 };
17190
17191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17193 if (SWIG_arg_fail(1)) SWIG_fail;
17194 {
17195 arg2 = wxString_in_helper(obj1);
17196 if (arg2 == NULL) SWIG_fail;
17197 temp2 = true;
17198 }
17199 {
17200 PyThreadState* __tstate = wxPyBeginAllowThreads();
17201 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17202
17203 wxPyEndAllowThreads(__tstate);
17204 if (PyErr_Occurred()) SWIG_fail;
17205 }
17206 {
17207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17208 }
17209 {
17210 if (temp2)
17211 delete arg2;
17212 }
17213 return resultobj;
17214 fail:
17215 {
17216 if (temp2)
17217 delete arg2;
17218 }
17219 return NULL;
17220 }
17221
17222
17223 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17224 PyObject *resultobj;
17225 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17226 wxString *arg2 = 0 ;
17227 bool result;
17228 bool temp2 = false ;
17229 PyObject * obj0 = 0 ;
17230 PyObject * obj1 = 0 ;
17231 char *kwnames[] = {
17232 (char *) "self",(char *) "name", NULL
17233 };
17234
17235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17237 if (SWIG_arg_fail(1)) SWIG_fail;
17238 {
17239 arg2 = wxString_in_helper(obj1);
17240 if (arg2 == NULL) SWIG_fail;
17241 temp2 = true;
17242 }
17243 {
17244 PyThreadState* __tstate = wxPyBeginAllowThreads();
17245 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17246
17247 wxPyEndAllowThreads(__tstate);
17248 if (PyErr_Occurred()) SWIG_fail;
17249 }
17250 {
17251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17252 }
17253 {
17254 if (temp2)
17255 delete arg2;
17256 }
17257 return resultobj;
17258 fail:
17259 {
17260 if (temp2)
17261 delete arg2;
17262 }
17263 return NULL;
17264 }
17265
17266
17267 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17268 PyObject *resultobj;
17269 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17270 wxString *arg2 = 0 ;
17271 wxConfigBase::EntryType result;
17272 bool temp2 = false ;
17273 PyObject * obj0 = 0 ;
17274 PyObject * obj1 = 0 ;
17275 char *kwnames[] = {
17276 (char *) "self",(char *) "name", NULL
17277 };
17278
17279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17281 if (SWIG_arg_fail(1)) SWIG_fail;
17282 {
17283 arg2 = wxString_in_helper(obj1);
17284 if (arg2 == NULL) SWIG_fail;
17285 temp2 = true;
17286 }
17287 {
17288 PyThreadState* __tstate = wxPyBeginAllowThreads();
17289 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17290
17291 wxPyEndAllowThreads(__tstate);
17292 if (PyErr_Occurred()) SWIG_fail;
17293 }
17294 resultobj = SWIG_From_int((result));
17295 {
17296 if (temp2)
17297 delete arg2;
17298 }
17299 return resultobj;
17300 fail:
17301 {
17302 if (temp2)
17303 delete arg2;
17304 }
17305 return NULL;
17306 }
17307
17308
17309 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj;
17311 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17312 wxString *arg2 = 0 ;
17313 wxString const &arg3_defvalue = wxPyEmptyString ;
17314 wxString *arg3 = (wxString *) &arg3_defvalue ;
17315 wxString result;
17316 bool temp2 = false ;
17317 bool temp3 = false ;
17318 PyObject * obj0 = 0 ;
17319 PyObject * obj1 = 0 ;
17320 PyObject * obj2 = 0 ;
17321 char *kwnames[] = {
17322 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17323 };
17324
17325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17327 if (SWIG_arg_fail(1)) SWIG_fail;
17328 {
17329 arg2 = wxString_in_helper(obj1);
17330 if (arg2 == NULL) SWIG_fail;
17331 temp2 = true;
17332 }
17333 if (obj2) {
17334 {
17335 arg3 = wxString_in_helper(obj2);
17336 if (arg3 == NULL) SWIG_fail;
17337 temp3 = true;
17338 }
17339 }
17340 {
17341 PyThreadState* __tstate = wxPyBeginAllowThreads();
17342 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17343
17344 wxPyEndAllowThreads(__tstate);
17345 if (PyErr_Occurred()) SWIG_fail;
17346 }
17347 {
17348 #if wxUSE_UNICODE
17349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17350 #else
17351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17352 #endif
17353 }
17354 {
17355 if (temp2)
17356 delete arg2;
17357 }
17358 {
17359 if (temp3)
17360 delete arg3;
17361 }
17362 return resultobj;
17363 fail:
17364 {
17365 if (temp2)
17366 delete arg2;
17367 }
17368 {
17369 if (temp3)
17370 delete arg3;
17371 }
17372 return NULL;
17373 }
17374
17375
17376 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17377 PyObject *resultobj;
17378 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17379 wxString *arg2 = 0 ;
17380 long arg3 = (long) 0 ;
17381 long result;
17382 bool temp2 = false ;
17383 PyObject * obj0 = 0 ;
17384 PyObject * obj1 = 0 ;
17385 PyObject * obj2 = 0 ;
17386 char *kwnames[] = {
17387 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17388 };
17389
17390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17392 if (SWIG_arg_fail(1)) SWIG_fail;
17393 {
17394 arg2 = wxString_in_helper(obj1);
17395 if (arg2 == NULL) SWIG_fail;
17396 temp2 = true;
17397 }
17398 if (obj2) {
17399 {
17400 arg3 = (long)(SWIG_As_long(obj2));
17401 if (SWIG_arg_fail(3)) SWIG_fail;
17402 }
17403 }
17404 {
17405 PyThreadState* __tstate = wxPyBeginAllowThreads();
17406 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17407
17408 wxPyEndAllowThreads(__tstate);
17409 if (PyErr_Occurred()) SWIG_fail;
17410 }
17411 {
17412 resultobj = SWIG_From_long((long)(result));
17413 }
17414 {
17415 if (temp2)
17416 delete arg2;
17417 }
17418 return resultobj;
17419 fail:
17420 {
17421 if (temp2)
17422 delete arg2;
17423 }
17424 return NULL;
17425 }
17426
17427
17428 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17429 PyObject *resultobj;
17430 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17431 wxString *arg2 = 0 ;
17432 double arg3 = (double) 0.0 ;
17433 double result;
17434 bool temp2 = false ;
17435 PyObject * obj0 = 0 ;
17436 PyObject * obj1 = 0 ;
17437 PyObject * obj2 = 0 ;
17438 char *kwnames[] = {
17439 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17440 };
17441
17442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17444 if (SWIG_arg_fail(1)) SWIG_fail;
17445 {
17446 arg2 = wxString_in_helper(obj1);
17447 if (arg2 == NULL) SWIG_fail;
17448 temp2 = true;
17449 }
17450 if (obj2) {
17451 {
17452 arg3 = (double)(SWIG_As_double(obj2));
17453 if (SWIG_arg_fail(3)) SWIG_fail;
17454 }
17455 }
17456 {
17457 PyThreadState* __tstate = wxPyBeginAllowThreads();
17458 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17459
17460 wxPyEndAllowThreads(__tstate);
17461 if (PyErr_Occurred()) SWIG_fail;
17462 }
17463 {
17464 resultobj = SWIG_From_double((double)(result));
17465 }
17466 {
17467 if (temp2)
17468 delete arg2;
17469 }
17470 return resultobj;
17471 fail:
17472 {
17473 if (temp2)
17474 delete arg2;
17475 }
17476 return NULL;
17477 }
17478
17479
17480 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17481 PyObject *resultobj;
17482 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17483 wxString *arg2 = 0 ;
17484 bool arg3 = (bool) false ;
17485 bool result;
17486 bool temp2 = false ;
17487 PyObject * obj0 = 0 ;
17488 PyObject * obj1 = 0 ;
17489 PyObject * obj2 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 arg2 = wxString_in_helper(obj1);
17499 if (arg2 == NULL) SWIG_fail;
17500 temp2 = true;
17501 }
17502 if (obj2) {
17503 {
17504 arg3 = (bool)(SWIG_As_bool(obj2));
17505 if (SWIG_arg_fail(3)) SWIG_fail;
17506 }
17507 }
17508 {
17509 PyThreadState* __tstate = wxPyBeginAllowThreads();
17510 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17511
17512 wxPyEndAllowThreads(__tstate);
17513 if (PyErr_Occurred()) SWIG_fail;
17514 }
17515 {
17516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17517 }
17518 {
17519 if (temp2)
17520 delete arg2;
17521 }
17522 return resultobj;
17523 fail:
17524 {
17525 if (temp2)
17526 delete arg2;
17527 }
17528 return NULL;
17529 }
17530
17531
17532 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17533 PyObject *resultobj;
17534 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17535 wxString *arg2 = 0 ;
17536 wxString *arg3 = 0 ;
17537 bool result;
17538 bool temp2 = false ;
17539 bool temp3 = false ;
17540 PyObject * obj0 = 0 ;
17541 PyObject * obj1 = 0 ;
17542 PyObject * obj2 = 0 ;
17543 char *kwnames[] = {
17544 (char *) "self",(char *) "key",(char *) "value", NULL
17545 };
17546
17547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17549 if (SWIG_arg_fail(1)) SWIG_fail;
17550 {
17551 arg2 = wxString_in_helper(obj1);
17552 if (arg2 == NULL) SWIG_fail;
17553 temp2 = true;
17554 }
17555 {
17556 arg3 = wxString_in_helper(obj2);
17557 if (arg3 == NULL) SWIG_fail;
17558 temp3 = true;
17559 }
17560 {
17561 PyThreadState* __tstate = wxPyBeginAllowThreads();
17562 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17563
17564 wxPyEndAllowThreads(__tstate);
17565 if (PyErr_Occurred()) SWIG_fail;
17566 }
17567 {
17568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17569 }
17570 {
17571 if (temp2)
17572 delete arg2;
17573 }
17574 {
17575 if (temp3)
17576 delete arg3;
17577 }
17578 return resultobj;
17579 fail:
17580 {
17581 if (temp2)
17582 delete arg2;
17583 }
17584 {
17585 if (temp3)
17586 delete arg3;
17587 }
17588 return NULL;
17589 }
17590
17591
17592 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17593 PyObject *resultobj;
17594 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17595 wxString *arg2 = 0 ;
17596 long arg3 ;
17597 bool result;
17598 bool temp2 = false ;
17599 PyObject * obj0 = 0 ;
17600 PyObject * obj1 = 0 ;
17601 PyObject * obj2 = 0 ;
17602 char *kwnames[] = {
17603 (char *) "self",(char *) "key",(char *) "value", NULL
17604 };
17605
17606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17608 if (SWIG_arg_fail(1)) SWIG_fail;
17609 {
17610 arg2 = wxString_in_helper(obj1);
17611 if (arg2 == NULL) SWIG_fail;
17612 temp2 = true;
17613 }
17614 {
17615 arg3 = (long)(SWIG_As_long(obj2));
17616 if (SWIG_arg_fail(3)) SWIG_fail;
17617 }
17618 {
17619 PyThreadState* __tstate = wxPyBeginAllowThreads();
17620 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17621
17622 wxPyEndAllowThreads(__tstate);
17623 if (PyErr_Occurred()) SWIG_fail;
17624 }
17625 {
17626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17627 }
17628 {
17629 if (temp2)
17630 delete arg2;
17631 }
17632 return resultobj;
17633 fail:
17634 {
17635 if (temp2)
17636 delete arg2;
17637 }
17638 return NULL;
17639 }
17640
17641
17642 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17643 PyObject *resultobj;
17644 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17645 wxString *arg2 = 0 ;
17646 double arg3 ;
17647 bool result;
17648 bool temp2 = false ;
17649 PyObject * obj0 = 0 ;
17650 PyObject * obj1 = 0 ;
17651 PyObject * obj2 = 0 ;
17652 char *kwnames[] = {
17653 (char *) "self",(char *) "key",(char *) "value", NULL
17654 };
17655
17656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17658 if (SWIG_arg_fail(1)) SWIG_fail;
17659 {
17660 arg2 = wxString_in_helper(obj1);
17661 if (arg2 == NULL) SWIG_fail;
17662 temp2 = true;
17663 }
17664 {
17665 arg3 = (double)(SWIG_As_double(obj2));
17666 if (SWIG_arg_fail(3)) SWIG_fail;
17667 }
17668 {
17669 PyThreadState* __tstate = wxPyBeginAllowThreads();
17670 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17671
17672 wxPyEndAllowThreads(__tstate);
17673 if (PyErr_Occurred()) SWIG_fail;
17674 }
17675 {
17676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17677 }
17678 {
17679 if (temp2)
17680 delete arg2;
17681 }
17682 return resultobj;
17683 fail:
17684 {
17685 if (temp2)
17686 delete arg2;
17687 }
17688 return NULL;
17689 }
17690
17691
17692 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17693 PyObject *resultobj;
17694 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17695 wxString *arg2 = 0 ;
17696 bool arg3 ;
17697 bool result;
17698 bool temp2 = false ;
17699 PyObject * obj0 = 0 ;
17700 PyObject * obj1 = 0 ;
17701 PyObject * obj2 = 0 ;
17702 char *kwnames[] = {
17703 (char *) "self",(char *) "key",(char *) "value", NULL
17704 };
17705
17706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17708 if (SWIG_arg_fail(1)) SWIG_fail;
17709 {
17710 arg2 = wxString_in_helper(obj1);
17711 if (arg2 == NULL) SWIG_fail;
17712 temp2 = true;
17713 }
17714 {
17715 arg3 = (bool)(SWIG_As_bool(obj2));
17716 if (SWIG_arg_fail(3)) SWIG_fail;
17717 }
17718 {
17719 PyThreadState* __tstate = wxPyBeginAllowThreads();
17720 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17721
17722 wxPyEndAllowThreads(__tstate);
17723 if (PyErr_Occurred()) SWIG_fail;
17724 }
17725 {
17726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17727 }
17728 {
17729 if (temp2)
17730 delete arg2;
17731 }
17732 return resultobj;
17733 fail:
17734 {
17735 if (temp2)
17736 delete arg2;
17737 }
17738 return NULL;
17739 }
17740
17741
17742 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17743 PyObject *resultobj;
17744 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17745 bool arg2 = (bool) false ;
17746 bool result;
17747 PyObject * obj0 = 0 ;
17748 PyObject * obj1 = 0 ;
17749 char *kwnames[] = {
17750 (char *) "self",(char *) "currentOnly", NULL
17751 };
17752
17753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17755 if (SWIG_arg_fail(1)) SWIG_fail;
17756 if (obj1) {
17757 {
17758 arg2 = (bool)(SWIG_As_bool(obj1));
17759 if (SWIG_arg_fail(2)) SWIG_fail;
17760 }
17761 }
17762 {
17763 PyThreadState* __tstate = wxPyBeginAllowThreads();
17764 result = (bool)(arg1)->Flush(arg2);
17765
17766 wxPyEndAllowThreads(__tstate);
17767 if (PyErr_Occurred()) SWIG_fail;
17768 }
17769 {
17770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17771 }
17772 return resultobj;
17773 fail:
17774 return NULL;
17775 }
17776
17777
17778 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17779 PyObject *resultobj;
17780 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17781 wxString *arg2 = 0 ;
17782 wxString *arg3 = 0 ;
17783 bool result;
17784 bool temp2 = false ;
17785 bool temp3 = false ;
17786 PyObject * obj0 = 0 ;
17787 PyObject * obj1 = 0 ;
17788 PyObject * obj2 = 0 ;
17789 char *kwnames[] = {
17790 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17791 };
17792
17793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17795 if (SWIG_arg_fail(1)) SWIG_fail;
17796 {
17797 arg2 = wxString_in_helper(obj1);
17798 if (arg2 == NULL) SWIG_fail;
17799 temp2 = true;
17800 }
17801 {
17802 arg3 = wxString_in_helper(obj2);
17803 if (arg3 == NULL) SWIG_fail;
17804 temp3 = true;
17805 }
17806 {
17807 PyThreadState* __tstate = wxPyBeginAllowThreads();
17808 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17809
17810 wxPyEndAllowThreads(__tstate);
17811 if (PyErr_Occurred()) SWIG_fail;
17812 }
17813 {
17814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17815 }
17816 {
17817 if (temp2)
17818 delete arg2;
17819 }
17820 {
17821 if (temp3)
17822 delete arg3;
17823 }
17824 return resultobj;
17825 fail:
17826 {
17827 if (temp2)
17828 delete arg2;
17829 }
17830 {
17831 if (temp3)
17832 delete arg3;
17833 }
17834 return NULL;
17835 }
17836
17837
17838 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17839 PyObject *resultobj;
17840 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17841 wxString *arg2 = 0 ;
17842 wxString *arg3 = 0 ;
17843 bool result;
17844 bool temp2 = false ;
17845 bool temp3 = false ;
17846 PyObject * obj0 = 0 ;
17847 PyObject * obj1 = 0 ;
17848 PyObject * obj2 = 0 ;
17849 char *kwnames[] = {
17850 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17851 };
17852
17853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17855 if (SWIG_arg_fail(1)) SWIG_fail;
17856 {
17857 arg2 = wxString_in_helper(obj1);
17858 if (arg2 == NULL) SWIG_fail;
17859 temp2 = true;
17860 }
17861 {
17862 arg3 = wxString_in_helper(obj2);
17863 if (arg3 == NULL) SWIG_fail;
17864 temp3 = true;
17865 }
17866 {
17867 PyThreadState* __tstate = wxPyBeginAllowThreads();
17868 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17869
17870 wxPyEndAllowThreads(__tstate);
17871 if (PyErr_Occurred()) SWIG_fail;
17872 }
17873 {
17874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17875 }
17876 {
17877 if (temp2)
17878 delete arg2;
17879 }
17880 {
17881 if (temp3)
17882 delete arg3;
17883 }
17884 return resultobj;
17885 fail:
17886 {
17887 if (temp2)
17888 delete arg2;
17889 }
17890 {
17891 if (temp3)
17892 delete arg3;
17893 }
17894 return NULL;
17895 }
17896
17897
17898 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17899 PyObject *resultobj;
17900 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17901 wxString *arg2 = 0 ;
17902 bool arg3 = (bool) true ;
17903 bool result;
17904 bool temp2 = false ;
17905 PyObject * obj0 = 0 ;
17906 PyObject * obj1 = 0 ;
17907 PyObject * obj2 = 0 ;
17908 char *kwnames[] = {
17909 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17910 };
17911
17912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17914 if (SWIG_arg_fail(1)) SWIG_fail;
17915 {
17916 arg2 = wxString_in_helper(obj1);
17917 if (arg2 == NULL) SWIG_fail;
17918 temp2 = true;
17919 }
17920 if (obj2) {
17921 {
17922 arg3 = (bool)(SWIG_As_bool(obj2));
17923 if (SWIG_arg_fail(3)) SWIG_fail;
17924 }
17925 }
17926 {
17927 PyThreadState* __tstate = wxPyBeginAllowThreads();
17928 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17929
17930 wxPyEndAllowThreads(__tstate);
17931 if (PyErr_Occurred()) SWIG_fail;
17932 }
17933 {
17934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17935 }
17936 {
17937 if (temp2)
17938 delete arg2;
17939 }
17940 return resultobj;
17941 fail:
17942 {
17943 if (temp2)
17944 delete arg2;
17945 }
17946 return NULL;
17947 }
17948
17949
17950 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17951 PyObject *resultobj;
17952 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17953 wxString *arg2 = 0 ;
17954 bool result;
17955 bool temp2 = false ;
17956 PyObject * obj0 = 0 ;
17957 PyObject * obj1 = 0 ;
17958 char *kwnames[] = {
17959 (char *) "self",(char *) "key", NULL
17960 };
17961
17962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17964 if (SWIG_arg_fail(1)) SWIG_fail;
17965 {
17966 arg2 = wxString_in_helper(obj1);
17967 if (arg2 == NULL) SWIG_fail;
17968 temp2 = true;
17969 }
17970 {
17971 PyThreadState* __tstate = wxPyBeginAllowThreads();
17972 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17973
17974 wxPyEndAllowThreads(__tstate);
17975 if (PyErr_Occurred()) SWIG_fail;
17976 }
17977 {
17978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17979 }
17980 {
17981 if (temp2)
17982 delete arg2;
17983 }
17984 return resultobj;
17985 fail:
17986 {
17987 if (temp2)
17988 delete arg2;
17989 }
17990 return NULL;
17991 }
17992
17993
17994 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17995 PyObject *resultobj;
17996 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17997 bool result;
17998 PyObject * obj0 = 0 ;
17999 char *kwnames[] = {
18000 (char *) "self", NULL
18001 };
18002
18003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18005 if (SWIG_arg_fail(1)) SWIG_fail;
18006 {
18007 PyThreadState* __tstate = wxPyBeginAllowThreads();
18008 result = (bool)(arg1)->DeleteAll();
18009
18010 wxPyEndAllowThreads(__tstate);
18011 if (PyErr_Occurred()) SWIG_fail;
18012 }
18013 {
18014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18015 }
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18023 PyObject *resultobj;
18024 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18025 bool arg2 = (bool) true ;
18026 PyObject * obj0 = 0 ;
18027 PyObject * obj1 = 0 ;
18028 char *kwnames[] = {
18029 (char *) "self",(char *) "doIt", NULL
18030 };
18031
18032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18034 if (SWIG_arg_fail(1)) SWIG_fail;
18035 if (obj1) {
18036 {
18037 arg2 = (bool)(SWIG_As_bool(obj1));
18038 if (SWIG_arg_fail(2)) SWIG_fail;
18039 }
18040 }
18041 {
18042 PyThreadState* __tstate = wxPyBeginAllowThreads();
18043 (arg1)->SetExpandEnvVars(arg2);
18044
18045 wxPyEndAllowThreads(__tstate);
18046 if (PyErr_Occurred()) SWIG_fail;
18047 }
18048 Py_INCREF(Py_None); resultobj = Py_None;
18049 return resultobj;
18050 fail:
18051 return NULL;
18052 }
18053
18054
18055 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18056 PyObject *resultobj;
18057 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18058 bool result;
18059 PyObject * obj0 = 0 ;
18060 char *kwnames[] = {
18061 (char *) "self", NULL
18062 };
18063
18064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18066 if (SWIG_arg_fail(1)) SWIG_fail;
18067 {
18068 PyThreadState* __tstate = wxPyBeginAllowThreads();
18069 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18070
18071 wxPyEndAllowThreads(__tstate);
18072 if (PyErr_Occurred()) SWIG_fail;
18073 }
18074 {
18075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18076 }
18077 return resultobj;
18078 fail:
18079 return NULL;
18080 }
18081
18082
18083 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18084 PyObject *resultobj;
18085 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18086 bool arg2 = (bool) true ;
18087 PyObject * obj0 = 0 ;
18088 PyObject * obj1 = 0 ;
18089 char *kwnames[] = {
18090 (char *) "self",(char *) "doIt", NULL
18091 };
18092
18093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18095 if (SWIG_arg_fail(1)) SWIG_fail;
18096 if (obj1) {
18097 {
18098 arg2 = (bool)(SWIG_As_bool(obj1));
18099 if (SWIG_arg_fail(2)) SWIG_fail;
18100 }
18101 }
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 (arg1)->SetRecordDefaults(arg2);
18105
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 Py_INCREF(Py_None); resultobj = Py_None;
18110 return resultobj;
18111 fail:
18112 return NULL;
18113 }
18114
18115
18116 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18117 PyObject *resultobj;
18118 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18119 bool result;
18120 PyObject * obj0 = 0 ;
18121 char *kwnames[] = {
18122 (char *) "self", NULL
18123 };
18124
18125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18127 if (SWIG_arg_fail(1)) SWIG_fail;
18128 {
18129 PyThreadState* __tstate = wxPyBeginAllowThreads();
18130 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18131
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 {
18136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18137 }
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18145 PyObject *resultobj;
18146 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18147 wxString *arg2 = 0 ;
18148 wxString result;
18149 bool temp2 = false ;
18150 PyObject * obj0 = 0 ;
18151 PyObject * obj1 = 0 ;
18152 char *kwnames[] = {
18153 (char *) "self",(char *) "str", NULL
18154 };
18155
18156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18158 if (SWIG_arg_fail(1)) SWIG_fail;
18159 {
18160 arg2 = wxString_in_helper(obj1);
18161 if (arg2 == NULL) SWIG_fail;
18162 temp2 = true;
18163 }
18164 {
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18167
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 {
18172 #if wxUSE_UNICODE
18173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18174 #else
18175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18176 #endif
18177 }
18178 {
18179 if (temp2)
18180 delete arg2;
18181 }
18182 return resultobj;
18183 fail:
18184 {
18185 if (temp2)
18186 delete arg2;
18187 }
18188 return NULL;
18189 }
18190
18191
18192 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18193 PyObject *resultobj;
18194 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18195 wxString result;
18196 PyObject * obj0 = 0 ;
18197 char *kwnames[] = {
18198 (char *) "self", NULL
18199 };
18200
18201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18203 if (SWIG_arg_fail(1)) SWIG_fail;
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 result = ((wxConfigBase const *)arg1)->GetAppName();
18207
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 {
18212 #if wxUSE_UNICODE
18213 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18214 #else
18215 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18216 #endif
18217 }
18218 return resultobj;
18219 fail:
18220 return NULL;
18221 }
18222
18223
18224 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18225 PyObject *resultobj;
18226 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18227 wxString result;
18228 PyObject * obj0 = 0 ;
18229 char *kwnames[] = {
18230 (char *) "self", NULL
18231 };
18232
18233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18235 if (SWIG_arg_fail(1)) SWIG_fail;
18236 {
18237 PyThreadState* __tstate = wxPyBeginAllowThreads();
18238 result = ((wxConfigBase const *)arg1)->GetVendorName();
18239
18240 wxPyEndAllowThreads(__tstate);
18241 if (PyErr_Occurred()) SWIG_fail;
18242 }
18243 {
18244 #if wxUSE_UNICODE
18245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18246 #else
18247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18248 #endif
18249 }
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18257 PyObject *resultobj;
18258 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18259 wxString *arg2 = 0 ;
18260 bool temp2 = false ;
18261 PyObject * obj0 = 0 ;
18262 PyObject * obj1 = 0 ;
18263 char *kwnames[] = {
18264 (char *) "self",(char *) "appName", NULL
18265 };
18266
18267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18269 if (SWIG_arg_fail(1)) SWIG_fail;
18270 {
18271 arg2 = wxString_in_helper(obj1);
18272 if (arg2 == NULL) SWIG_fail;
18273 temp2 = true;
18274 }
18275 {
18276 PyThreadState* __tstate = wxPyBeginAllowThreads();
18277 (arg1)->SetAppName((wxString const &)*arg2);
18278
18279 wxPyEndAllowThreads(__tstate);
18280 if (PyErr_Occurred()) SWIG_fail;
18281 }
18282 Py_INCREF(Py_None); resultobj = Py_None;
18283 {
18284 if (temp2)
18285 delete arg2;
18286 }
18287 return resultobj;
18288 fail:
18289 {
18290 if (temp2)
18291 delete arg2;
18292 }
18293 return NULL;
18294 }
18295
18296
18297 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18298 PyObject *resultobj;
18299 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18300 wxString *arg2 = 0 ;
18301 bool temp2 = false ;
18302 PyObject * obj0 = 0 ;
18303 PyObject * obj1 = 0 ;
18304 char *kwnames[] = {
18305 (char *) "self",(char *) "vendorName", NULL
18306 };
18307
18308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18310 if (SWIG_arg_fail(1)) SWIG_fail;
18311 {
18312 arg2 = wxString_in_helper(obj1);
18313 if (arg2 == NULL) SWIG_fail;
18314 temp2 = true;
18315 }
18316 {
18317 PyThreadState* __tstate = wxPyBeginAllowThreads();
18318 (arg1)->SetVendorName((wxString const &)*arg2);
18319
18320 wxPyEndAllowThreads(__tstate);
18321 if (PyErr_Occurred()) SWIG_fail;
18322 }
18323 Py_INCREF(Py_None); resultobj = Py_None;
18324 {
18325 if (temp2)
18326 delete arg2;
18327 }
18328 return resultobj;
18329 fail:
18330 {
18331 if (temp2)
18332 delete arg2;
18333 }
18334 return NULL;
18335 }
18336
18337
18338 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18339 PyObject *resultobj;
18340 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18341 long arg2 ;
18342 PyObject * obj0 = 0 ;
18343 PyObject * obj1 = 0 ;
18344 char *kwnames[] = {
18345 (char *) "self",(char *) "style", NULL
18346 };
18347
18348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18350 if (SWIG_arg_fail(1)) SWIG_fail;
18351 {
18352 arg2 = (long)(SWIG_As_long(obj1));
18353 if (SWIG_arg_fail(2)) SWIG_fail;
18354 }
18355 {
18356 PyThreadState* __tstate = wxPyBeginAllowThreads();
18357 (arg1)->SetStyle(arg2);
18358
18359 wxPyEndAllowThreads(__tstate);
18360 if (PyErr_Occurred()) SWIG_fail;
18361 }
18362 Py_INCREF(Py_None); resultobj = Py_None;
18363 return resultobj;
18364 fail:
18365 return NULL;
18366 }
18367
18368
18369 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18370 PyObject *resultobj;
18371 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18372 long result;
18373 PyObject * obj0 = 0 ;
18374 char *kwnames[] = {
18375 (char *) "self", NULL
18376 };
18377
18378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18380 if (SWIG_arg_fail(1)) SWIG_fail;
18381 {
18382 PyThreadState* __tstate = wxPyBeginAllowThreads();
18383 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18384
18385 wxPyEndAllowThreads(__tstate);
18386 if (PyErr_Occurred()) SWIG_fail;
18387 }
18388 {
18389 resultobj = SWIG_From_long((long)(result));
18390 }
18391 return resultobj;
18392 fail:
18393 return NULL;
18394 }
18395
18396
18397 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18398 PyObject *obj;
18399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18400 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18401 Py_INCREF(obj);
18402 return Py_BuildValue((char *)"");
18403 }
18404 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18405 PyObject *resultobj;
18406 wxString const &arg1_defvalue = wxPyEmptyString ;
18407 wxString *arg1 = (wxString *) &arg1_defvalue ;
18408 wxString const &arg2_defvalue = wxPyEmptyString ;
18409 wxString *arg2 = (wxString *) &arg2_defvalue ;
18410 wxString const &arg3_defvalue = wxPyEmptyString ;
18411 wxString *arg3 = (wxString *) &arg3_defvalue ;
18412 wxString const &arg4_defvalue = wxPyEmptyString ;
18413 wxString *arg4 = (wxString *) &arg4_defvalue ;
18414 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18415 wxConfig *result;
18416 bool temp1 = false ;
18417 bool temp2 = false ;
18418 bool temp3 = false ;
18419 bool temp4 = false ;
18420 PyObject * obj0 = 0 ;
18421 PyObject * obj1 = 0 ;
18422 PyObject * obj2 = 0 ;
18423 PyObject * obj3 = 0 ;
18424 PyObject * obj4 = 0 ;
18425 char *kwnames[] = {
18426 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18427 };
18428
18429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18430 if (obj0) {
18431 {
18432 arg1 = wxString_in_helper(obj0);
18433 if (arg1 == NULL) SWIG_fail;
18434 temp1 = true;
18435 }
18436 }
18437 if (obj1) {
18438 {
18439 arg2 = wxString_in_helper(obj1);
18440 if (arg2 == NULL) SWIG_fail;
18441 temp2 = true;
18442 }
18443 }
18444 if (obj2) {
18445 {
18446 arg3 = wxString_in_helper(obj2);
18447 if (arg3 == NULL) SWIG_fail;
18448 temp3 = true;
18449 }
18450 }
18451 if (obj3) {
18452 {
18453 arg4 = wxString_in_helper(obj3);
18454 if (arg4 == NULL) SWIG_fail;
18455 temp4 = true;
18456 }
18457 }
18458 if (obj4) {
18459 {
18460 arg5 = (long)(SWIG_As_long(obj4));
18461 if (SWIG_arg_fail(5)) SWIG_fail;
18462 }
18463 }
18464 {
18465 PyThreadState* __tstate = wxPyBeginAllowThreads();
18466 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18467
18468 wxPyEndAllowThreads(__tstate);
18469 if (PyErr_Occurred()) SWIG_fail;
18470 }
18471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18472 {
18473 if (temp1)
18474 delete arg1;
18475 }
18476 {
18477 if (temp2)
18478 delete arg2;
18479 }
18480 {
18481 if (temp3)
18482 delete arg3;
18483 }
18484 {
18485 if (temp4)
18486 delete arg4;
18487 }
18488 return resultobj;
18489 fail:
18490 {
18491 if (temp1)
18492 delete arg1;
18493 }
18494 {
18495 if (temp2)
18496 delete arg2;
18497 }
18498 {
18499 if (temp3)
18500 delete arg3;
18501 }
18502 {
18503 if (temp4)
18504 delete arg4;
18505 }
18506 return NULL;
18507 }
18508
18509
18510 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18511 PyObject *resultobj;
18512 wxConfig *arg1 = (wxConfig *) 0 ;
18513 PyObject * obj0 = 0 ;
18514 char *kwnames[] = {
18515 (char *) "self", NULL
18516 };
18517
18518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18520 if (SWIG_arg_fail(1)) SWIG_fail;
18521 {
18522 PyThreadState* __tstate = wxPyBeginAllowThreads();
18523 delete arg1;
18524
18525 wxPyEndAllowThreads(__tstate);
18526 if (PyErr_Occurred()) SWIG_fail;
18527 }
18528 Py_INCREF(Py_None); resultobj = Py_None;
18529 return resultobj;
18530 fail:
18531 return NULL;
18532 }
18533
18534
18535 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18536 PyObject *obj;
18537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18538 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18539 Py_INCREF(obj);
18540 return Py_BuildValue((char *)"");
18541 }
18542 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18543 PyObject *resultobj;
18544 wxString const &arg1_defvalue = wxPyEmptyString ;
18545 wxString *arg1 = (wxString *) &arg1_defvalue ;
18546 wxString const &arg2_defvalue = wxPyEmptyString ;
18547 wxString *arg2 = (wxString *) &arg2_defvalue ;
18548 wxString const &arg3_defvalue = wxPyEmptyString ;
18549 wxString *arg3 = (wxString *) &arg3_defvalue ;
18550 wxString const &arg4_defvalue = wxPyEmptyString ;
18551 wxString *arg4 = (wxString *) &arg4_defvalue ;
18552 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18553 wxFileConfig *result;
18554 bool temp1 = false ;
18555 bool temp2 = false ;
18556 bool temp3 = false ;
18557 bool temp4 = false ;
18558 PyObject * obj0 = 0 ;
18559 PyObject * obj1 = 0 ;
18560 PyObject * obj2 = 0 ;
18561 PyObject * obj3 = 0 ;
18562 PyObject * obj4 = 0 ;
18563 char *kwnames[] = {
18564 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18565 };
18566
18567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18568 if (obj0) {
18569 {
18570 arg1 = wxString_in_helper(obj0);
18571 if (arg1 == NULL) SWIG_fail;
18572 temp1 = true;
18573 }
18574 }
18575 if (obj1) {
18576 {
18577 arg2 = wxString_in_helper(obj1);
18578 if (arg2 == NULL) SWIG_fail;
18579 temp2 = true;
18580 }
18581 }
18582 if (obj2) {
18583 {
18584 arg3 = wxString_in_helper(obj2);
18585 if (arg3 == NULL) SWIG_fail;
18586 temp3 = true;
18587 }
18588 }
18589 if (obj3) {
18590 {
18591 arg4 = wxString_in_helper(obj3);
18592 if (arg4 == NULL) SWIG_fail;
18593 temp4 = true;
18594 }
18595 }
18596 if (obj4) {
18597 {
18598 arg5 = (long)(SWIG_As_long(obj4));
18599 if (SWIG_arg_fail(5)) SWIG_fail;
18600 }
18601 }
18602 {
18603 PyThreadState* __tstate = wxPyBeginAllowThreads();
18604 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18605
18606 wxPyEndAllowThreads(__tstate);
18607 if (PyErr_Occurred()) SWIG_fail;
18608 }
18609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18610 {
18611 if (temp1)
18612 delete arg1;
18613 }
18614 {
18615 if (temp2)
18616 delete arg2;
18617 }
18618 {
18619 if (temp3)
18620 delete arg3;
18621 }
18622 {
18623 if (temp4)
18624 delete arg4;
18625 }
18626 return resultobj;
18627 fail:
18628 {
18629 if (temp1)
18630 delete arg1;
18631 }
18632 {
18633 if (temp2)
18634 delete arg2;
18635 }
18636 {
18637 if (temp3)
18638 delete arg3;
18639 }
18640 {
18641 if (temp4)
18642 delete arg4;
18643 }
18644 return NULL;
18645 }
18646
18647
18648 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18649 PyObject *resultobj;
18650 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18651 PyObject * obj0 = 0 ;
18652 char *kwnames[] = {
18653 (char *) "self", NULL
18654 };
18655
18656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18658 if (SWIG_arg_fail(1)) SWIG_fail;
18659 {
18660 PyThreadState* __tstate = wxPyBeginAllowThreads();
18661 delete arg1;
18662
18663 wxPyEndAllowThreads(__tstate);
18664 if (PyErr_Occurred()) SWIG_fail;
18665 }
18666 Py_INCREF(Py_None); resultobj = Py_None;
18667 return resultobj;
18668 fail:
18669 return NULL;
18670 }
18671
18672
18673 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18674 PyObject *obj;
18675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18676 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18677 Py_INCREF(obj);
18678 return Py_BuildValue((char *)"");
18679 }
18680 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj;
18682 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18683 wxString *arg2 = 0 ;
18684 wxConfigPathChanger *result;
18685 bool temp2 = false ;
18686 PyObject * obj0 = 0 ;
18687 PyObject * obj1 = 0 ;
18688 char *kwnames[] = {
18689 (char *) "config",(char *) "entry", NULL
18690 };
18691
18692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18694 if (SWIG_arg_fail(1)) SWIG_fail;
18695 {
18696 arg2 = wxString_in_helper(obj1);
18697 if (arg2 == NULL) SWIG_fail;
18698 temp2 = true;
18699 }
18700 {
18701 PyThreadState* __tstate = wxPyBeginAllowThreads();
18702 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18703
18704 wxPyEndAllowThreads(__tstate);
18705 if (PyErr_Occurred()) SWIG_fail;
18706 }
18707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18708 {
18709 if (temp2)
18710 delete arg2;
18711 }
18712 return resultobj;
18713 fail:
18714 {
18715 if (temp2)
18716 delete arg2;
18717 }
18718 return NULL;
18719 }
18720
18721
18722 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18723 PyObject *resultobj;
18724 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18725 PyObject * obj0 = 0 ;
18726 char *kwnames[] = {
18727 (char *) "self", NULL
18728 };
18729
18730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18732 if (SWIG_arg_fail(1)) SWIG_fail;
18733 {
18734 PyThreadState* __tstate = wxPyBeginAllowThreads();
18735 delete arg1;
18736
18737 wxPyEndAllowThreads(__tstate);
18738 if (PyErr_Occurred()) SWIG_fail;
18739 }
18740 Py_INCREF(Py_None); resultobj = Py_None;
18741 return resultobj;
18742 fail:
18743 return NULL;
18744 }
18745
18746
18747 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18748 PyObject *resultobj;
18749 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18750 wxString *result;
18751 PyObject * obj0 = 0 ;
18752 char *kwnames[] = {
18753 (char *) "self", NULL
18754 };
18755
18756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18758 if (SWIG_arg_fail(1)) SWIG_fail;
18759 {
18760 PyThreadState* __tstate = wxPyBeginAllowThreads();
18761 {
18762 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18763 result = (wxString *) &_result_ref;
18764 }
18765
18766 wxPyEndAllowThreads(__tstate);
18767 if (PyErr_Occurred()) SWIG_fail;
18768 }
18769 {
18770 #if wxUSE_UNICODE
18771 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18772 #else
18773 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18774 #endif
18775 }
18776 return resultobj;
18777 fail:
18778 return NULL;
18779 }
18780
18781
18782 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18783 PyObject *obj;
18784 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18785 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18786 Py_INCREF(obj);
18787 return Py_BuildValue((char *)"");
18788 }
18789 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18790 PyObject *resultobj;
18791 wxString *arg1 = 0 ;
18792 wxString result;
18793 bool temp1 = false ;
18794 PyObject * obj0 = 0 ;
18795 char *kwnames[] = {
18796 (char *) "sz", NULL
18797 };
18798
18799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18800 {
18801 arg1 = wxString_in_helper(obj0);
18802 if (arg1 == NULL) SWIG_fail;
18803 temp1 = true;
18804 }
18805 {
18806 PyThreadState* __tstate = wxPyBeginAllowThreads();
18807 result = wxExpandEnvVars((wxString const &)*arg1);
18808
18809 wxPyEndAllowThreads(__tstate);
18810 if (PyErr_Occurred()) SWIG_fail;
18811 }
18812 {
18813 #if wxUSE_UNICODE
18814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18815 #else
18816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18817 #endif
18818 }
18819 {
18820 if (temp1)
18821 delete arg1;
18822 }
18823 return resultobj;
18824 fail:
18825 {
18826 if (temp1)
18827 delete arg1;
18828 }
18829 return NULL;
18830 }
18831
18832
18833 static int _wrap_DateFormatStr_set(PyObject *) {
18834 PyErr_SetString(PyExc_TypeError,"Variable DateFormatStr is read-only.");
18835 return 1;
18836 }
18837
18838
18839 static PyObject *_wrap_DateFormatStr_get(void) {
18840 PyObject *pyobj;
18841
18842 {
18843 #if wxUSE_UNICODE
18844 pyobj = PyUnicode_FromWideChar((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18845 #else
18846 pyobj = PyString_FromStringAndSize((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18847 #endif
18848 }
18849 return pyobj;
18850 }
18851
18852
18853 static int _wrap_TimeSpanFormatStr_set(PyObject *) {
18854 PyErr_SetString(PyExc_TypeError,"Variable TimeSpanFormatStr is read-only.");
18855 return 1;
18856 }
18857
18858
18859 static PyObject *_wrap_TimeSpanFormatStr_get(void) {
18860 PyObject *pyobj;
18861
18862 {
18863 #if wxUSE_UNICODE
18864 pyobj = PyUnicode_FromWideChar((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18865 #else
18866 pyobj = PyString_FromStringAndSize((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18867 #endif
18868 }
18869 return pyobj;
18870 }
18871
18872
18873 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18874 PyObject *resultobj;
18875 wxDateTime::Country arg1 ;
18876 PyObject * obj0 = 0 ;
18877 char *kwnames[] = {
18878 (char *) "country", NULL
18879 };
18880
18881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18882 {
18883 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18884 if (SWIG_arg_fail(1)) SWIG_fail;
18885 }
18886 {
18887 PyThreadState* __tstate = wxPyBeginAllowThreads();
18888 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18889
18890 wxPyEndAllowThreads(__tstate);
18891 if (PyErr_Occurred()) SWIG_fail;
18892 }
18893 Py_INCREF(Py_None); resultobj = Py_None;
18894 return resultobj;
18895 fail:
18896 return NULL;
18897 }
18898
18899
18900 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18901 PyObject *resultobj;
18902 wxDateTime::Country result;
18903 char *kwnames[] = {
18904 NULL
18905 };
18906
18907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18908 {
18909 PyThreadState* __tstate = wxPyBeginAllowThreads();
18910 result = (wxDateTime::Country)wxDateTime::GetCountry();
18911
18912 wxPyEndAllowThreads(__tstate);
18913 if (PyErr_Occurred()) SWIG_fail;
18914 }
18915 resultobj = SWIG_From_int((result));
18916 return resultobj;
18917 fail:
18918 return NULL;
18919 }
18920
18921
18922 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18923 PyObject *resultobj;
18924 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18925 bool result;
18926 PyObject * obj0 = 0 ;
18927 char *kwnames[] = {
18928 (char *) "country", NULL
18929 };
18930
18931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18932 if (obj0) {
18933 {
18934 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18935 if (SWIG_arg_fail(1)) SWIG_fail;
18936 }
18937 }
18938 {
18939 PyThreadState* __tstate = wxPyBeginAllowThreads();
18940 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18941
18942 wxPyEndAllowThreads(__tstate);
18943 if (PyErr_Occurred()) SWIG_fail;
18944 }
18945 {
18946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18947 }
18948 return resultobj;
18949 fail:
18950 return NULL;
18951 }
18952
18953
18954 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18955 PyObject *resultobj;
18956 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18957 int result;
18958 PyObject * obj0 = 0 ;
18959 char *kwnames[] = {
18960 (char *) "cal", NULL
18961 };
18962
18963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18964 if (obj0) {
18965 {
18966 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18967 if (SWIG_arg_fail(1)) SWIG_fail;
18968 }
18969 }
18970 {
18971 PyThreadState* __tstate = wxPyBeginAllowThreads();
18972 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18973
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 {
18978 resultobj = SWIG_From_int((int)(result));
18979 }
18980 return resultobj;
18981 fail:
18982 return NULL;
18983 }
18984
18985
18986 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18987 PyObject *resultobj;
18988 int arg1 ;
18989 int result;
18990 PyObject * obj0 = 0 ;
18991 char *kwnames[] = {
18992 (char *) "year", NULL
18993 };
18994
18995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18996 {
18997 arg1 = (int)(SWIG_As_int(obj0));
18998 if (SWIG_arg_fail(1)) SWIG_fail;
18999 }
19000 {
19001 PyThreadState* __tstate = wxPyBeginAllowThreads();
19002 result = (int)wxDateTime::ConvertYearToBC(arg1);
19003
19004 wxPyEndAllowThreads(__tstate);
19005 if (PyErr_Occurred()) SWIG_fail;
19006 }
19007 {
19008 resultobj = SWIG_From_int((int)(result));
19009 }
19010 return resultobj;
19011 fail:
19012 return NULL;
19013 }
19014
19015
19016 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19017 PyObject *resultobj;
19018 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19019 wxDateTime::Month result;
19020 PyObject * obj0 = 0 ;
19021 char *kwnames[] = {
19022 (char *) "cal", NULL
19023 };
19024
19025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19026 if (obj0) {
19027 {
19028 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19029 if (SWIG_arg_fail(1)) SWIG_fail;
19030 }
19031 }
19032 {
19033 PyThreadState* __tstate = wxPyBeginAllowThreads();
19034 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19035
19036 wxPyEndAllowThreads(__tstate);
19037 if (PyErr_Occurred()) SWIG_fail;
19038 }
19039 resultobj = SWIG_From_int((result));
19040 return resultobj;
19041 fail:
19042 return NULL;
19043 }
19044
19045
19046 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19047 PyObject *resultobj;
19048 int arg1 = (int) wxDateTime::Inv_Year ;
19049 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19050 bool result;
19051 PyObject * obj0 = 0 ;
19052 PyObject * obj1 = 0 ;
19053 char *kwnames[] = {
19054 (char *) "year",(char *) "cal", NULL
19055 };
19056
19057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19058 if (obj0) {
19059 {
19060 arg1 = (int)(SWIG_As_int(obj0));
19061 if (SWIG_arg_fail(1)) SWIG_fail;
19062 }
19063 }
19064 if (obj1) {
19065 {
19066 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19067 if (SWIG_arg_fail(2)) SWIG_fail;
19068 }
19069 }
19070 {
19071 PyThreadState* __tstate = wxPyBeginAllowThreads();
19072 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19073
19074 wxPyEndAllowThreads(__tstate);
19075 if (PyErr_Occurred()) SWIG_fail;
19076 }
19077 {
19078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19079 }
19080 return resultobj;
19081 fail:
19082 return NULL;
19083 }
19084
19085
19086 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19087 PyObject *resultobj;
19088 int arg1 = (int) wxDateTime::Inv_Year ;
19089 int result;
19090 PyObject * obj0 = 0 ;
19091 char *kwnames[] = {
19092 (char *) "year", NULL
19093 };
19094
19095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19096 if (obj0) {
19097 {
19098 arg1 = (int)(SWIG_As_int(obj0));
19099 if (SWIG_arg_fail(1)) SWIG_fail;
19100 }
19101 }
19102 {
19103 PyThreadState* __tstate = wxPyBeginAllowThreads();
19104 result = (int)wxDateTime::GetCentury(arg1);
19105
19106 wxPyEndAllowThreads(__tstate);
19107 if (PyErr_Occurred()) SWIG_fail;
19108 }
19109 {
19110 resultobj = SWIG_From_int((int)(result));
19111 }
19112 return resultobj;
19113 fail:
19114 return NULL;
19115 }
19116
19117
19118 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19119 PyObject *resultobj;
19120 int arg1 ;
19121 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19122 int result;
19123 PyObject * obj0 = 0 ;
19124 PyObject * obj1 = 0 ;
19125 char *kwnames[] = {
19126 (char *) "year",(char *) "cal", NULL
19127 };
19128
19129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19130 {
19131 arg1 = (int)(SWIG_As_int(obj0));
19132 if (SWIG_arg_fail(1)) SWIG_fail;
19133 }
19134 if (obj1) {
19135 {
19136 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19137 if (SWIG_arg_fail(2)) SWIG_fail;
19138 }
19139 }
19140 {
19141 PyThreadState* __tstate = wxPyBeginAllowThreads();
19142 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19143
19144 wxPyEndAllowThreads(__tstate);
19145 if (PyErr_Occurred()) SWIG_fail;
19146 }
19147 {
19148 resultobj = SWIG_From_int((int)(result));
19149 }
19150 return resultobj;
19151 fail:
19152 return NULL;
19153 }
19154
19155
19156 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19157 PyObject *resultobj;
19158 wxDateTime::Month arg1 ;
19159 int arg2 = (int) wxDateTime::Inv_Year ;
19160 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19161 int result;
19162 PyObject * obj0 = 0 ;
19163 PyObject * obj1 = 0 ;
19164 PyObject * obj2 = 0 ;
19165 char *kwnames[] = {
19166 (char *) "month",(char *) "year",(char *) "cal", NULL
19167 };
19168
19169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19170 {
19171 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19172 if (SWIG_arg_fail(1)) SWIG_fail;
19173 }
19174 if (obj1) {
19175 {
19176 arg2 = (int)(SWIG_As_int(obj1));
19177 if (SWIG_arg_fail(2)) SWIG_fail;
19178 }
19179 }
19180 if (obj2) {
19181 {
19182 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19183 if (SWIG_arg_fail(3)) SWIG_fail;
19184 }
19185 }
19186 {
19187 PyThreadState* __tstate = wxPyBeginAllowThreads();
19188 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19189
19190 wxPyEndAllowThreads(__tstate);
19191 if (PyErr_Occurred()) SWIG_fail;
19192 }
19193 {
19194 resultobj = SWIG_From_int((int)(result));
19195 }
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19203 PyObject *resultobj;
19204 wxDateTime::Month arg1 ;
19205 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19206 wxString result;
19207 PyObject * obj0 = 0 ;
19208 PyObject * obj1 = 0 ;
19209 char *kwnames[] = {
19210 (char *) "month",(char *) "flags", NULL
19211 };
19212
19213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19214 {
19215 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19216 if (SWIG_arg_fail(1)) SWIG_fail;
19217 }
19218 if (obj1) {
19219 {
19220 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19221 if (SWIG_arg_fail(2)) SWIG_fail;
19222 }
19223 }
19224 {
19225 PyThreadState* __tstate = wxPyBeginAllowThreads();
19226 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19227
19228 wxPyEndAllowThreads(__tstate);
19229 if (PyErr_Occurred()) SWIG_fail;
19230 }
19231 {
19232 #if wxUSE_UNICODE
19233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19234 #else
19235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19236 #endif
19237 }
19238 return resultobj;
19239 fail:
19240 return NULL;
19241 }
19242
19243
19244 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj;
19246 wxDateTime::WeekDay arg1 ;
19247 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19248 wxString result;
19249 PyObject * obj0 = 0 ;
19250 PyObject * obj1 = 0 ;
19251 char *kwnames[] = {
19252 (char *) "weekday",(char *) "flags", NULL
19253 };
19254
19255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19256 {
19257 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19258 if (SWIG_arg_fail(1)) SWIG_fail;
19259 }
19260 if (obj1) {
19261 {
19262 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19263 if (SWIG_arg_fail(2)) SWIG_fail;
19264 }
19265 }
19266 {
19267 PyThreadState* __tstate = wxPyBeginAllowThreads();
19268 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19269
19270 wxPyEndAllowThreads(__tstate);
19271 if (PyErr_Occurred()) SWIG_fail;
19272 }
19273 {
19274 #if wxUSE_UNICODE
19275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19276 #else
19277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19278 #endif
19279 }
19280 return resultobj;
19281 fail:
19282 return NULL;
19283 }
19284
19285
19286 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19287 PyObject *resultobj;
19288 wxString *arg1 = (wxString *) 0 ;
19289 wxString *arg2 = (wxString *) 0 ;
19290 bool temp1 = false ;
19291 bool temp2 = false ;
19292 PyObject * obj0 = 0 ;
19293 PyObject * obj1 = 0 ;
19294 char *kwnames[] = {
19295 (char *) "OUTPUT",(char *) "OUTPUT", NULL
19296 };
19297
19298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
19299 {
19300 arg1 = wxString_in_helper(obj0);
19301 if (arg1 == NULL) SWIG_fail;
19302 temp1 = true;
19303 }
19304 {
19305 arg2 = wxString_in_helper(obj1);
19306 if (arg2 == NULL) SWIG_fail;
19307 temp2 = true;
19308 }
19309 {
19310 PyThreadState* __tstate = wxPyBeginAllowThreads();
19311 wxDateTime::GetAmPmStrings(arg1,arg2);
19312
19313 wxPyEndAllowThreads(__tstate);
19314 if (PyErr_Occurred()) SWIG_fail;
19315 }
19316 Py_INCREF(Py_None); resultobj = Py_None;
19317 {
19318 if (temp1)
19319 delete arg1;
19320 }
19321 {
19322 if (temp2)
19323 delete arg2;
19324 }
19325 return resultobj;
19326 fail:
19327 {
19328 if (temp1)
19329 delete arg1;
19330 }
19331 {
19332 if (temp2)
19333 delete arg2;
19334 }
19335 return NULL;
19336 }
19337
19338
19339 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19340 PyObject *resultobj;
19341 int arg1 = (int) wxDateTime::Inv_Year ;
19342 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19343 bool result;
19344 PyObject * obj0 = 0 ;
19345 PyObject * obj1 = 0 ;
19346 char *kwnames[] = {
19347 (char *) "year",(char *) "country", NULL
19348 };
19349
19350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19351 if (obj0) {
19352 {
19353 arg1 = (int)(SWIG_As_int(obj0));
19354 if (SWIG_arg_fail(1)) SWIG_fail;
19355 }
19356 }
19357 if (obj1) {
19358 {
19359 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19360 if (SWIG_arg_fail(2)) SWIG_fail;
19361 }
19362 }
19363 {
19364 PyThreadState* __tstate = wxPyBeginAllowThreads();
19365 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19366
19367 wxPyEndAllowThreads(__tstate);
19368 if (PyErr_Occurred()) SWIG_fail;
19369 }
19370 {
19371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19372 }
19373 return resultobj;
19374 fail:
19375 return NULL;
19376 }
19377
19378
19379 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19380 PyObject *resultobj;
19381 int arg1 = (int) wxDateTime::Inv_Year ;
19382 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19383 wxDateTime result;
19384 PyObject * obj0 = 0 ;
19385 PyObject * obj1 = 0 ;
19386 char *kwnames[] = {
19387 (char *) "year",(char *) "country", NULL
19388 };
19389
19390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19391 if (obj0) {
19392 {
19393 arg1 = (int)(SWIG_As_int(obj0));
19394 if (SWIG_arg_fail(1)) SWIG_fail;
19395 }
19396 }
19397 if (obj1) {
19398 {
19399 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19400 if (SWIG_arg_fail(2)) SWIG_fail;
19401 }
19402 }
19403 {
19404 PyThreadState* __tstate = wxPyBeginAllowThreads();
19405 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19406
19407 wxPyEndAllowThreads(__tstate);
19408 if (PyErr_Occurred()) SWIG_fail;
19409 }
19410 {
19411 wxDateTime * resultptr;
19412 resultptr = new wxDateTime((wxDateTime &)(result));
19413 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19414 }
19415 return resultobj;
19416 fail:
19417 return NULL;
19418 }
19419
19420
19421 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19422 PyObject *resultobj;
19423 int arg1 = (int) wxDateTime::Inv_Year ;
19424 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19425 wxDateTime result;
19426 PyObject * obj0 = 0 ;
19427 PyObject * obj1 = 0 ;
19428 char *kwnames[] = {
19429 (char *) "year",(char *) "country", NULL
19430 };
19431
19432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19433 if (obj0) {
19434 {
19435 arg1 = (int)(SWIG_As_int(obj0));
19436 if (SWIG_arg_fail(1)) SWIG_fail;
19437 }
19438 }
19439 if (obj1) {
19440 {
19441 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19442 if (SWIG_arg_fail(2)) SWIG_fail;
19443 }
19444 }
19445 {
19446 PyThreadState* __tstate = wxPyBeginAllowThreads();
19447 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19448
19449 wxPyEndAllowThreads(__tstate);
19450 if (PyErr_Occurred()) SWIG_fail;
19451 }
19452 {
19453 wxDateTime * resultptr;
19454 resultptr = new wxDateTime((wxDateTime &)(result));
19455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19456 }
19457 return resultobj;
19458 fail:
19459 return NULL;
19460 }
19461
19462
19463 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19464 PyObject *resultobj;
19465 wxDateTime result;
19466 char *kwnames[] = {
19467 NULL
19468 };
19469
19470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19471 {
19472 PyThreadState* __tstate = wxPyBeginAllowThreads();
19473 result = wxDateTime::Now();
19474
19475 wxPyEndAllowThreads(__tstate);
19476 if (PyErr_Occurred()) SWIG_fail;
19477 }
19478 {
19479 wxDateTime * resultptr;
19480 resultptr = new wxDateTime((wxDateTime &)(result));
19481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19482 }
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19490 PyObject *resultobj;
19491 wxDateTime result;
19492 char *kwnames[] = {
19493 NULL
19494 };
19495
19496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19497 {
19498 PyThreadState* __tstate = wxPyBeginAllowThreads();
19499 result = wxDateTime::UNow();
19500
19501 wxPyEndAllowThreads(__tstate);
19502 if (PyErr_Occurred()) SWIG_fail;
19503 }
19504 {
19505 wxDateTime * resultptr;
19506 resultptr = new wxDateTime((wxDateTime &)(result));
19507 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19508 }
19509 return resultobj;
19510 fail:
19511 return NULL;
19512 }
19513
19514
19515 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19516 PyObject *resultobj;
19517 wxDateTime result;
19518 char *kwnames[] = {
19519 NULL
19520 };
19521
19522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19523 {
19524 PyThreadState* __tstate = wxPyBeginAllowThreads();
19525 result = wxDateTime::Today();
19526
19527 wxPyEndAllowThreads(__tstate);
19528 if (PyErr_Occurred()) SWIG_fail;
19529 }
19530 {
19531 wxDateTime * resultptr;
19532 resultptr = new wxDateTime((wxDateTime &)(result));
19533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19534 }
19535 return resultobj;
19536 fail:
19537 return NULL;
19538 }
19539
19540
19541 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19542 PyObject *resultobj;
19543 wxDateTime *result;
19544 char *kwnames[] = {
19545 NULL
19546 };
19547
19548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19549 {
19550 PyThreadState* __tstate = wxPyBeginAllowThreads();
19551 result = (wxDateTime *)new wxDateTime();
19552
19553 wxPyEndAllowThreads(__tstate);
19554 if (PyErr_Occurred()) SWIG_fail;
19555 }
19556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19557 return resultobj;
19558 fail:
19559 return NULL;
19560 }
19561
19562
19563 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19564 PyObject *resultobj;
19565 time_t arg1 ;
19566 wxDateTime *result;
19567 PyObject * obj0 = 0 ;
19568 char *kwnames[] = {
19569 (char *) "timet", NULL
19570 };
19571
19572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19573 {
19574 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19575 if (SWIG_arg_fail(1)) SWIG_fail;
19576 }
19577 {
19578 PyThreadState* __tstate = wxPyBeginAllowThreads();
19579 result = (wxDateTime *)new wxDateTime(arg1);
19580
19581 wxPyEndAllowThreads(__tstate);
19582 if (PyErr_Occurred()) SWIG_fail;
19583 }
19584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19585 return resultobj;
19586 fail:
19587 return NULL;
19588 }
19589
19590
19591 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19592 PyObject *resultobj;
19593 double arg1 ;
19594 wxDateTime *result;
19595 PyObject * obj0 = 0 ;
19596 char *kwnames[] = {
19597 (char *) "jdn", NULL
19598 };
19599
19600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19601 {
19602 arg1 = (double)(SWIG_As_double(obj0));
19603 if (SWIG_arg_fail(1)) SWIG_fail;
19604 }
19605 {
19606 PyThreadState* __tstate = wxPyBeginAllowThreads();
19607 result = (wxDateTime *)new wxDateTime(arg1);
19608
19609 wxPyEndAllowThreads(__tstate);
19610 if (PyErr_Occurred()) SWIG_fail;
19611 }
19612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19613 return resultobj;
19614 fail:
19615 return NULL;
19616 }
19617
19618
19619 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19620 PyObject *resultobj;
19621 int arg1 ;
19622 int arg2 = (int) 0 ;
19623 int arg3 = (int) 0 ;
19624 int arg4 = (int) 0 ;
19625 wxDateTime *result;
19626 PyObject * obj0 = 0 ;
19627 PyObject * obj1 = 0 ;
19628 PyObject * obj2 = 0 ;
19629 PyObject * obj3 = 0 ;
19630 char *kwnames[] = {
19631 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19632 };
19633
19634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19635 {
19636 arg1 = (int)(SWIG_As_int(obj0));
19637 if (SWIG_arg_fail(1)) SWIG_fail;
19638 }
19639 if (obj1) {
19640 {
19641 arg2 = (int)(SWIG_As_int(obj1));
19642 if (SWIG_arg_fail(2)) SWIG_fail;
19643 }
19644 }
19645 if (obj2) {
19646 {
19647 arg3 = (int)(SWIG_As_int(obj2));
19648 if (SWIG_arg_fail(3)) SWIG_fail;
19649 }
19650 }
19651 if (obj3) {
19652 {
19653 arg4 = (int)(SWIG_As_int(obj3));
19654 if (SWIG_arg_fail(4)) SWIG_fail;
19655 }
19656 }
19657 {
19658 PyThreadState* __tstate = wxPyBeginAllowThreads();
19659 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19660
19661 wxPyEndAllowThreads(__tstate);
19662 if (PyErr_Occurred()) SWIG_fail;
19663 }
19664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19665 return resultobj;
19666 fail:
19667 return NULL;
19668 }
19669
19670
19671 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19672 PyObject *resultobj;
19673 int arg1 ;
19674 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19675 int arg3 = (int) wxDateTime::Inv_Year ;
19676 int arg4 = (int) 0 ;
19677 int arg5 = (int) 0 ;
19678 int arg6 = (int) 0 ;
19679 int arg7 = (int) 0 ;
19680 wxDateTime *result;
19681 PyObject * obj0 = 0 ;
19682 PyObject * obj1 = 0 ;
19683 PyObject * obj2 = 0 ;
19684 PyObject * obj3 = 0 ;
19685 PyObject * obj4 = 0 ;
19686 PyObject * obj5 = 0 ;
19687 PyObject * obj6 = 0 ;
19688 char *kwnames[] = {
19689 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19690 };
19691
19692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19693 {
19694 arg1 = (int)(SWIG_As_int(obj0));
19695 if (SWIG_arg_fail(1)) SWIG_fail;
19696 }
19697 if (obj1) {
19698 {
19699 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19700 if (SWIG_arg_fail(2)) SWIG_fail;
19701 }
19702 }
19703 if (obj2) {
19704 {
19705 arg3 = (int)(SWIG_As_int(obj2));
19706 if (SWIG_arg_fail(3)) SWIG_fail;
19707 }
19708 }
19709 if (obj3) {
19710 {
19711 arg4 = (int)(SWIG_As_int(obj3));
19712 if (SWIG_arg_fail(4)) SWIG_fail;
19713 }
19714 }
19715 if (obj4) {
19716 {
19717 arg5 = (int)(SWIG_As_int(obj4));
19718 if (SWIG_arg_fail(5)) SWIG_fail;
19719 }
19720 }
19721 if (obj5) {
19722 {
19723 arg6 = (int)(SWIG_As_int(obj5));
19724 if (SWIG_arg_fail(6)) SWIG_fail;
19725 }
19726 }
19727 if (obj6) {
19728 {
19729 arg7 = (int)(SWIG_As_int(obj6));
19730 if (SWIG_arg_fail(7)) SWIG_fail;
19731 }
19732 }
19733 {
19734 PyThreadState* __tstate = wxPyBeginAllowThreads();
19735 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19736
19737 wxPyEndAllowThreads(__tstate);
19738 if (PyErr_Occurred()) SWIG_fail;
19739 }
19740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19741 return resultobj;
19742 fail:
19743 return NULL;
19744 }
19745
19746
19747 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19748 PyObject *resultobj;
19749 wxDateTime *arg1 = (wxDateTime *) 0 ;
19750 PyObject * obj0 = 0 ;
19751 char *kwnames[] = {
19752 (char *) "self", NULL
19753 };
19754
19755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19757 if (SWIG_arg_fail(1)) SWIG_fail;
19758 {
19759 PyThreadState* __tstate = wxPyBeginAllowThreads();
19760 delete arg1;
19761
19762 wxPyEndAllowThreads(__tstate);
19763 if (PyErr_Occurred()) SWIG_fail;
19764 }
19765 Py_INCREF(Py_None); resultobj = Py_None;
19766 return resultobj;
19767 fail:
19768 return NULL;
19769 }
19770
19771
19772 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19773 PyObject *resultobj;
19774 wxDateTime *arg1 = (wxDateTime *) 0 ;
19775 wxDateTime *result;
19776 PyObject * obj0 = 0 ;
19777 char *kwnames[] = {
19778 (char *) "self", NULL
19779 };
19780
19781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19783 if (SWIG_arg_fail(1)) SWIG_fail;
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 {
19787 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19788 result = (wxDateTime *) &_result_ref;
19789 }
19790
19791 wxPyEndAllowThreads(__tstate);
19792 if (PyErr_Occurred()) SWIG_fail;
19793 }
19794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19795 return resultobj;
19796 fail:
19797 return NULL;
19798 }
19799
19800
19801 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19802 PyObject *resultobj;
19803 wxDateTime *arg1 = (wxDateTime *) 0 ;
19804 time_t arg2 ;
19805 wxDateTime *result;
19806 PyObject * obj0 = 0 ;
19807 PyObject * obj1 = 0 ;
19808 char *kwnames[] = {
19809 (char *) "self",(char *) "timet", NULL
19810 };
19811
19812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19814 if (SWIG_arg_fail(1)) SWIG_fail;
19815 {
19816 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19817 if (SWIG_arg_fail(2)) SWIG_fail;
19818 }
19819 {
19820 PyThreadState* __tstate = wxPyBeginAllowThreads();
19821 {
19822 wxDateTime &_result_ref = (arg1)->Set(arg2);
19823 result = (wxDateTime *) &_result_ref;
19824 }
19825
19826 wxPyEndAllowThreads(__tstate);
19827 if (PyErr_Occurred()) SWIG_fail;
19828 }
19829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19830 return resultobj;
19831 fail:
19832 return NULL;
19833 }
19834
19835
19836 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19837 PyObject *resultobj;
19838 wxDateTime *arg1 = (wxDateTime *) 0 ;
19839 double arg2 ;
19840 wxDateTime *result;
19841 PyObject * obj0 = 0 ;
19842 PyObject * obj1 = 0 ;
19843 char *kwnames[] = {
19844 (char *) "self",(char *) "jdn", NULL
19845 };
19846
19847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19849 if (SWIG_arg_fail(1)) SWIG_fail;
19850 {
19851 arg2 = (double)(SWIG_As_double(obj1));
19852 if (SWIG_arg_fail(2)) SWIG_fail;
19853 }
19854 {
19855 PyThreadState* __tstate = wxPyBeginAllowThreads();
19856 {
19857 wxDateTime &_result_ref = (arg1)->Set(arg2);
19858 result = (wxDateTime *) &_result_ref;
19859 }
19860
19861 wxPyEndAllowThreads(__tstate);
19862 if (PyErr_Occurred()) SWIG_fail;
19863 }
19864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19865 return resultobj;
19866 fail:
19867 return NULL;
19868 }
19869
19870
19871 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19872 PyObject *resultobj;
19873 wxDateTime *arg1 = (wxDateTime *) 0 ;
19874 int arg2 ;
19875 int arg3 = (int) 0 ;
19876 int arg4 = (int) 0 ;
19877 int arg5 = (int) 0 ;
19878 wxDateTime *result;
19879 PyObject * obj0 = 0 ;
19880 PyObject * obj1 = 0 ;
19881 PyObject * obj2 = 0 ;
19882 PyObject * obj3 = 0 ;
19883 PyObject * obj4 = 0 ;
19884 char *kwnames[] = {
19885 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19886 };
19887
19888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19890 if (SWIG_arg_fail(1)) SWIG_fail;
19891 {
19892 arg2 = (int)(SWIG_As_int(obj1));
19893 if (SWIG_arg_fail(2)) SWIG_fail;
19894 }
19895 if (obj2) {
19896 {
19897 arg3 = (int)(SWIG_As_int(obj2));
19898 if (SWIG_arg_fail(3)) SWIG_fail;
19899 }
19900 }
19901 if (obj3) {
19902 {
19903 arg4 = (int)(SWIG_As_int(obj3));
19904 if (SWIG_arg_fail(4)) SWIG_fail;
19905 }
19906 }
19907 if (obj4) {
19908 {
19909 arg5 = (int)(SWIG_As_int(obj4));
19910 if (SWIG_arg_fail(5)) SWIG_fail;
19911 }
19912 }
19913 {
19914 PyThreadState* __tstate = wxPyBeginAllowThreads();
19915 {
19916 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19917 result = (wxDateTime *) &_result_ref;
19918 }
19919
19920 wxPyEndAllowThreads(__tstate);
19921 if (PyErr_Occurred()) SWIG_fail;
19922 }
19923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19924 return resultobj;
19925 fail:
19926 return NULL;
19927 }
19928
19929
19930 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj;
19932 wxDateTime *arg1 = (wxDateTime *) 0 ;
19933 int arg2 ;
19934 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19935 int arg4 = (int) wxDateTime::Inv_Year ;
19936 int arg5 = (int) 0 ;
19937 int arg6 = (int) 0 ;
19938 int arg7 = (int) 0 ;
19939 int arg8 = (int) 0 ;
19940 wxDateTime *result;
19941 PyObject * obj0 = 0 ;
19942 PyObject * obj1 = 0 ;
19943 PyObject * obj2 = 0 ;
19944 PyObject * obj3 = 0 ;
19945 PyObject * obj4 = 0 ;
19946 PyObject * obj5 = 0 ;
19947 PyObject * obj6 = 0 ;
19948 PyObject * obj7 = 0 ;
19949 char *kwnames[] = {
19950 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19951 };
19952
19953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19955 if (SWIG_arg_fail(1)) SWIG_fail;
19956 {
19957 arg2 = (int)(SWIG_As_int(obj1));
19958 if (SWIG_arg_fail(2)) SWIG_fail;
19959 }
19960 if (obj2) {
19961 {
19962 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19963 if (SWIG_arg_fail(3)) SWIG_fail;
19964 }
19965 }
19966 if (obj3) {
19967 {
19968 arg4 = (int)(SWIG_As_int(obj3));
19969 if (SWIG_arg_fail(4)) SWIG_fail;
19970 }
19971 }
19972 if (obj4) {
19973 {
19974 arg5 = (int)(SWIG_As_int(obj4));
19975 if (SWIG_arg_fail(5)) SWIG_fail;
19976 }
19977 }
19978 if (obj5) {
19979 {
19980 arg6 = (int)(SWIG_As_int(obj5));
19981 if (SWIG_arg_fail(6)) SWIG_fail;
19982 }
19983 }
19984 if (obj6) {
19985 {
19986 arg7 = (int)(SWIG_As_int(obj6));
19987 if (SWIG_arg_fail(7)) SWIG_fail;
19988 }
19989 }
19990 if (obj7) {
19991 {
19992 arg8 = (int)(SWIG_As_int(obj7));
19993 if (SWIG_arg_fail(8)) SWIG_fail;
19994 }
19995 }
19996 {
19997 PyThreadState* __tstate = wxPyBeginAllowThreads();
19998 {
19999 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20000 result = (wxDateTime *) &_result_ref;
20001 }
20002
20003 wxPyEndAllowThreads(__tstate);
20004 if (PyErr_Occurred()) SWIG_fail;
20005 }
20006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20007 return resultobj;
20008 fail:
20009 return NULL;
20010 }
20011
20012
20013 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20014 PyObject *resultobj;
20015 wxDateTime *arg1 = (wxDateTime *) 0 ;
20016 wxDateTime *result;
20017 PyObject * obj0 = 0 ;
20018 char *kwnames[] = {
20019 (char *) "self", NULL
20020 };
20021
20022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20024 if (SWIG_arg_fail(1)) SWIG_fail;
20025 {
20026 PyThreadState* __tstate = wxPyBeginAllowThreads();
20027 {
20028 wxDateTime &_result_ref = (arg1)->ResetTime();
20029 result = (wxDateTime *) &_result_ref;
20030 }
20031
20032 wxPyEndAllowThreads(__tstate);
20033 if (PyErr_Occurred()) SWIG_fail;
20034 }
20035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20043 PyObject *resultobj;
20044 wxDateTime *arg1 = (wxDateTime *) 0 ;
20045 int arg2 ;
20046 wxDateTime *result;
20047 PyObject * obj0 = 0 ;
20048 PyObject * obj1 = 0 ;
20049 char *kwnames[] = {
20050 (char *) "self",(char *) "year", NULL
20051 };
20052
20053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20055 if (SWIG_arg_fail(1)) SWIG_fail;
20056 {
20057 arg2 = (int)(SWIG_As_int(obj1));
20058 if (SWIG_arg_fail(2)) SWIG_fail;
20059 }
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 {
20063 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20064 result = (wxDateTime *) &_result_ref;
20065 }
20066
20067 wxPyEndAllowThreads(__tstate);
20068 if (PyErr_Occurred()) SWIG_fail;
20069 }
20070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20071 return resultobj;
20072 fail:
20073 return NULL;
20074 }
20075
20076
20077 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20078 PyObject *resultobj;
20079 wxDateTime *arg1 = (wxDateTime *) 0 ;
20080 wxDateTime::Month arg2 ;
20081 wxDateTime *result;
20082 PyObject * obj0 = 0 ;
20083 PyObject * obj1 = 0 ;
20084 char *kwnames[] = {
20085 (char *) "self",(char *) "month", NULL
20086 };
20087
20088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20090 if (SWIG_arg_fail(1)) SWIG_fail;
20091 {
20092 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20093 if (SWIG_arg_fail(2)) SWIG_fail;
20094 }
20095 {
20096 PyThreadState* __tstate = wxPyBeginAllowThreads();
20097 {
20098 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20099 result = (wxDateTime *) &_result_ref;
20100 }
20101
20102 wxPyEndAllowThreads(__tstate);
20103 if (PyErr_Occurred()) SWIG_fail;
20104 }
20105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20106 return resultobj;
20107 fail:
20108 return NULL;
20109 }
20110
20111
20112 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20113 PyObject *resultobj;
20114 wxDateTime *arg1 = (wxDateTime *) 0 ;
20115 int arg2 ;
20116 wxDateTime *result;
20117 PyObject * obj0 = 0 ;
20118 PyObject * obj1 = 0 ;
20119 char *kwnames[] = {
20120 (char *) "self",(char *) "day", NULL
20121 };
20122
20123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20125 if (SWIG_arg_fail(1)) SWIG_fail;
20126 {
20127 arg2 = (int)(SWIG_As_int(obj1));
20128 if (SWIG_arg_fail(2)) SWIG_fail;
20129 }
20130 {
20131 PyThreadState* __tstate = wxPyBeginAllowThreads();
20132 {
20133 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20134 result = (wxDateTime *) &_result_ref;
20135 }
20136
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20148 PyObject *resultobj;
20149 wxDateTime *arg1 = (wxDateTime *) 0 ;
20150 int arg2 ;
20151 wxDateTime *result;
20152 PyObject * obj0 = 0 ;
20153 PyObject * obj1 = 0 ;
20154 char *kwnames[] = {
20155 (char *) "self",(char *) "hour", NULL
20156 };
20157
20158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20160 if (SWIG_arg_fail(1)) SWIG_fail;
20161 {
20162 arg2 = (int)(SWIG_As_int(obj1));
20163 if (SWIG_arg_fail(2)) SWIG_fail;
20164 }
20165 {
20166 PyThreadState* __tstate = wxPyBeginAllowThreads();
20167 {
20168 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20169 result = (wxDateTime *) &_result_ref;
20170 }
20171
20172 wxPyEndAllowThreads(__tstate);
20173 if (PyErr_Occurred()) SWIG_fail;
20174 }
20175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20183 PyObject *resultobj;
20184 wxDateTime *arg1 = (wxDateTime *) 0 ;
20185 int arg2 ;
20186 wxDateTime *result;
20187 PyObject * obj0 = 0 ;
20188 PyObject * obj1 = 0 ;
20189 char *kwnames[] = {
20190 (char *) "self",(char *) "minute", NULL
20191 };
20192
20193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20195 if (SWIG_arg_fail(1)) SWIG_fail;
20196 {
20197 arg2 = (int)(SWIG_As_int(obj1));
20198 if (SWIG_arg_fail(2)) SWIG_fail;
20199 }
20200 {
20201 PyThreadState* __tstate = wxPyBeginAllowThreads();
20202 {
20203 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20204 result = (wxDateTime *) &_result_ref;
20205 }
20206
20207 wxPyEndAllowThreads(__tstate);
20208 if (PyErr_Occurred()) SWIG_fail;
20209 }
20210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20211 return resultobj;
20212 fail:
20213 return NULL;
20214 }
20215
20216
20217 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20218 PyObject *resultobj;
20219 wxDateTime *arg1 = (wxDateTime *) 0 ;
20220 int arg2 ;
20221 wxDateTime *result;
20222 PyObject * obj0 = 0 ;
20223 PyObject * obj1 = 0 ;
20224 char *kwnames[] = {
20225 (char *) "self",(char *) "second", NULL
20226 };
20227
20228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20230 if (SWIG_arg_fail(1)) SWIG_fail;
20231 {
20232 arg2 = (int)(SWIG_As_int(obj1));
20233 if (SWIG_arg_fail(2)) SWIG_fail;
20234 }
20235 {
20236 PyThreadState* __tstate = wxPyBeginAllowThreads();
20237 {
20238 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20239 result = (wxDateTime *) &_result_ref;
20240 }
20241
20242 wxPyEndAllowThreads(__tstate);
20243 if (PyErr_Occurred()) SWIG_fail;
20244 }
20245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20246 return resultobj;
20247 fail:
20248 return NULL;
20249 }
20250
20251
20252 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20253 PyObject *resultobj;
20254 wxDateTime *arg1 = (wxDateTime *) 0 ;
20255 int arg2 ;
20256 wxDateTime *result;
20257 PyObject * obj0 = 0 ;
20258 PyObject * obj1 = 0 ;
20259 char *kwnames[] = {
20260 (char *) "self",(char *) "millisecond", NULL
20261 };
20262
20263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20265 if (SWIG_arg_fail(1)) SWIG_fail;
20266 {
20267 arg2 = (int)(SWIG_As_int(obj1));
20268 if (SWIG_arg_fail(2)) SWIG_fail;
20269 }
20270 {
20271 PyThreadState* __tstate = wxPyBeginAllowThreads();
20272 {
20273 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20274 result = (wxDateTime *) &_result_ref;
20275 }
20276
20277 wxPyEndAllowThreads(__tstate);
20278 if (PyErr_Occurred()) SWIG_fail;
20279 }
20280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20281 return resultobj;
20282 fail:
20283 return NULL;
20284 }
20285
20286
20287 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20288 PyObject *resultobj;
20289 wxDateTime *arg1 = (wxDateTime *) 0 ;
20290 wxDateTime::WeekDay arg2 ;
20291 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20292 wxDateTime *result;
20293 PyObject * obj0 = 0 ;
20294 PyObject * obj1 = 0 ;
20295 PyObject * obj2 = 0 ;
20296 char *kwnames[] = {
20297 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20298 };
20299
20300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20302 if (SWIG_arg_fail(1)) SWIG_fail;
20303 {
20304 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20305 if (SWIG_arg_fail(2)) SWIG_fail;
20306 }
20307 if (obj2) {
20308 {
20309 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20310 if (SWIG_arg_fail(3)) SWIG_fail;
20311 }
20312 }
20313 {
20314 PyThreadState* __tstate = wxPyBeginAllowThreads();
20315 {
20316 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20317 result = (wxDateTime *) &_result_ref;
20318 }
20319
20320 wxPyEndAllowThreads(__tstate);
20321 if (PyErr_Occurred()) SWIG_fail;
20322 }
20323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20324 return resultobj;
20325 fail:
20326 return NULL;
20327 }
20328
20329
20330 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20331 PyObject *resultobj;
20332 wxDateTime *arg1 = (wxDateTime *) 0 ;
20333 wxDateTime::WeekDay arg2 ;
20334 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20335 wxDateTime result;
20336 PyObject * obj0 = 0 ;
20337 PyObject * obj1 = 0 ;
20338 PyObject * obj2 = 0 ;
20339 char *kwnames[] = {
20340 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20341 };
20342
20343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20345 if (SWIG_arg_fail(1)) SWIG_fail;
20346 {
20347 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20348 if (SWIG_arg_fail(2)) SWIG_fail;
20349 }
20350 if (obj2) {
20351 {
20352 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20353 if (SWIG_arg_fail(3)) SWIG_fail;
20354 }
20355 }
20356 {
20357 PyThreadState* __tstate = wxPyBeginAllowThreads();
20358 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20359
20360 wxPyEndAllowThreads(__tstate);
20361 if (PyErr_Occurred()) SWIG_fail;
20362 }
20363 {
20364 wxDateTime * resultptr;
20365 resultptr = new wxDateTime((wxDateTime &)(result));
20366 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20367 }
20368 return resultobj;
20369 fail:
20370 return NULL;
20371 }
20372
20373
20374 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20375 PyObject *resultobj;
20376 wxDateTime *arg1 = (wxDateTime *) 0 ;
20377 wxDateTime::WeekDay arg2 ;
20378 wxDateTime *result;
20379 PyObject * obj0 = 0 ;
20380 PyObject * obj1 = 0 ;
20381 char *kwnames[] = {
20382 (char *) "self",(char *) "weekday", NULL
20383 };
20384
20385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20387 if (SWIG_arg_fail(1)) SWIG_fail;
20388 {
20389 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20390 if (SWIG_arg_fail(2)) SWIG_fail;
20391 }
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 {
20395 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20396 result = (wxDateTime *) &_result_ref;
20397 }
20398
20399 wxPyEndAllowThreads(__tstate);
20400 if (PyErr_Occurred()) SWIG_fail;
20401 }
20402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20403 return resultobj;
20404 fail:
20405 return NULL;
20406 }
20407
20408
20409 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20410 PyObject *resultobj;
20411 wxDateTime *arg1 = (wxDateTime *) 0 ;
20412 wxDateTime::WeekDay arg2 ;
20413 wxDateTime result;
20414 PyObject * obj0 = 0 ;
20415 PyObject * obj1 = 0 ;
20416 char *kwnames[] = {
20417 (char *) "self",(char *) "weekday", NULL
20418 };
20419
20420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20422 if (SWIG_arg_fail(1)) SWIG_fail;
20423 {
20424 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20425 if (SWIG_arg_fail(2)) SWIG_fail;
20426 }
20427 {
20428 PyThreadState* __tstate = wxPyBeginAllowThreads();
20429 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20430
20431 wxPyEndAllowThreads(__tstate);
20432 if (PyErr_Occurred()) SWIG_fail;
20433 }
20434 {
20435 wxDateTime * resultptr;
20436 resultptr = new wxDateTime((wxDateTime &)(result));
20437 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20438 }
20439 return resultobj;
20440 fail:
20441 return NULL;
20442 }
20443
20444
20445 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20446 PyObject *resultobj;
20447 wxDateTime *arg1 = (wxDateTime *) 0 ;
20448 wxDateTime::WeekDay arg2 ;
20449 wxDateTime *result;
20450 PyObject * obj0 = 0 ;
20451 PyObject * obj1 = 0 ;
20452 char *kwnames[] = {
20453 (char *) "self",(char *) "weekday", NULL
20454 };
20455
20456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20458 if (SWIG_arg_fail(1)) SWIG_fail;
20459 {
20460 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20461 if (SWIG_arg_fail(2)) SWIG_fail;
20462 }
20463 {
20464 PyThreadState* __tstate = wxPyBeginAllowThreads();
20465 {
20466 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20467 result = (wxDateTime *) &_result_ref;
20468 }
20469
20470 wxPyEndAllowThreads(__tstate);
20471 if (PyErr_Occurred()) SWIG_fail;
20472 }
20473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20474 return resultobj;
20475 fail:
20476 return NULL;
20477 }
20478
20479
20480 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20481 PyObject *resultobj;
20482 wxDateTime *arg1 = (wxDateTime *) 0 ;
20483 wxDateTime::WeekDay arg2 ;
20484 wxDateTime result;
20485 PyObject * obj0 = 0 ;
20486 PyObject * obj1 = 0 ;
20487 char *kwnames[] = {
20488 (char *) "self",(char *) "weekday", NULL
20489 };
20490
20491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20493 if (SWIG_arg_fail(1)) SWIG_fail;
20494 {
20495 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20496 if (SWIG_arg_fail(2)) SWIG_fail;
20497 }
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20501
20502 wxPyEndAllowThreads(__tstate);
20503 if (PyErr_Occurred()) SWIG_fail;
20504 }
20505 {
20506 wxDateTime * resultptr;
20507 resultptr = new wxDateTime((wxDateTime &)(result));
20508 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20509 }
20510 return resultobj;
20511 fail:
20512 return NULL;
20513 }
20514
20515
20516 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20517 PyObject *resultobj;
20518 wxDateTime *arg1 = (wxDateTime *) 0 ;
20519 wxDateTime::WeekDay arg2 ;
20520 int arg3 = (int) 1 ;
20521 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20522 int arg5 = (int) wxDateTime::Inv_Year ;
20523 bool result;
20524 PyObject * obj0 = 0 ;
20525 PyObject * obj1 = 0 ;
20526 PyObject * obj2 = 0 ;
20527 PyObject * obj3 = 0 ;
20528 PyObject * obj4 = 0 ;
20529 char *kwnames[] = {
20530 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20531 };
20532
20533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20535 if (SWIG_arg_fail(1)) SWIG_fail;
20536 {
20537 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20538 if (SWIG_arg_fail(2)) SWIG_fail;
20539 }
20540 if (obj2) {
20541 {
20542 arg3 = (int)(SWIG_As_int(obj2));
20543 if (SWIG_arg_fail(3)) SWIG_fail;
20544 }
20545 }
20546 if (obj3) {
20547 {
20548 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20549 if (SWIG_arg_fail(4)) SWIG_fail;
20550 }
20551 }
20552 if (obj4) {
20553 {
20554 arg5 = (int)(SWIG_As_int(obj4));
20555 if (SWIG_arg_fail(5)) SWIG_fail;
20556 }
20557 }
20558 {
20559 PyThreadState* __tstate = wxPyBeginAllowThreads();
20560 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20561
20562 wxPyEndAllowThreads(__tstate);
20563 if (PyErr_Occurred()) SWIG_fail;
20564 }
20565 {
20566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20567 }
20568 return resultobj;
20569 fail:
20570 return NULL;
20571 }
20572
20573
20574 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20575 PyObject *resultobj;
20576 wxDateTime *arg1 = (wxDateTime *) 0 ;
20577 wxDateTime::WeekDay arg2 ;
20578 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20579 int arg4 = (int) wxDateTime::Inv_Year ;
20580 bool result;
20581 PyObject * obj0 = 0 ;
20582 PyObject * obj1 = 0 ;
20583 PyObject * obj2 = 0 ;
20584 PyObject * obj3 = 0 ;
20585 char *kwnames[] = {
20586 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20587 };
20588
20589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20591 if (SWIG_arg_fail(1)) SWIG_fail;
20592 {
20593 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20594 if (SWIG_arg_fail(2)) SWIG_fail;
20595 }
20596 if (obj2) {
20597 {
20598 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20599 if (SWIG_arg_fail(3)) SWIG_fail;
20600 }
20601 }
20602 if (obj3) {
20603 {
20604 arg4 = (int)(SWIG_As_int(obj3));
20605 if (SWIG_arg_fail(4)) SWIG_fail;
20606 }
20607 }
20608 {
20609 PyThreadState* __tstate = wxPyBeginAllowThreads();
20610 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20611
20612 wxPyEndAllowThreads(__tstate);
20613 if (PyErr_Occurred()) SWIG_fail;
20614 }
20615 {
20616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20617 }
20618 return resultobj;
20619 fail:
20620 return NULL;
20621 }
20622
20623
20624 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20625 PyObject *resultobj;
20626 wxDateTime *arg1 = (wxDateTime *) 0 ;
20627 wxDateTime::WeekDay arg2 ;
20628 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20629 int arg4 = (int) wxDateTime::Inv_Year ;
20630 wxDateTime result;
20631 PyObject * obj0 = 0 ;
20632 PyObject * obj1 = 0 ;
20633 PyObject * obj2 = 0 ;
20634 PyObject * obj3 = 0 ;
20635 char *kwnames[] = {
20636 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20637 };
20638
20639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20641 if (SWIG_arg_fail(1)) SWIG_fail;
20642 {
20643 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20644 if (SWIG_arg_fail(2)) SWIG_fail;
20645 }
20646 if (obj2) {
20647 {
20648 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20649 if (SWIG_arg_fail(3)) SWIG_fail;
20650 }
20651 }
20652 if (obj3) {
20653 {
20654 arg4 = (int)(SWIG_As_int(obj3));
20655 if (SWIG_arg_fail(4)) SWIG_fail;
20656 }
20657 }
20658 {
20659 PyThreadState* __tstate = wxPyBeginAllowThreads();
20660 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20661
20662 wxPyEndAllowThreads(__tstate);
20663 if (PyErr_Occurred()) SWIG_fail;
20664 }
20665 {
20666 wxDateTime * resultptr;
20667 resultptr = new wxDateTime((wxDateTime &)(result));
20668 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20669 }
20670 return resultobj;
20671 fail:
20672 return NULL;
20673 }
20674
20675
20676 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20677 PyObject *resultobj;
20678 wxDateTime *arg1 = (wxDateTime *) 0 ;
20679 int arg2 ;
20680 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20681 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20682 bool result;
20683 PyObject * obj0 = 0 ;
20684 PyObject * obj1 = 0 ;
20685 PyObject * obj2 = 0 ;
20686 PyObject * obj3 = 0 ;
20687 char *kwnames[] = {
20688 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20689 };
20690
20691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20693 if (SWIG_arg_fail(1)) SWIG_fail;
20694 {
20695 arg2 = (int)(SWIG_As_int(obj1));
20696 if (SWIG_arg_fail(2)) SWIG_fail;
20697 }
20698 if (obj2) {
20699 {
20700 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20701 if (SWIG_arg_fail(3)) SWIG_fail;
20702 }
20703 }
20704 if (obj3) {
20705 {
20706 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20707 if (SWIG_arg_fail(4)) SWIG_fail;
20708 }
20709 }
20710 {
20711 PyThreadState* __tstate = wxPyBeginAllowThreads();
20712 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20713
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 {
20718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20719 }
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20727 PyObject *resultobj;
20728 wxDateTime *arg1 = (wxDateTime *) 0 ;
20729 int arg2 ;
20730 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20731 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20732 wxDateTime result;
20733 PyObject * obj0 = 0 ;
20734 PyObject * obj1 = 0 ;
20735 PyObject * obj2 = 0 ;
20736 PyObject * obj3 = 0 ;
20737 char *kwnames[] = {
20738 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20739 };
20740
20741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20743 if (SWIG_arg_fail(1)) SWIG_fail;
20744 {
20745 arg2 = (int)(SWIG_As_int(obj1));
20746 if (SWIG_arg_fail(2)) SWIG_fail;
20747 }
20748 if (obj2) {
20749 {
20750 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20751 if (SWIG_arg_fail(3)) SWIG_fail;
20752 }
20753 }
20754 if (obj3) {
20755 {
20756 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20757 if (SWIG_arg_fail(4)) SWIG_fail;
20758 }
20759 }
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20763
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 {
20768 wxDateTime * resultptr;
20769 resultptr = new wxDateTime((wxDateTime &)(result));
20770 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20771 }
20772 return resultobj;
20773 fail:
20774 return NULL;
20775 }
20776
20777
20778 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20779 PyObject *resultobj;
20780 int arg1 ;
20781 int arg2 ;
20782 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20783 wxDateTime result;
20784 PyObject * obj0 = 0 ;
20785 PyObject * obj1 = 0 ;
20786 PyObject * obj2 = 0 ;
20787 char *kwnames[] = {
20788 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20789 };
20790
20791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20792 {
20793 arg1 = (int)(SWIG_As_int(obj0));
20794 if (SWIG_arg_fail(1)) SWIG_fail;
20795 }
20796 {
20797 arg2 = (int)(SWIG_As_int(obj1));
20798 if (SWIG_arg_fail(2)) SWIG_fail;
20799 }
20800 if (obj2) {
20801 {
20802 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20803 if (SWIG_arg_fail(3)) SWIG_fail;
20804 }
20805 }
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20809
20810 wxPyEndAllowThreads(__tstate);
20811 if (PyErr_Occurred()) SWIG_fail;
20812 }
20813 {
20814 wxDateTime * resultptr;
20815 resultptr = new wxDateTime((wxDateTime &)(result));
20816 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20817 }
20818 return resultobj;
20819 fail:
20820 return NULL;
20821 }
20822
20823
20824 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20825 PyObject *resultobj;
20826 wxDateTime *arg1 = (wxDateTime *) 0 ;
20827 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20828 int arg3 = (int) wxDateTime::Inv_Year ;
20829 wxDateTime *result;
20830 PyObject * obj0 = 0 ;
20831 PyObject * obj1 = 0 ;
20832 PyObject * obj2 = 0 ;
20833 char *kwnames[] = {
20834 (char *) "self",(char *) "month",(char *) "year", NULL
20835 };
20836
20837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20839 if (SWIG_arg_fail(1)) SWIG_fail;
20840 if (obj1) {
20841 {
20842 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20843 if (SWIG_arg_fail(2)) SWIG_fail;
20844 }
20845 }
20846 if (obj2) {
20847 {
20848 arg3 = (int)(SWIG_As_int(obj2));
20849 if (SWIG_arg_fail(3)) SWIG_fail;
20850 }
20851 }
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 {
20855 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20856 result = (wxDateTime *) &_result_ref;
20857 }
20858
20859 wxPyEndAllowThreads(__tstate);
20860 if (PyErr_Occurred()) SWIG_fail;
20861 }
20862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20870 PyObject *resultobj;
20871 wxDateTime *arg1 = (wxDateTime *) 0 ;
20872 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20873 int arg3 = (int) wxDateTime::Inv_Year ;
20874 wxDateTime result;
20875 PyObject * obj0 = 0 ;
20876 PyObject * obj1 = 0 ;
20877 PyObject * obj2 = 0 ;
20878 char *kwnames[] = {
20879 (char *) "self",(char *) "month",(char *) "year", NULL
20880 };
20881
20882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20884 if (SWIG_arg_fail(1)) SWIG_fail;
20885 if (obj1) {
20886 {
20887 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20888 if (SWIG_arg_fail(2)) SWIG_fail;
20889 }
20890 }
20891 if (obj2) {
20892 {
20893 arg3 = (int)(SWIG_As_int(obj2));
20894 if (SWIG_arg_fail(3)) SWIG_fail;
20895 }
20896 }
20897 {
20898 PyThreadState* __tstate = wxPyBeginAllowThreads();
20899 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20900
20901 wxPyEndAllowThreads(__tstate);
20902 if (PyErr_Occurred()) SWIG_fail;
20903 }
20904 {
20905 wxDateTime * resultptr;
20906 resultptr = new wxDateTime((wxDateTime &)(result));
20907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20908 }
20909 return resultobj;
20910 fail:
20911 return NULL;
20912 }
20913
20914
20915 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20916 PyObject *resultobj;
20917 wxDateTime *arg1 = (wxDateTime *) 0 ;
20918 int arg2 ;
20919 wxDateTime *result;
20920 PyObject * obj0 = 0 ;
20921 PyObject * obj1 = 0 ;
20922 char *kwnames[] = {
20923 (char *) "self",(char *) "yday", NULL
20924 };
20925
20926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20928 if (SWIG_arg_fail(1)) SWIG_fail;
20929 {
20930 arg2 = (int)(SWIG_As_int(obj1));
20931 if (SWIG_arg_fail(2)) SWIG_fail;
20932 }
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 {
20936 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20937 result = (wxDateTime *) &_result_ref;
20938 }
20939
20940 wxPyEndAllowThreads(__tstate);
20941 if (PyErr_Occurred()) SWIG_fail;
20942 }
20943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20944 return resultobj;
20945 fail:
20946 return NULL;
20947 }
20948
20949
20950 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20951 PyObject *resultobj;
20952 wxDateTime *arg1 = (wxDateTime *) 0 ;
20953 int arg2 ;
20954 wxDateTime result;
20955 PyObject * obj0 = 0 ;
20956 PyObject * obj1 = 0 ;
20957 char *kwnames[] = {
20958 (char *) "self",(char *) "yday", NULL
20959 };
20960
20961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20963 if (SWIG_arg_fail(1)) SWIG_fail;
20964 {
20965 arg2 = (int)(SWIG_As_int(obj1));
20966 if (SWIG_arg_fail(2)) SWIG_fail;
20967 }
20968 {
20969 PyThreadState* __tstate = wxPyBeginAllowThreads();
20970 result = (arg1)->GetYearDay(arg2);
20971
20972 wxPyEndAllowThreads(__tstate);
20973 if (PyErr_Occurred()) SWIG_fail;
20974 }
20975 {
20976 wxDateTime * resultptr;
20977 resultptr = new wxDateTime((wxDateTime &)(result));
20978 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20979 }
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20987 PyObject *resultobj;
20988 wxDateTime *arg1 = (wxDateTime *) 0 ;
20989 double result;
20990 PyObject * obj0 = 0 ;
20991 char *kwnames[] = {
20992 (char *) "self", NULL
20993 };
20994
20995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20997 if (SWIG_arg_fail(1)) SWIG_fail;
20998 {
20999 PyThreadState* __tstate = wxPyBeginAllowThreads();
21000 result = (double)(arg1)->GetJulianDayNumber();
21001
21002 wxPyEndAllowThreads(__tstate);
21003 if (PyErr_Occurred()) SWIG_fail;
21004 }
21005 {
21006 resultobj = SWIG_From_double((double)(result));
21007 }
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21015 PyObject *resultobj;
21016 wxDateTime *arg1 = (wxDateTime *) 0 ;
21017 double result;
21018 PyObject * obj0 = 0 ;
21019 char *kwnames[] = {
21020 (char *) "self", NULL
21021 };
21022
21023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21025 if (SWIG_arg_fail(1)) SWIG_fail;
21026 {
21027 PyThreadState* __tstate = wxPyBeginAllowThreads();
21028 result = (double)(arg1)->GetJDN();
21029
21030 wxPyEndAllowThreads(__tstate);
21031 if (PyErr_Occurred()) SWIG_fail;
21032 }
21033 {
21034 resultobj = SWIG_From_double((double)(result));
21035 }
21036 return resultobj;
21037 fail:
21038 return NULL;
21039 }
21040
21041
21042 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21043 PyObject *resultobj;
21044 wxDateTime *arg1 = (wxDateTime *) 0 ;
21045 double result;
21046 PyObject * obj0 = 0 ;
21047 char *kwnames[] = {
21048 (char *) "self", NULL
21049 };
21050
21051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21053 if (SWIG_arg_fail(1)) SWIG_fail;
21054 {
21055 PyThreadState* __tstate = wxPyBeginAllowThreads();
21056 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21057
21058 wxPyEndAllowThreads(__tstate);
21059 if (PyErr_Occurred()) SWIG_fail;
21060 }
21061 {
21062 resultobj = SWIG_From_double((double)(result));
21063 }
21064 return resultobj;
21065 fail:
21066 return NULL;
21067 }
21068
21069
21070 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21071 PyObject *resultobj;
21072 wxDateTime *arg1 = (wxDateTime *) 0 ;
21073 double result;
21074 PyObject * obj0 = 0 ;
21075 char *kwnames[] = {
21076 (char *) "self", NULL
21077 };
21078
21079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21081 if (SWIG_arg_fail(1)) SWIG_fail;
21082 {
21083 PyThreadState* __tstate = wxPyBeginAllowThreads();
21084 result = (double)(arg1)->GetMJD();
21085
21086 wxPyEndAllowThreads(__tstate);
21087 if (PyErr_Occurred()) SWIG_fail;
21088 }
21089 {
21090 resultobj = SWIG_From_double((double)(result));
21091 }
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21099 PyObject *resultobj;
21100 wxDateTime *arg1 = (wxDateTime *) 0 ;
21101 double result;
21102 PyObject * obj0 = 0 ;
21103 char *kwnames[] = {
21104 (char *) "self", NULL
21105 };
21106
21107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21109 if (SWIG_arg_fail(1)) SWIG_fail;
21110 {
21111 PyThreadState* __tstate = wxPyBeginAllowThreads();
21112 result = (double)(arg1)->GetRataDie();
21113
21114 wxPyEndAllowThreads(__tstate);
21115 if (PyErr_Occurred()) SWIG_fail;
21116 }
21117 {
21118 resultobj = SWIG_From_double((double)(result));
21119 }
21120 return resultobj;
21121 fail:
21122 return NULL;
21123 }
21124
21125
21126 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21127 PyObject *resultobj;
21128 wxDateTime *arg1 = (wxDateTime *) 0 ;
21129 wxDateTime::TimeZone *arg2 = 0 ;
21130 bool arg3 = (bool) false ;
21131 wxDateTime result;
21132 bool temp2 = false ;
21133 PyObject * obj0 = 0 ;
21134 PyObject * obj1 = 0 ;
21135 PyObject * obj2 = 0 ;
21136 char *kwnames[] = {
21137 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21138 };
21139
21140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21142 if (SWIG_arg_fail(1)) SWIG_fail;
21143 {
21144 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21145 temp2 = true;
21146 }
21147 if (obj2) {
21148 {
21149 arg3 = (bool)(SWIG_As_bool(obj2));
21150 if (SWIG_arg_fail(3)) SWIG_fail;
21151 }
21152 }
21153 {
21154 PyThreadState* __tstate = wxPyBeginAllowThreads();
21155 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21156
21157 wxPyEndAllowThreads(__tstate);
21158 if (PyErr_Occurred()) SWIG_fail;
21159 }
21160 {
21161 wxDateTime * resultptr;
21162 resultptr = new wxDateTime((wxDateTime &)(result));
21163 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21164 }
21165 {
21166 if (temp2) delete arg2;
21167 }
21168 return resultobj;
21169 fail:
21170 {
21171 if (temp2) delete arg2;
21172 }
21173 return NULL;
21174 }
21175
21176
21177 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21178 PyObject *resultobj;
21179 wxDateTime *arg1 = (wxDateTime *) 0 ;
21180 wxDateTime::TimeZone *arg2 = 0 ;
21181 bool arg3 = (bool) false ;
21182 wxDateTime *result;
21183 bool temp2 = false ;
21184 PyObject * obj0 = 0 ;
21185 PyObject * obj1 = 0 ;
21186 PyObject * obj2 = 0 ;
21187 char *kwnames[] = {
21188 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21189 };
21190
21191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21193 if (SWIG_arg_fail(1)) SWIG_fail;
21194 {
21195 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21196 temp2 = true;
21197 }
21198 if (obj2) {
21199 {
21200 arg3 = (bool)(SWIG_As_bool(obj2));
21201 if (SWIG_arg_fail(3)) SWIG_fail;
21202 }
21203 }
21204 {
21205 PyThreadState* __tstate = wxPyBeginAllowThreads();
21206 {
21207 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21208 result = (wxDateTime *) &_result_ref;
21209 }
21210
21211 wxPyEndAllowThreads(__tstate);
21212 if (PyErr_Occurred()) SWIG_fail;
21213 }
21214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21215 {
21216 if (temp2) delete arg2;
21217 }
21218 return resultobj;
21219 fail:
21220 {
21221 if (temp2) delete arg2;
21222 }
21223 return NULL;
21224 }
21225
21226
21227 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21228 PyObject *resultobj;
21229 wxDateTime *arg1 = (wxDateTime *) 0 ;
21230 bool arg2 = (bool) false ;
21231 wxDateTime result;
21232 PyObject * obj0 = 0 ;
21233 PyObject * obj1 = 0 ;
21234 char *kwnames[] = {
21235 (char *) "self",(char *) "noDST", NULL
21236 };
21237
21238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21240 if (SWIG_arg_fail(1)) SWIG_fail;
21241 if (obj1) {
21242 {
21243 arg2 = (bool)(SWIG_As_bool(obj1));
21244 if (SWIG_arg_fail(2)) SWIG_fail;
21245 }
21246 }
21247 {
21248 PyThreadState* __tstate = wxPyBeginAllowThreads();
21249 result = (arg1)->ToGMT(arg2);
21250
21251 wxPyEndAllowThreads(__tstate);
21252 if (PyErr_Occurred()) SWIG_fail;
21253 }
21254 {
21255 wxDateTime * resultptr;
21256 resultptr = new wxDateTime((wxDateTime &)(result));
21257 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21258 }
21259 return resultobj;
21260 fail:
21261 return NULL;
21262 }
21263
21264
21265 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21266 PyObject *resultobj;
21267 wxDateTime *arg1 = (wxDateTime *) 0 ;
21268 bool arg2 = (bool) false ;
21269 wxDateTime *result;
21270 PyObject * obj0 = 0 ;
21271 PyObject * obj1 = 0 ;
21272 char *kwnames[] = {
21273 (char *) "self",(char *) "noDST", NULL
21274 };
21275
21276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21278 if (SWIG_arg_fail(1)) SWIG_fail;
21279 if (obj1) {
21280 {
21281 arg2 = (bool)(SWIG_As_bool(obj1));
21282 if (SWIG_arg_fail(2)) SWIG_fail;
21283 }
21284 }
21285 {
21286 PyThreadState* __tstate = wxPyBeginAllowThreads();
21287 {
21288 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21289 result = (wxDateTime *) &_result_ref;
21290 }
21291
21292 wxPyEndAllowThreads(__tstate);
21293 if (PyErr_Occurred()) SWIG_fail;
21294 }
21295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21296 return resultobj;
21297 fail:
21298 return NULL;
21299 }
21300
21301
21302 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21303 PyObject *resultobj;
21304 wxDateTime *arg1 = (wxDateTime *) 0 ;
21305 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21306 int result;
21307 PyObject * obj0 = 0 ;
21308 PyObject * obj1 = 0 ;
21309 char *kwnames[] = {
21310 (char *) "self",(char *) "country", NULL
21311 };
21312
21313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21315 if (SWIG_arg_fail(1)) SWIG_fail;
21316 if (obj1) {
21317 {
21318 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21319 if (SWIG_arg_fail(2)) SWIG_fail;
21320 }
21321 }
21322 {
21323 PyThreadState* __tstate = wxPyBeginAllowThreads();
21324 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21325
21326 wxPyEndAllowThreads(__tstate);
21327 if (PyErr_Occurred()) SWIG_fail;
21328 }
21329 {
21330 resultobj = SWIG_From_int((int)(result));
21331 }
21332 return resultobj;
21333 fail:
21334 return NULL;
21335 }
21336
21337
21338 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21339 PyObject *resultobj;
21340 wxDateTime *arg1 = (wxDateTime *) 0 ;
21341 bool result;
21342 PyObject * obj0 = 0 ;
21343 char *kwnames[] = {
21344 (char *) "self", NULL
21345 };
21346
21347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21349 if (SWIG_arg_fail(1)) SWIG_fail;
21350 {
21351 PyThreadState* __tstate = wxPyBeginAllowThreads();
21352 result = (bool)((wxDateTime const *)arg1)->IsValid();
21353
21354 wxPyEndAllowThreads(__tstate);
21355 if (PyErr_Occurred()) SWIG_fail;
21356 }
21357 {
21358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21359 }
21360 return resultobj;
21361 fail:
21362 return NULL;
21363 }
21364
21365
21366 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21367 PyObject *resultobj;
21368 wxDateTime *arg1 = (wxDateTime *) 0 ;
21369 time_t result;
21370 PyObject * obj0 = 0 ;
21371 char *kwnames[] = {
21372 (char *) "self", NULL
21373 };
21374
21375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21377 if (SWIG_arg_fail(1)) SWIG_fail;
21378 {
21379 PyThreadState* __tstate = wxPyBeginAllowThreads();
21380 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21381
21382 wxPyEndAllowThreads(__tstate);
21383 if (PyErr_Occurred()) SWIG_fail;
21384 }
21385 {
21386 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21387 }
21388 return resultobj;
21389 fail:
21390 return NULL;
21391 }
21392
21393
21394 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21395 PyObject *resultobj;
21396 wxDateTime *arg1 = (wxDateTime *) 0 ;
21397 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21398 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21399 int result;
21400 bool temp2 = false ;
21401 PyObject * obj0 = 0 ;
21402 PyObject * obj1 = 0 ;
21403 char *kwnames[] = {
21404 (char *) "self",(char *) "tz", NULL
21405 };
21406
21407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21409 if (SWIG_arg_fail(1)) SWIG_fail;
21410 if (obj1) {
21411 {
21412 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21413 temp2 = true;
21414 }
21415 }
21416 {
21417 PyThreadState* __tstate = wxPyBeginAllowThreads();
21418 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21419
21420 wxPyEndAllowThreads(__tstate);
21421 if (PyErr_Occurred()) SWIG_fail;
21422 }
21423 {
21424 resultobj = SWIG_From_int((int)(result));
21425 }
21426 {
21427 if (temp2) delete arg2;
21428 }
21429 return resultobj;
21430 fail:
21431 {
21432 if (temp2) delete arg2;
21433 }
21434 return NULL;
21435 }
21436
21437
21438 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21439 PyObject *resultobj;
21440 wxDateTime *arg1 = (wxDateTime *) 0 ;
21441 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21442 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21443 wxDateTime::Month result;
21444 bool temp2 = false ;
21445 PyObject * obj0 = 0 ;
21446 PyObject * obj1 = 0 ;
21447 char *kwnames[] = {
21448 (char *) "self",(char *) "tz", NULL
21449 };
21450
21451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21453 if (SWIG_arg_fail(1)) SWIG_fail;
21454 if (obj1) {
21455 {
21456 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21457 temp2 = true;
21458 }
21459 }
21460 {
21461 PyThreadState* __tstate = wxPyBeginAllowThreads();
21462 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21463
21464 wxPyEndAllowThreads(__tstate);
21465 if (PyErr_Occurred()) SWIG_fail;
21466 }
21467 resultobj = SWIG_From_int((result));
21468 {
21469 if (temp2) delete arg2;
21470 }
21471 return resultobj;
21472 fail:
21473 {
21474 if (temp2) delete arg2;
21475 }
21476 return NULL;
21477 }
21478
21479
21480 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21481 PyObject *resultobj;
21482 wxDateTime *arg1 = (wxDateTime *) 0 ;
21483 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21484 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21485 int result;
21486 bool temp2 = false ;
21487 PyObject * obj0 = 0 ;
21488 PyObject * obj1 = 0 ;
21489 char *kwnames[] = {
21490 (char *) "self",(char *) "tz", NULL
21491 };
21492
21493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21495 if (SWIG_arg_fail(1)) SWIG_fail;
21496 if (obj1) {
21497 {
21498 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21499 temp2 = true;
21500 }
21501 }
21502 {
21503 PyThreadState* __tstate = wxPyBeginAllowThreads();
21504 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21505
21506 wxPyEndAllowThreads(__tstate);
21507 if (PyErr_Occurred()) SWIG_fail;
21508 }
21509 {
21510 resultobj = SWIG_From_int((int)(result));
21511 }
21512 {
21513 if (temp2) delete arg2;
21514 }
21515 return resultobj;
21516 fail:
21517 {
21518 if (temp2) delete arg2;
21519 }
21520 return NULL;
21521 }
21522
21523
21524 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21525 PyObject *resultobj;
21526 wxDateTime *arg1 = (wxDateTime *) 0 ;
21527 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21528 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21529 wxDateTime::WeekDay result;
21530 bool temp2 = false ;
21531 PyObject * obj0 = 0 ;
21532 PyObject * obj1 = 0 ;
21533 char *kwnames[] = {
21534 (char *) "self",(char *) "tz", NULL
21535 };
21536
21537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21539 if (SWIG_arg_fail(1)) SWIG_fail;
21540 if (obj1) {
21541 {
21542 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21543 temp2 = true;
21544 }
21545 }
21546 {
21547 PyThreadState* __tstate = wxPyBeginAllowThreads();
21548 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21549
21550 wxPyEndAllowThreads(__tstate);
21551 if (PyErr_Occurred()) SWIG_fail;
21552 }
21553 resultobj = SWIG_From_int((result));
21554 {
21555 if (temp2) delete arg2;
21556 }
21557 return resultobj;
21558 fail:
21559 {
21560 if (temp2) delete arg2;
21561 }
21562 return NULL;
21563 }
21564
21565
21566 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21567 PyObject *resultobj;
21568 wxDateTime *arg1 = (wxDateTime *) 0 ;
21569 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21570 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21571 int result;
21572 bool temp2 = false ;
21573 PyObject * obj0 = 0 ;
21574 PyObject * obj1 = 0 ;
21575 char *kwnames[] = {
21576 (char *) "self",(char *) "tz", NULL
21577 };
21578
21579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21581 if (SWIG_arg_fail(1)) SWIG_fail;
21582 if (obj1) {
21583 {
21584 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21585 temp2 = true;
21586 }
21587 }
21588 {
21589 PyThreadState* __tstate = wxPyBeginAllowThreads();
21590 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21591
21592 wxPyEndAllowThreads(__tstate);
21593 if (PyErr_Occurred()) SWIG_fail;
21594 }
21595 {
21596 resultobj = SWIG_From_int((int)(result));
21597 }
21598 {
21599 if (temp2) delete arg2;
21600 }
21601 return resultobj;
21602 fail:
21603 {
21604 if (temp2) delete arg2;
21605 }
21606 return NULL;
21607 }
21608
21609
21610 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21611 PyObject *resultobj;
21612 wxDateTime *arg1 = (wxDateTime *) 0 ;
21613 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21614 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21615 int result;
21616 bool temp2 = false ;
21617 PyObject * obj0 = 0 ;
21618 PyObject * obj1 = 0 ;
21619 char *kwnames[] = {
21620 (char *) "self",(char *) "tz", NULL
21621 };
21622
21623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21625 if (SWIG_arg_fail(1)) SWIG_fail;
21626 if (obj1) {
21627 {
21628 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21629 temp2 = true;
21630 }
21631 }
21632 {
21633 PyThreadState* __tstate = wxPyBeginAllowThreads();
21634 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21635
21636 wxPyEndAllowThreads(__tstate);
21637 if (PyErr_Occurred()) SWIG_fail;
21638 }
21639 {
21640 resultobj = SWIG_From_int((int)(result));
21641 }
21642 {
21643 if (temp2) delete arg2;
21644 }
21645 return resultobj;
21646 fail:
21647 {
21648 if (temp2) delete arg2;
21649 }
21650 return NULL;
21651 }
21652
21653
21654 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21655 PyObject *resultobj;
21656 wxDateTime *arg1 = (wxDateTime *) 0 ;
21657 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21658 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21659 int result;
21660 bool temp2 = false ;
21661 PyObject * obj0 = 0 ;
21662 PyObject * obj1 = 0 ;
21663 char *kwnames[] = {
21664 (char *) "self",(char *) "tz", NULL
21665 };
21666
21667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21669 if (SWIG_arg_fail(1)) SWIG_fail;
21670 if (obj1) {
21671 {
21672 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21673 temp2 = true;
21674 }
21675 }
21676 {
21677 PyThreadState* __tstate = wxPyBeginAllowThreads();
21678 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21679
21680 wxPyEndAllowThreads(__tstate);
21681 if (PyErr_Occurred()) SWIG_fail;
21682 }
21683 {
21684 resultobj = SWIG_From_int((int)(result));
21685 }
21686 {
21687 if (temp2) delete arg2;
21688 }
21689 return resultobj;
21690 fail:
21691 {
21692 if (temp2) delete arg2;
21693 }
21694 return NULL;
21695 }
21696
21697
21698 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21699 PyObject *resultobj;
21700 wxDateTime *arg1 = (wxDateTime *) 0 ;
21701 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21702 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21703 int result;
21704 bool temp2 = false ;
21705 PyObject * obj0 = 0 ;
21706 PyObject * obj1 = 0 ;
21707 char *kwnames[] = {
21708 (char *) "self",(char *) "tz", NULL
21709 };
21710
21711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21713 if (SWIG_arg_fail(1)) SWIG_fail;
21714 if (obj1) {
21715 {
21716 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21717 temp2 = true;
21718 }
21719 }
21720 {
21721 PyThreadState* __tstate = wxPyBeginAllowThreads();
21722 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21723
21724 wxPyEndAllowThreads(__tstate);
21725 if (PyErr_Occurred()) SWIG_fail;
21726 }
21727 {
21728 resultobj = SWIG_From_int((int)(result));
21729 }
21730 {
21731 if (temp2) delete arg2;
21732 }
21733 return resultobj;
21734 fail:
21735 {
21736 if (temp2) delete arg2;
21737 }
21738 return NULL;
21739 }
21740
21741
21742 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21743 PyObject *resultobj;
21744 wxDateTime *arg1 = (wxDateTime *) 0 ;
21745 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21746 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21747 int result;
21748 bool temp2 = false ;
21749 PyObject * obj0 = 0 ;
21750 PyObject * obj1 = 0 ;
21751 char *kwnames[] = {
21752 (char *) "self",(char *) "tz", NULL
21753 };
21754
21755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21757 if (SWIG_arg_fail(1)) SWIG_fail;
21758 if (obj1) {
21759 {
21760 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21761 temp2 = true;
21762 }
21763 }
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21767
21768 wxPyEndAllowThreads(__tstate);
21769 if (PyErr_Occurred()) SWIG_fail;
21770 }
21771 {
21772 resultobj = SWIG_From_int((int)(result));
21773 }
21774 {
21775 if (temp2) delete arg2;
21776 }
21777 return resultobj;
21778 fail:
21779 {
21780 if (temp2) delete arg2;
21781 }
21782 return NULL;
21783 }
21784
21785
21786 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21787 PyObject *resultobj;
21788 wxDateTime *arg1 = (wxDateTime *) 0 ;
21789 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21790 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21791 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21792 int result;
21793 bool temp3 = false ;
21794 PyObject * obj0 = 0 ;
21795 PyObject * obj1 = 0 ;
21796 PyObject * obj2 = 0 ;
21797 char *kwnames[] = {
21798 (char *) "self",(char *) "flags",(char *) "tz", NULL
21799 };
21800
21801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21803 if (SWIG_arg_fail(1)) SWIG_fail;
21804 if (obj1) {
21805 {
21806 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21807 if (SWIG_arg_fail(2)) SWIG_fail;
21808 }
21809 }
21810 if (obj2) {
21811 {
21812 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21813 temp3 = true;
21814 }
21815 }
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21819
21820 wxPyEndAllowThreads(__tstate);
21821 if (PyErr_Occurred()) SWIG_fail;
21822 }
21823 {
21824 resultobj = SWIG_From_int((int)(result));
21825 }
21826 {
21827 if (temp3) delete arg3;
21828 }
21829 return resultobj;
21830 fail:
21831 {
21832 if (temp3) delete arg3;
21833 }
21834 return NULL;
21835 }
21836
21837
21838 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21839 PyObject *resultobj;
21840 wxDateTime *arg1 = (wxDateTime *) 0 ;
21841 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21842 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21843 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21844 int result;
21845 bool temp3 = false ;
21846 PyObject * obj0 = 0 ;
21847 PyObject * obj1 = 0 ;
21848 PyObject * obj2 = 0 ;
21849 char *kwnames[] = {
21850 (char *) "self",(char *) "flags",(char *) "tz", NULL
21851 };
21852
21853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21855 if (SWIG_arg_fail(1)) SWIG_fail;
21856 if (obj1) {
21857 {
21858 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21859 if (SWIG_arg_fail(2)) SWIG_fail;
21860 }
21861 }
21862 if (obj2) {
21863 {
21864 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21865 temp3 = true;
21866 }
21867 }
21868 {
21869 PyThreadState* __tstate = wxPyBeginAllowThreads();
21870 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21871
21872 wxPyEndAllowThreads(__tstate);
21873 if (PyErr_Occurred()) SWIG_fail;
21874 }
21875 {
21876 resultobj = SWIG_From_int((int)(result));
21877 }
21878 {
21879 if (temp3) delete arg3;
21880 }
21881 return resultobj;
21882 fail:
21883 {
21884 if (temp3) delete arg3;
21885 }
21886 return NULL;
21887 }
21888
21889
21890 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21891 PyObject *resultobj;
21892 wxDateTime *arg1 = (wxDateTime *) 0 ;
21893 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21894 bool result;
21895 PyObject * obj0 = 0 ;
21896 PyObject * obj1 = 0 ;
21897 char *kwnames[] = {
21898 (char *) "self",(char *) "country", NULL
21899 };
21900
21901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21903 if (SWIG_arg_fail(1)) SWIG_fail;
21904 if (obj1) {
21905 {
21906 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21907 if (SWIG_arg_fail(2)) SWIG_fail;
21908 }
21909 }
21910 {
21911 PyThreadState* __tstate = wxPyBeginAllowThreads();
21912 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21913
21914 wxPyEndAllowThreads(__tstate);
21915 if (PyErr_Occurred()) SWIG_fail;
21916 }
21917 {
21918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21919 }
21920 return resultobj;
21921 fail:
21922 return NULL;
21923 }
21924
21925
21926 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21927 PyObject *resultobj;
21928 wxDateTime *arg1 = (wxDateTime *) 0 ;
21929 wxDateTime *arg2 = 0 ;
21930 bool result;
21931 PyObject * obj0 = 0 ;
21932 PyObject * obj1 = 0 ;
21933 char *kwnames[] = {
21934 (char *) "self",(char *) "datetime", NULL
21935 };
21936
21937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21939 if (SWIG_arg_fail(1)) SWIG_fail;
21940 {
21941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21942 if (SWIG_arg_fail(2)) SWIG_fail;
21943 if (arg2 == NULL) {
21944 SWIG_null_ref("wxDateTime");
21945 }
21946 if (SWIG_arg_fail(2)) SWIG_fail;
21947 }
21948 {
21949 PyThreadState* __tstate = wxPyBeginAllowThreads();
21950 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21951
21952 wxPyEndAllowThreads(__tstate);
21953 if (PyErr_Occurred()) SWIG_fail;
21954 }
21955 {
21956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21957 }
21958 return resultobj;
21959 fail:
21960 return NULL;
21961 }
21962
21963
21964 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21965 PyObject *resultobj;
21966 wxDateTime *arg1 = (wxDateTime *) 0 ;
21967 wxDateTime *arg2 = 0 ;
21968 bool result;
21969 PyObject * obj0 = 0 ;
21970 PyObject * obj1 = 0 ;
21971 char *kwnames[] = {
21972 (char *) "self",(char *) "datetime", NULL
21973 };
21974
21975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21977 if (SWIG_arg_fail(1)) SWIG_fail;
21978 {
21979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21980 if (SWIG_arg_fail(2)) SWIG_fail;
21981 if (arg2 == NULL) {
21982 SWIG_null_ref("wxDateTime");
21983 }
21984 if (SWIG_arg_fail(2)) SWIG_fail;
21985 }
21986 {
21987 PyThreadState* __tstate = wxPyBeginAllowThreads();
21988 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21989
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21995 }
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22003 PyObject *resultobj;
22004 wxDateTime *arg1 = (wxDateTime *) 0 ;
22005 wxDateTime *arg2 = 0 ;
22006 bool result;
22007 PyObject * obj0 = 0 ;
22008 PyObject * obj1 = 0 ;
22009 char *kwnames[] = {
22010 (char *) "self",(char *) "datetime", NULL
22011 };
22012
22013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22015 if (SWIG_arg_fail(1)) SWIG_fail;
22016 {
22017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22018 if (SWIG_arg_fail(2)) SWIG_fail;
22019 if (arg2 == NULL) {
22020 SWIG_null_ref("wxDateTime");
22021 }
22022 if (SWIG_arg_fail(2)) SWIG_fail;
22023 }
22024 {
22025 PyThreadState* __tstate = wxPyBeginAllowThreads();
22026 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22027
22028 wxPyEndAllowThreads(__tstate);
22029 if (PyErr_Occurred()) SWIG_fail;
22030 }
22031 {
22032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22033 }
22034 return resultobj;
22035 fail:
22036 return NULL;
22037 }
22038
22039
22040 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22041 PyObject *resultobj;
22042 wxDateTime *arg1 = (wxDateTime *) 0 ;
22043 wxDateTime *arg2 = 0 ;
22044 wxDateTime *arg3 = 0 ;
22045 bool result;
22046 PyObject * obj0 = 0 ;
22047 PyObject * obj1 = 0 ;
22048 PyObject * obj2 = 0 ;
22049 char *kwnames[] = {
22050 (char *) "self",(char *) "t1",(char *) "t2", NULL
22051 };
22052
22053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22055 if (SWIG_arg_fail(1)) SWIG_fail;
22056 {
22057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22058 if (SWIG_arg_fail(2)) SWIG_fail;
22059 if (arg2 == NULL) {
22060 SWIG_null_ref("wxDateTime");
22061 }
22062 if (SWIG_arg_fail(2)) SWIG_fail;
22063 }
22064 {
22065 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22066 if (SWIG_arg_fail(3)) SWIG_fail;
22067 if (arg3 == NULL) {
22068 SWIG_null_ref("wxDateTime");
22069 }
22070 if (SWIG_arg_fail(3)) SWIG_fail;
22071 }
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22075
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 {
22080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22081 }
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22089 PyObject *resultobj;
22090 wxDateTime *arg1 = (wxDateTime *) 0 ;
22091 wxDateTime *arg2 = 0 ;
22092 wxDateTime *arg3 = 0 ;
22093 bool result;
22094 PyObject * obj0 = 0 ;
22095 PyObject * obj1 = 0 ;
22096 PyObject * obj2 = 0 ;
22097 char *kwnames[] = {
22098 (char *) "self",(char *) "t1",(char *) "t2", NULL
22099 };
22100
22101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22103 if (SWIG_arg_fail(1)) SWIG_fail;
22104 {
22105 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22106 if (SWIG_arg_fail(2)) SWIG_fail;
22107 if (arg2 == NULL) {
22108 SWIG_null_ref("wxDateTime");
22109 }
22110 if (SWIG_arg_fail(2)) SWIG_fail;
22111 }
22112 {
22113 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22114 if (SWIG_arg_fail(3)) SWIG_fail;
22115 if (arg3 == NULL) {
22116 SWIG_null_ref("wxDateTime");
22117 }
22118 if (SWIG_arg_fail(3)) SWIG_fail;
22119 }
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22123
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 {
22128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22129 }
22130 return resultobj;
22131 fail:
22132 return NULL;
22133 }
22134
22135
22136 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22137 PyObject *resultobj;
22138 wxDateTime *arg1 = (wxDateTime *) 0 ;
22139 wxDateTime *arg2 = 0 ;
22140 bool result;
22141 PyObject * obj0 = 0 ;
22142 PyObject * obj1 = 0 ;
22143 char *kwnames[] = {
22144 (char *) "self",(char *) "dt", NULL
22145 };
22146
22147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22149 if (SWIG_arg_fail(1)) SWIG_fail;
22150 {
22151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22152 if (SWIG_arg_fail(2)) SWIG_fail;
22153 if (arg2 == NULL) {
22154 SWIG_null_ref("wxDateTime");
22155 }
22156 if (SWIG_arg_fail(2)) SWIG_fail;
22157 }
22158 {
22159 PyThreadState* __tstate = wxPyBeginAllowThreads();
22160 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22161
22162 wxPyEndAllowThreads(__tstate);
22163 if (PyErr_Occurred()) SWIG_fail;
22164 }
22165 {
22166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22167 }
22168 return resultobj;
22169 fail:
22170 return NULL;
22171 }
22172
22173
22174 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22175 PyObject *resultobj;
22176 wxDateTime *arg1 = (wxDateTime *) 0 ;
22177 wxDateTime *arg2 = 0 ;
22178 bool result;
22179 PyObject * obj0 = 0 ;
22180 PyObject * obj1 = 0 ;
22181 char *kwnames[] = {
22182 (char *) "self",(char *) "dt", NULL
22183 };
22184
22185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22187 if (SWIG_arg_fail(1)) SWIG_fail;
22188 {
22189 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22190 if (SWIG_arg_fail(2)) SWIG_fail;
22191 if (arg2 == NULL) {
22192 SWIG_null_ref("wxDateTime");
22193 }
22194 if (SWIG_arg_fail(2)) SWIG_fail;
22195 }
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22199
22200 wxPyEndAllowThreads(__tstate);
22201 if (PyErr_Occurred()) SWIG_fail;
22202 }
22203 {
22204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22205 }
22206 return resultobj;
22207 fail:
22208 return NULL;
22209 }
22210
22211
22212 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22213 PyObject *resultobj;
22214 wxDateTime *arg1 = (wxDateTime *) 0 ;
22215 wxDateTime *arg2 = 0 ;
22216 wxTimeSpan *arg3 = 0 ;
22217 bool result;
22218 PyObject * obj0 = 0 ;
22219 PyObject * obj1 = 0 ;
22220 PyObject * obj2 = 0 ;
22221 char *kwnames[] = {
22222 (char *) "self",(char *) "dt",(char *) "ts", NULL
22223 };
22224
22225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22227 if (SWIG_arg_fail(1)) SWIG_fail;
22228 {
22229 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22230 if (SWIG_arg_fail(2)) SWIG_fail;
22231 if (arg2 == NULL) {
22232 SWIG_null_ref("wxDateTime");
22233 }
22234 if (SWIG_arg_fail(2)) SWIG_fail;
22235 }
22236 {
22237 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22238 if (SWIG_arg_fail(3)) SWIG_fail;
22239 if (arg3 == NULL) {
22240 SWIG_null_ref("wxTimeSpan");
22241 }
22242 if (SWIG_arg_fail(3)) SWIG_fail;
22243 }
22244 {
22245 PyThreadState* __tstate = wxPyBeginAllowThreads();
22246 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22247
22248 wxPyEndAllowThreads(__tstate);
22249 if (PyErr_Occurred()) SWIG_fail;
22250 }
22251 {
22252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22253 }
22254 return resultobj;
22255 fail:
22256 return NULL;
22257 }
22258
22259
22260 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22261 PyObject *resultobj;
22262 wxDateTime *arg1 = (wxDateTime *) 0 ;
22263 wxTimeSpan *arg2 = 0 ;
22264 wxDateTime *result;
22265 PyObject * obj0 = 0 ;
22266 PyObject * obj1 = 0 ;
22267 char *kwnames[] = {
22268 (char *) "self",(char *) "diff", NULL
22269 };
22270
22271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22273 if (SWIG_arg_fail(1)) SWIG_fail;
22274 {
22275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22276 if (SWIG_arg_fail(2)) SWIG_fail;
22277 if (arg2 == NULL) {
22278 SWIG_null_ref("wxTimeSpan");
22279 }
22280 if (SWIG_arg_fail(2)) SWIG_fail;
22281 }
22282 {
22283 PyThreadState* __tstate = wxPyBeginAllowThreads();
22284 {
22285 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22286 result = (wxDateTime *) &_result_ref;
22287 }
22288
22289 wxPyEndAllowThreads(__tstate);
22290 if (PyErr_Occurred()) SWIG_fail;
22291 }
22292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22300 PyObject *resultobj;
22301 wxDateTime *arg1 = (wxDateTime *) 0 ;
22302 wxDateSpan *arg2 = 0 ;
22303 wxDateTime *result;
22304 PyObject * obj0 = 0 ;
22305 PyObject * obj1 = 0 ;
22306 char *kwnames[] = {
22307 (char *) "self",(char *) "diff", NULL
22308 };
22309
22310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22312 if (SWIG_arg_fail(1)) SWIG_fail;
22313 {
22314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22315 if (SWIG_arg_fail(2)) SWIG_fail;
22316 if (arg2 == NULL) {
22317 SWIG_null_ref("wxDateSpan");
22318 }
22319 if (SWIG_arg_fail(2)) SWIG_fail;
22320 }
22321 {
22322 PyThreadState* __tstate = wxPyBeginAllowThreads();
22323 {
22324 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22325 result = (wxDateTime *) &_result_ref;
22326 }
22327
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22332 return resultobj;
22333 fail:
22334 return NULL;
22335 }
22336
22337
22338 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22339 PyObject *resultobj;
22340 wxDateTime *arg1 = (wxDateTime *) 0 ;
22341 wxTimeSpan *arg2 = 0 ;
22342 wxDateTime *result;
22343 PyObject * obj0 = 0 ;
22344 PyObject * obj1 = 0 ;
22345 char *kwnames[] = {
22346 (char *) "self",(char *) "diff", NULL
22347 };
22348
22349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22351 if (SWIG_arg_fail(1)) SWIG_fail;
22352 {
22353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22354 if (SWIG_arg_fail(2)) SWIG_fail;
22355 if (arg2 == NULL) {
22356 SWIG_null_ref("wxTimeSpan");
22357 }
22358 if (SWIG_arg_fail(2)) SWIG_fail;
22359 }
22360 {
22361 PyThreadState* __tstate = wxPyBeginAllowThreads();
22362 {
22363 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22364 result = (wxDateTime *) &_result_ref;
22365 }
22366
22367 wxPyEndAllowThreads(__tstate);
22368 if (PyErr_Occurred()) SWIG_fail;
22369 }
22370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22371 return resultobj;
22372 fail:
22373 return NULL;
22374 }
22375
22376
22377 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22378 PyObject *resultobj;
22379 wxDateTime *arg1 = (wxDateTime *) 0 ;
22380 wxDateSpan *arg2 = 0 ;
22381 wxDateTime *result;
22382 PyObject * obj0 = 0 ;
22383 PyObject * obj1 = 0 ;
22384 char *kwnames[] = {
22385 (char *) "self",(char *) "diff", NULL
22386 };
22387
22388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22390 if (SWIG_arg_fail(1)) SWIG_fail;
22391 {
22392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22393 if (SWIG_arg_fail(2)) SWIG_fail;
22394 if (arg2 == NULL) {
22395 SWIG_null_ref("wxDateSpan");
22396 }
22397 if (SWIG_arg_fail(2)) SWIG_fail;
22398 }
22399 {
22400 PyThreadState* __tstate = wxPyBeginAllowThreads();
22401 {
22402 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22403 result = (wxDateTime *) &_result_ref;
22404 }
22405
22406 wxPyEndAllowThreads(__tstate);
22407 if (PyErr_Occurred()) SWIG_fail;
22408 }
22409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22410 return resultobj;
22411 fail:
22412 return NULL;
22413 }
22414
22415
22416 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22417 PyObject *resultobj;
22418 wxDateTime *arg1 = (wxDateTime *) 0 ;
22419 wxDateTime *arg2 = 0 ;
22420 wxTimeSpan result;
22421 PyObject * obj0 = 0 ;
22422 PyObject * obj1 = 0 ;
22423 char *kwnames[] = {
22424 (char *) "self",(char *) "dt", NULL
22425 };
22426
22427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22429 if (SWIG_arg_fail(1)) SWIG_fail;
22430 {
22431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22432 if (SWIG_arg_fail(2)) SWIG_fail;
22433 if (arg2 == NULL) {
22434 SWIG_null_ref("wxDateTime");
22435 }
22436 if (SWIG_arg_fail(2)) SWIG_fail;
22437 }
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22441
22442 wxPyEndAllowThreads(__tstate);
22443 if (PyErr_Occurred()) SWIG_fail;
22444 }
22445 {
22446 wxTimeSpan * resultptr;
22447 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22448 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22449 }
22450 return resultobj;
22451 fail:
22452 return NULL;
22453 }
22454
22455
22456 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22457 PyObject *resultobj;
22458 wxDateTime *arg1 = (wxDateTime *) 0 ;
22459 wxTimeSpan *arg2 = 0 ;
22460 wxDateTime *result;
22461 PyObject * obj0 = 0 ;
22462 PyObject * obj1 = 0 ;
22463
22464 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22466 if (SWIG_arg_fail(1)) SWIG_fail;
22467 {
22468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22469 if (SWIG_arg_fail(2)) SWIG_fail;
22470 if (arg2 == NULL) {
22471 SWIG_null_ref("wxTimeSpan");
22472 }
22473 if (SWIG_arg_fail(2)) SWIG_fail;
22474 }
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 {
22478 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22479 result = (wxDateTime *) &_result_ref;
22480 }
22481
22482 wxPyEndAllowThreads(__tstate);
22483 if (PyErr_Occurred()) SWIG_fail;
22484 }
22485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22486 return resultobj;
22487 fail:
22488 return NULL;
22489 }
22490
22491
22492 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22493 PyObject *resultobj;
22494 wxDateTime *arg1 = (wxDateTime *) 0 ;
22495 wxDateSpan *arg2 = 0 ;
22496 wxDateTime *result;
22497 PyObject * obj0 = 0 ;
22498 PyObject * obj1 = 0 ;
22499
22500 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22502 if (SWIG_arg_fail(1)) SWIG_fail;
22503 {
22504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22505 if (SWIG_arg_fail(2)) SWIG_fail;
22506 if (arg2 == NULL) {
22507 SWIG_null_ref("wxDateSpan");
22508 }
22509 if (SWIG_arg_fail(2)) SWIG_fail;
22510 }
22511 {
22512 PyThreadState* __tstate = wxPyBeginAllowThreads();
22513 {
22514 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22515 result = (wxDateTime *) &_result_ref;
22516 }
22517
22518 wxPyEndAllowThreads(__tstate);
22519 if (PyErr_Occurred()) SWIG_fail;
22520 }
22521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22522 return resultobj;
22523 fail:
22524 return NULL;
22525 }
22526
22527
22528 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22529 int argc;
22530 PyObject *argv[3];
22531 int ii;
22532
22533 argc = PyObject_Length(args);
22534 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22535 argv[ii] = PyTuple_GetItem(args,ii);
22536 }
22537 if (argc == 2) {
22538 int _v;
22539 {
22540 void *ptr;
22541 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22542 _v = 0;
22543 PyErr_Clear();
22544 } else {
22545 _v = 1;
22546 }
22547 }
22548 if (_v) {
22549 {
22550 void *ptr = 0;
22551 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22552 _v = 0;
22553 PyErr_Clear();
22554 } else {
22555 _v = (ptr != 0);
22556 }
22557 }
22558 if (_v) {
22559 return _wrap_DateTime___iadd____SWIG_0(self,args);
22560 }
22561 }
22562 }
22563 if (argc == 2) {
22564 int _v;
22565 {
22566 void *ptr;
22567 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22568 _v = 0;
22569 PyErr_Clear();
22570 } else {
22571 _v = 1;
22572 }
22573 }
22574 if (_v) {
22575 {
22576 void *ptr = 0;
22577 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22578 _v = 0;
22579 PyErr_Clear();
22580 } else {
22581 _v = (ptr != 0);
22582 }
22583 }
22584 if (_v) {
22585 return _wrap_DateTime___iadd____SWIG_1(self,args);
22586 }
22587 }
22588 }
22589
22590 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22591 return NULL;
22592 }
22593
22594
22595 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22596 PyObject *resultobj;
22597 wxDateTime *arg1 = (wxDateTime *) 0 ;
22598 wxTimeSpan *arg2 = 0 ;
22599 wxDateTime *result;
22600 PyObject * obj0 = 0 ;
22601 PyObject * obj1 = 0 ;
22602
22603 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22605 if (SWIG_arg_fail(1)) SWIG_fail;
22606 {
22607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22608 if (SWIG_arg_fail(2)) SWIG_fail;
22609 if (arg2 == NULL) {
22610 SWIG_null_ref("wxTimeSpan");
22611 }
22612 if (SWIG_arg_fail(2)) SWIG_fail;
22613 }
22614 {
22615 PyThreadState* __tstate = wxPyBeginAllowThreads();
22616 {
22617 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22618 result = (wxDateTime *) &_result_ref;
22619 }
22620
22621 wxPyEndAllowThreads(__tstate);
22622 if (PyErr_Occurred()) SWIG_fail;
22623 }
22624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22625 return resultobj;
22626 fail:
22627 return NULL;
22628 }
22629
22630
22631 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22632 PyObject *resultobj;
22633 wxDateTime *arg1 = (wxDateTime *) 0 ;
22634 wxDateSpan *arg2 = 0 ;
22635 wxDateTime *result;
22636 PyObject * obj0 = 0 ;
22637 PyObject * obj1 = 0 ;
22638
22639 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22641 if (SWIG_arg_fail(1)) SWIG_fail;
22642 {
22643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22644 if (SWIG_arg_fail(2)) SWIG_fail;
22645 if (arg2 == NULL) {
22646 SWIG_null_ref("wxDateSpan");
22647 }
22648 if (SWIG_arg_fail(2)) SWIG_fail;
22649 }
22650 {
22651 PyThreadState* __tstate = wxPyBeginAllowThreads();
22652 {
22653 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22654 result = (wxDateTime *) &_result_ref;
22655 }
22656
22657 wxPyEndAllowThreads(__tstate);
22658 if (PyErr_Occurred()) SWIG_fail;
22659 }
22660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22661 return resultobj;
22662 fail:
22663 return NULL;
22664 }
22665
22666
22667 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22668 int argc;
22669 PyObject *argv[3];
22670 int ii;
22671
22672 argc = PyObject_Length(args);
22673 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22674 argv[ii] = PyTuple_GetItem(args,ii);
22675 }
22676 if (argc == 2) {
22677 int _v;
22678 {
22679 void *ptr;
22680 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22681 _v = 0;
22682 PyErr_Clear();
22683 } else {
22684 _v = 1;
22685 }
22686 }
22687 if (_v) {
22688 {
22689 void *ptr = 0;
22690 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22691 _v = 0;
22692 PyErr_Clear();
22693 } else {
22694 _v = (ptr != 0);
22695 }
22696 }
22697 if (_v) {
22698 return _wrap_DateTime___isub____SWIG_0(self,args);
22699 }
22700 }
22701 }
22702 if (argc == 2) {
22703 int _v;
22704 {
22705 void *ptr;
22706 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22707 _v = 0;
22708 PyErr_Clear();
22709 } else {
22710 _v = 1;
22711 }
22712 }
22713 if (_v) {
22714 {
22715 void *ptr = 0;
22716 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22717 _v = 0;
22718 PyErr_Clear();
22719 } else {
22720 _v = (ptr != 0);
22721 }
22722 }
22723 if (_v) {
22724 return _wrap_DateTime___isub____SWIG_1(self,args);
22725 }
22726 }
22727 }
22728
22729 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22730 return NULL;
22731 }
22732
22733
22734 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22735 PyObject *resultobj;
22736 wxDateTime *arg1 = (wxDateTime *) 0 ;
22737 wxTimeSpan *arg2 = 0 ;
22738 wxDateTime result;
22739 PyObject * obj0 = 0 ;
22740 PyObject * obj1 = 0 ;
22741
22742 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22744 if (SWIG_arg_fail(1)) SWIG_fail;
22745 {
22746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22747 if (SWIG_arg_fail(2)) SWIG_fail;
22748 if (arg2 == NULL) {
22749 SWIG_null_ref("wxTimeSpan");
22750 }
22751 if (SWIG_arg_fail(2)) SWIG_fail;
22752 }
22753 {
22754 PyThreadState* __tstate = wxPyBeginAllowThreads();
22755 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22756
22757 wxPyEndAllowThreads(__tstate);
22758 if (PyErr_Occurred()) SWIG_fail;
22759 }
22760 {
22761 wxDateTime * resultptr;
22762 resultptr = new wxDateTime((wxDateTime &)(result));
22763 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22764 }
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22772 PyObject *resultobj;
22773 wxDateTime *arg1 = (wxDateTime *) 0 ;
22774 wxDateSpan *arg2 = 0 ;
22775 wxDateTime result;
22776 PyObject * obj0 = 0 ;
22777 PyObject * obj1 = 0 ;
22778
22779 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22781 if (SWIG_arg_fail(1)) SWIG_fail;
22782 {
22783 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22784 if (SWIG_arg_fail(2)) SWIG_fail;
22785 if (arg2 == NULL) {
22786 SWIG_null_ref("wxDateSpan");
22787 }
22788 if (SWIG_arg_fail(2)) SWIG_fail;
22789 }
22790 {
22791 PyThreadState* __tstate = wxPyBeginAllowThreads();
22792 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22793
22794 wxPyEndAllowThreads(__tstate);
22795 if (PyErr_Occurred()) SWIG_fail;
22796 }
22797 {
22798 wxDateTime * resultptr;
22799 resultptr = new wxDateTime((wxDateTime &)(result));
22800 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22801 }
22802 return resultobj;
22803 fail:
22804 return NULL;
22805 }
22806
22807
22808 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22809 int argc;
22810 PyObject *argv[3];
22811 int ii;
22812
22813 argc = PyObject_Length(args);
22814 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22815 argv[ii] = PyTuple_GetItem(args,ii);
22816 }
22817 if (argc == 2) {
22818 int _v;
22819 {
22820 void *ptr;
22821 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22822 _v = 0;
22823 PyErr_Clear();
22824 } else {
22825 _v = 1;
22826 }
22827 }
22828 if (_v) {
22829 {
22830 void *ptr = 0;
22831 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22832 _v = 0;
22833 PyErr_Clear();
22834 } else {
22835 _v = (ptr != 0);
22836 }
22837 }
22838 if (_v) {
22839 return _wrap_DateTime___add____SWIG_0(self,args);
22840 }
22841 }
22842 }
22843 if (argc == 2) {
22844 int _v;
22845 {
22846 void *ptr;
22847 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22848 _v = 0;
22849 PyErr_Clear();
22850 } else {
22851 _v = 1;
22852 }
22853 }
22854 if (_v) {
22855 {
22856 void *ptr = 0;
22857 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22858 _v = 0;
22859 PyErr_Clear();
22860 } else {
22861 _v = (ptr != 0);
22862 }
22863 }
22864 if (_v) {
22865 return _wrap_DateTime___add____SWIG_1(self,args);
22866 }
22867 }
22868 }
22869
22870 Py_INCREF(Py_NotImplemented);
22871 return Py_NotImplemented;
22872 }
22873
22874
22875 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22876 PyObject *resultobj;
22877 wxDateTime *arg1 = (wxDateTime *) 0 ;
22878 wxDateTime *arg2 = 0 ;
22879 wxTimeSpan result;
22880 PyObject * obj0 = 0 ;
22881 PyObject * obj1 = 0 ;
22882
22883 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22885 if (SWIG_arg_fail(1)) SWIG_fail;
22886 {
22887 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22888 if (SWIG_arg_fail(2)) SWIG_fail;
22889 if (arg2 == NULL) {
22890 SWIG_null_ref("wxDateTime");
22891 }
22892 if (SWIG_arg_fail(2)) SWIG_fail;
22893 }
22894 {
22895 PyThreadState* __tstate = wxPyBeginAllowThreads();
22896 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22897
22898 wxPyEndAllowThreads(__tstate);
22899 if (PyErr_Occurred()) SWIG_fail;
22900 }
22901 {
22902 wxTimeSpan * resultptr;
22903 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22904 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22905 }
22906 return resultobj;
22907 fail:
22908 return NULL;
22909 }
22910
22911
22912 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22913 PyObject *resultobj;
22914 wxDateTime *arg1 = (wxDateTime *) 0 ;
22915 wxTimeSpan *arg2 = 0 ;
22916 wxDateTime result;
22917 PyObject * obj0 = 0 ;
22918 PyObject * obj1 = 0 ;
22919
22920 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22922 if (SWIG_arg_fail(1)) SWIG_fail;
22923 {
22924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22925 if (SWIG_arg_fail(2)) SWIG_fail;
22926 if (arg2 == NULL) {
22927 SWIG_null_ref("wxTimeSpan");
22928 }
22929 if (SWIG_arg_fail(2)) SWIG_fail;
22930 }
22931 {
22932 PyThreadState* __tstate = wxPyBeginAllowThreads();
22933 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22934
22935 wxPyEndAllowThreads(__tstate);
22936 if (PyErr_Occurred()) SWIG_fail;
22937 }
22938 {
22939 wxDateTime * resultptr;
22940 resultptr = new wxDateTime((wxDateTime &)(result));
22941 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22942 }
22943 return resultobj;
22944 fail:
22945 return NULL;
22946 }
22947
22948
22949 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22950 PyObject *resultobj;
22951 wxDateTime *arg1 = (wxDateTime *) 0 ;
22952 wxDateSpan *arg2 = 0 ;
22953 wxDateTime result;
22954 PyObject * obj0 = 0 ;
22955 PyObject * obj1 = 0 ;
22956
22957 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22959 if (SWIG_arg_fail(1)) SWIG_fail;
22960 {
22961 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22962 if (SWIG_arg_fail(2)) SWIG_fail;
22963 if (arg2 == NULL) {
22964 SWIG_null_ref("wxDateSpan");
22965 }
22966 if (SWIG_arg_fail(2)) SWIG_fail;
22967 }
22968 {
22969 PyThreadState* __tstate = wxPyBeginAllowThreads();
22970 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22971
22972 wxPyEndAllowThreads(__tstate);
22973 if (PyErr_Occurred()) SWIG_fail;
22974 }
22975 {
22976 wxDateTime * resultptr;
22977 resultptr = new wxDateTime((wxDateTime &)(result));
22978 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22979 }
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22987 int argc;
22988 PyObject *argv[3];
22989 int ii;
22990
22991 argc = PyObject_Length(args);
22992 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22993 argv[ii] = PyTuple_GetItem(args,ii);
22994 }
22995 if (argc == 2) {
22996 int _v;
22997 {
22998 void *ptr;
22999 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23000 _v = 0;
23001 PyErr_Clear();
23002 } else {
23003 _v = 1;
23004 }
23005 }
23006 if (_v) {
23007 {
23008 void *ptr = 0;
23009 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23010 _v = 0;
23011 PyErr_Clear();
23012 } else {
23013 _v = (ptr != 0);
23014 }
23015 }
23016 if (_v) {
23017 return _wrap_DateTime___sub____SWIG_0(self,args);
23018 }
23019 }
23020 }
23021 if (argc == 2) {
23022 int _v;
23023 {
23024 void *ptr;
23025 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23026 _v = 0;
23027 PyErr_Clear();
23028 } else {
23029 _v = 1;
23030 }
23031 }
23032 if (_v) {
23033 {
23034 void *ptr = 0;
23035 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23036 _v = 0;
23037 PyErr_Clear();
23038 } else {
23039 _v = (ptr != 0);
23040 }
23041 }
23042 if (_v) {
23043 return _wrap_DateTime___sub____SWIG_1(self,args);
23044 }
23045 }
23046 }
23047 if (argc == 2) {
23048 int _v;
23049 {
23050 void *ptr;
23051 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23052 _v = 0;
23053 PyErr_Clear();
23054 } else {
23055 _v = 1;
23056 }
23057 }
23058 if (_v) {
23059 {
23060 void *ptr = 0;
23061 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23062 _v = 0;
23063 PyErr_Clear();
23064 } else {
23065 _v = (ptr != 0);
23066 }
23067 }
23068 if (_v) {
23069 return _wrap_DateTime___sub____SWIG_2(self,args);
23070 }
23071 }
23072 }
23073
23074 Py_INCREF(Py_NotImplemented);
23075 return Py_NotImplemented;
23076 }
23077
23078
23079 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args) {
23080 PyObject *resultobj;
23081 wxDateTime *arg1 = (wxDateTime *) 0 ;
23082 wxDateTime *arg2 = (wxDateTime *) 0 ;
23083 bool result;
23084 PyObject * obj0 = 0 ;
23085 PyObject * obj1 = 0 ;
23086
23087 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___lt__",&obj0,&obj1)) goto fail;
23088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23089 if (SWIG_arg_fail(1)) SWIG_fail;
23090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23091 if (SWIG_arg_fail(2)) SWIG_fail;
23092 {
23093 PyThreadState* __tstate = wxPyBeginAllowThreads();
23094 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23095
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 {
23100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23101 }
23102 return resultobj;
23103 fail:
23104 return NULL;
23105 }
23106
23107
23108 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args) {
23109 PyObject *resultobj;
23110 wxDateTime *arg1 = (wxDateTime *) 0 ;
23111 wxDateTime *arg2 = (wxDateTime *) 0 ;
23112 bool result;
23113 PyObject * obj0 = 0 ;
23114 PyObject * obj1 = 0 ;
23115
23116 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___le__",&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) {
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
23145 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___gt__",&obj0,&obj1)) goto fail;
23146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23147 if (SWIG_arg_fail(1)) SWIG_fail;
23148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23149 if (SWIG_arg_fail(2)) SWIG_fail;
23150 {
23151 PyThreadState* __tstate = wxPyBeginAllowThreads();
23152 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23153
23154 wxPyEndAllowThreads(__tstate);
23155 if (PyErr_Occurred()) SWIG_fail;
23156 }
23157 {
23158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23159 }
23160 return resultobj;
23161 fail:
23162 return NULL;
23163 }
23164
23165
23166 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args) {
23167 PyObject *resultobj;
23168 wxDateTime *arg1 = (wxDateTime *) 0 ;
23169 wxDateTime *arg2 = (wxDateTime *) 0 ;
23170 bool result;
23171 PyObject * obj0 = 0 ;
23172 PyObject * obj1 = 0 ;
23173
23174 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ge__",&obj0,&obj1)) goto fail;
23175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23176 if (SWIG_arg_fail(1)) SWIG_fail;
23177 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23178 if (SWIG_arg_fail(2)) SWIG_fail;
23179 {
23180 PyThreadState* __tstate = wxPyBeginAllowThreads();
23181 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23182
23183 wxPyEndAllowThreads(__tstate);
23184 if (PyErr_Occurred()) SWIG_fail;
23185 }
23186 {
23187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23188 }
23189 return resultobj;
23190 fail:
23191 return NULL;
23192 }
23193
23194
23195 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args) {
23196 PyObject *resultobj;
23197 wxDateTime *arg1 = (wxDateTime *) 0 ;
23198 wxDateTime *arg2 = (wxDateTime *) 0 ;
23199 bool result;
23200 PyObject * obj0 = 0 ;
23201 PyObject * obj1 = 0 ;
23202
23203 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___eq__",&obj0,&obj1)) goto fail;
23204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23205 if (SWIG_arg_fail(1)) SWIG_fail;
23206 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23207 if (SWIG_arg_fail(2)) SWIG_fail;
23208 {
23209 PyThreadState* __tstate = wxPyBeginAllowThreads();
23210 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23211
23212 wxPyEndAllowThreads(__tstate);
23213 if (PyErr_Occurred()) SWIG_fail;
23214 }
23215 {
23216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23217 }
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args) {
23225 PyObject *resultobj;
23226 wxDateTime *arg1 = (wxDateTime *) 0 ;
23227 wxDateTime *arg2 = (wxDateTime *) 0 ;
23228 bool result;
23229 PyObject * obj0 = 0 ;
23230 PyObject * obj1 = 0 ;
23231
23232 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ne__",&obj0,&obj1)) goto fail;
23233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23234 if (SWIG_arg_fail(1)) SWIG_fail;
23235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23236 if (SWIG_arg_fail(2)) SWIG_fail;
23237 {
23238 PyThreadState* __tstate = wxPyBeginAllowThreads();
23239 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23240
23241 wxPyEndAllowThreads(__tstate);
23242 if (PyErr_Occurred()) SWIG_fail;
23243 }
23244 {
23245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23246 }
23247 return resultobj;
23248 fail:
23249 return NULL;
23250 }
23251
23252
23253 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23254 PyObject *resultobj;
23255 wxDateTime *arg1 = (wxDateTime *) 0 ;
23256 wxString *arg2 = 0 ;
23257 int result;
23258 bool temp2 = false ;
23259 PyObject * obj0 = 0 ;
23260 PyObject * obj1 = 0 ;
23261 char *kwnames[] = {
23262 (char *) "self",(char *) "date", NULL
23263 };
23264
23265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23267 if (SWIG_arg_fail(1)) SWIG_fail;
23268 {
23269 arg2 = wxString_in_helper(obj1);
23270 if (arg2 == NULL) SWIG_fail;
23271 temp2 = true;
23272 }
23273 {
23274 PyThreadState* __tstate = wxPyBeginAllowThreads();
23275 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23276
23277 wxPyEndAllowThreads(__tstate);
23278 if (PyErr_Occurred()) SWIG_fail;
23279 }
23280 {
23281 resultobj = SWIG_From_int((int)(result));
23282 }
23283 {
23284 if (temp2)
23285 delete arg2;
23286 }
23287 return resultobj;
23288 fail:
23289 {
23290 if (temp2)
23291 delete arg2;
23292 }
23293 return NULL;
23294 }
23295
23296
23297 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23298 PyObject *resultobj;
23299 wxDateTime *arg1 = (wxDateTime *) 0 ;
23300 wxString *arg2 = 0 ;
23301 wxString const &arg3_defvalue = wxPyDateFormatStr ;
23302 wxString *arg3 = (wxString *) &arg3_defvalue ;
23303 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23304 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23305 int result;
23306 bool temp2 = false ;
23307 bool temp3 = false ;
23308 PyObject * obj0 = 0 ;
23309 PyObject * obj1 = 0 ;
23310 PyObject * obj2 = 0 ;
23311 PyObject * obj3 = 0 ;
23312 char *kwnames[] = {
23313 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23314 };
23315
23316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23318 if (SWIG_arg_fail(1)) SWIG_fail;
23319 {
23320 arg2 = wxString_in_helper(obj1);
23321 if (arg2 == NULL) SWIG_fail;
23322 temp2 = true;
23323 }
23324 if (obj2) {
23325 {
23326 arg3 = wxString_in_helper(obj2);
23327 if (arg3 == NULL) SWIG_fail;
23328 temp3 = true;
23329 }
23330 }
23331 if (obj3) {
23332 {
23333 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23334 if (SWIG_arg_fail(4)) SWIG_fail;
23335 if (arg4 == NULL) {
23336 SWIG_null_ref("wxDateTime");
23337 }
23338 if (SWIG_arg_fail(4)) SWIG_fail;
23339 }
23340 }
23341 {
23342 PyThreadState* __tstate = wxPyBeginAllowThreads();
23343 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23344
23345 wxPyEndAllowThreads(__tstate);
23346 if (PyErr_Occurred()) SWIG_fail;
23347 }
23348 {
23349 resultobj = SWIG_From_int((int)(result));
23350 }
23351 {
23352 if (temp2)
23353 delete arg2;
23354 }
23355 {
23356 if (temp3)
23357 delete arg3;
23358 }
23359 return resultobj;
23360 fail:
23361 {
23362 if (temp2)
23363 delete arg2;
23364 }
23365 {
23366 if (temp3)
23367 delete arg3;
23368 }
23369 return NULL;
23370 }
23371
23372
23373 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23374 PyObject *resultobj;
23375 wxDateTime *arg1 = (wxDateTime *) 0 ;
23376 wxString *arg2 = 0 ;
23377 int result;
23378 bool temp2 = false ;
23379 PyObject * obj0 = 0 ;
23380 PyObject * obj1 = 0 ;
23381 char *kwnames[] = {
23382 (char *) "self",(char *) "datetime", NULL
23383 };
23384
23385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23387 if (SWIG_arg_fail(1)) SWIG_fail;
23388 {
23389 arg2 = wxString_in_helper(obj1);
23390 if (arg2 == NULL) SWIG_fail;
23391 temp2 = true;
23392 }
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23396
23397 wxPyEndAllowThreads(__tstate);
23398 if (PyErr_Occurred()) SWIG_fail;
23399 }
23400 {
23401 resultobj = SWIG_From_int((int)(result));
23402 }
23403 {
23404 if (temp2)
23405 delete arg2;
23406 }
23407 return resultobj;
23408 fail:
23409 {
23410 if (temp2)
23411 delete arg2;
23412 }
23413 return NULL;
23414 }
23415
23416
23417 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj;
23419 wxDateTime *arg1 = (wxDateTime *) 0 ;
23420 wxString *arg2 = 0 ;
23421 int result;
23422 bool temp2 = false ;
23423 PyObject * obj0 = 0 ;
23424 PyObject * obj1 = 0 ;
23425 char *kwnames[] = {
23426 (char *) "self",(char *) "date", NULL
23427 };
23428
23429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23431 if (SWIG_arg_fail(1)) SWIG_fail;
23432 {
23433 arg2 = wxString_in_helper(obj1);
23434 if (arg2 == NULL) SWIG_fail;
23435 temp2 = true;
23436 }
23437 {
23438 PyThreadState* __tstate = wxPyBeginAllowThreads();
23439 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23440
23441 wxPyEndAllowThreads(__tstate);
23442 if (PyErr_Occurred()) SWIG_fail;
23443 }
23444 {
23445 resultobj = SWIG_From_int((int)(result));
23446 }
23447 {
23448 if (temp2)
23449 delete arg2;
23450 }
23451 return resultobj;
23452 fail:
23453 {
23454 if (temp2)
23455 delete arg2;
23456 }
23457 return NULL;
23458 }
23459
23460
23461 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23462 PyObject *resultobj;
23463 wxDateTime *arg1 = (wxDateTime *) 0 ;
23464 wxString *arg2 = 0 ;
23465 int result;
23466 bool temp2 = false ;
23467 PyObject * obj0 = 0 ;
23468 PyObject * obj1 = 0 ;
23469 char *kwnames[] = {
23470 (char *) "self",(char *) "time", NULL
23471 };
23472
23473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23475 if (SWIG_arg_fail(1)) SWIG_fail;
23476 {
23477 arg2 = wxString_in_helper(obj1);
23478 if (arg2 == NULL) SWIG_fail;
23479 temp2 = true;
23480 }
23481 {
23482 PyThreadState* __tstate = wxPyBeginAllowThreads();
23483 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23484
23485 wxPyEndAllowThreads(__tstate);
23486 if (PyErr_Occurred()) SWIG_fail;
23487 }
23488 {
23489 resultobj = SWIG_From_int((int)(result));
23490 }
23491 {
23492 if (temp2)
23493 delete arg2;
23494 }
23495 return resultobj;
23496 fail:
23497 {
23498 if (temp2)
23499 delete arg2;
23500 }
23501 return NULL;
23502 }
23503
23504
23505 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23506 PyObject *resultobj;
23507 wxDateTime *arg1 = (wxDateTime *) 0 ;
23508 wxString const &arg2_defvalue = wxPyDateFormatStr ;
23509 wxString *arg2 = (wxString *) &arg2_defvalue ;
23510 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23511 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23512 wxString result;
23513 bool temp2 = false ;
23514 bool temp3 = false ;
23515 PyObject * obj0 = 0 ;
23516 PyObject * obj1 = 0 ;
23517 PyObject * obj2 = 0 ;
23518 char *kwnames[] = {
23519 (char *) "self",(char *) "format",(char *) "tz", NULL
23520 };
23521
23522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23524 if (SWIG_arg_fail(1)) SWIG_fail;
23525 if (obj1) {
23526 {
23527 arg2 = wxString_in_helper(obj1);
23528 if (arg2 == NULL) SWIG_fail;
23529 temp2 = true;
23530 }
23531 }
23532 if (obj2) {
23533 {
23534 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23535 temp3 = true;
23536 }
23537 }
23538 {
23539 PyThreadState* __tstate = wxPyBeginAllowThreads();
23540 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23541
23542 wxPyEndAllowThreads(__tstate);
23543 if (PyErr_Occurred()) SWIG_fail;
23544 }
23545 {
23546 #if wxUSE_UNICODE
23547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23548 #else
23549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23550 #endif
23551 }
23552 {
23553 if (temp2)
23554 delete arg2;
23555 }
23556 {
23557 if (temp3) delete arg3;
23558 }
23559 return resultobj;
23560 fail:
23561 {
23562 if (temp2)
23563 delete arg2;
23564 }
23565 {
23566 if (temp3) delete arg3;
23567 }
23568 return NULL;
23569 }
23570
23571
23572 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23573 PyObject *resultobj;
23574 wxDateTime *arg1 = (wxDateTime *) 0 ;
23575 wxString result;
23576 PyObject * obj0 = 0 ;
23577 char *kwnames[] = {
23578 (char *) "self", NULL
23579 };
23580
23581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23583 if (SWIG_arg_fail(1)) SWIG_fail;
23584 {
23585 PyThreadState* __tstate = wxPyBeginAllowThreads();
23586 result = ((wxDateTime const *)arg1)->FormatDate();
23587
23588 wxPyEndAllowThreads(__tstate);
23589 if (PyErr_Occurred()) SWIG_fail;
23590 }
23591 {
23592 #if wxUSE_UNICODE
23593 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23594 #else
23595 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23596 #endif
23597 }
23598 return resultobj;
23599 fail:
23600 return NULL;
23601 }
23602
23603
23604 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23605 PyObject *resultobj;
23606 wxDateTime *arg1 = (wxDateTime *) 0 ;
23607 wxString result;
23608 PyObject * obj0 = 0 ;
23609 char *kwnames[] = {
23610 (char *) "self", NULL
23611 };
23612
23613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23615 if (SWIG_arg_fail(1)) SWIG_fail;
23616 {
23617 PyThreadState* __tstate = wxPyBeginAllowThreads();
23618 result = ((wxDateTime const *)arg1)->FormatTime();
23619
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 {
23624 #if wxUSE_UNICODE
23625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23626 #else
23627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23628 #endif
23629 }
23630 return resultobj;
23631 fail:
23632 return NULL;
23633 }
23634
23635
23636 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23637 PyObject *resultobj;
23638 wxDateTime *arg1 = (wxDateTime *) 0 ;
23639 wxString result;
23640 PyObject * obj0 = 0 ;
23641 char *kwnames[] = {
23642 (char *) "self", NULL
23643 };
23644
23645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23647 if (SWIG_arg_fail(1)) SWIG_fail;
23648 {
23649 PyThreadState* __tstate = wxPyBeginAllowThreads();
23650 result = ((wxDateTime const *)arg1)->FormatISODate();
23651
23652 wxPyEndAllowThreads(__tstate);
23653 if (PyErr_Occurred()) SWIG_fail;
23654 }
23655 {
23656 #if wxUSE_UNICODE
23657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23658 #else
23659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23660 #endif
23661 }
23662 return resultobj;
23663 fail:
23664 return NULL;
23665 }
23666
23667
23668 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23669 PyObject *resultobj;
23670 wxDateTime *arg1 = (wxDateTime *) 0 ;
23671 wxString result;
23672 PyObject * obj0 = 0 ;
23673 char *kwnames[] = {
23674 (char *) "self", NULL
23675 };
23676
23677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23679 if (SWIG_arg_fail(1)) SWIG_fail;
23680 {
23681 PyThreadState* __tstate = wxPyBeginAllowThreads();
23682 result = ((wxDateTime const *)arg1)->FormatISOTime();
23683
23684 wxPyEndAllowThreads(__tstate);
23685 if (PyErr_Occurred()) SWIG_fail;
23686 }
23687 {
23688 #if wxUSE_UNICODE
23689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23690 #else
23691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23692 #endif
23693 }
23694 return resultobj;
23695 fail:
23696 return NULL;
23697 }
23698
23699
23700 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23701 PyObject *obj;
23702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23703 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23704 Py_INCREF(obj);
23705 return Py_BuildValue((char *)"");
23706 }
23707 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23708 PyObject *resultobj;
23709 long arg1 ;
23710 wxTimeSpan result;
23711 PyObject * obj0 = 0 ;
23712 char *kwnames[] = {
23713 (char *) "sec", NULL
23714 };
23715
23716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23717 {
23718 arg1 = (long)(SWIG_As_long(obj0));
23719 if (SWIG_arg_fail(1)) SWIG_fail;
23720 }
23721 {
23722 PyThreadState* __tstate = wxPyBeginAllowThreads();
23723 result = wxTimeSpan::Seconds(arg1);
23724
23725 wxPyEndAllowThreads(__tstate);
23726 if (PyErr_Occurred()) SWIG_fail;
23727 }
23728 {
23729 wxTimeSpan * resultptr;
23730 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23731 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23732 }
23733 return resultobj;
23734 fail:
23735 return NULL;
23736 }
23737
23738
23739 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23740 PyObject *resultobj;
23741 wxTimeSpan result;
23742 char *kwnames[] = {
23743 NULL
23744 };
23745
23746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23747 {
23748 PyThreadState* __tstate = wxPyBeginAllowThreads();
23749 result = wxTimeSpan::Second();
23750
23751 wxPyEndAllowThreads(__tstate);
23752 if (PyErr_Occurred()) SWIG_fail;
23753 }
23754 {
23755 wxTimeSpan * resultptr;
23756 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23757 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23758 }
23759 return resultobj;
23760 fail:
23761 return NULL;
23762 }
23763
23764
23765 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23766 PyObject *resultobj;
23767 long arg1 ;
23768 wxTimeSpan result;
23769 PyObject * obj0 = 0 ;
23770 char *kwnames[] = {
23771 (char *) "min", NULL
23772 };
23773
23774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23775 {
23776 arg1 = (long)(SWIG_As_long(obj0));
23777 if (SWIG_arg_fail(1)) SWIG_fail;
23778 }
23779 {
23780 PyThreadState* __tstate = wxPyBeginAllowThreads();
23781 result = wxTimeSpan::Minutes(arg1);
23782
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 {
23787 wxTimeSpan * resultptr;
23788 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23790 }
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23798 PyObject *resultobj;
23799 wxTimeSpan result;
23800 char *kwnames[] = {
23801 NULL
23802 };
23803
23804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23805 {
23806 PyThreadState* __tstate = wxPyBeginAllowThreads();
23807 result = wxTimeSpan::Minute();
23808
23809 wxPyEndAllowThreads(__tstate);
23810 if (PyErr_Occurred()) SWIG_fail;
23811 }
23812 {
23813 wxTimeSpan * resultptr;
23814 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23815 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23816 }
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23824 PyObject *resultobj;
23825 long arg1 ;
23826 wxTimeSpan result;
23827 PyObject * obj0 = 0 ;
23828 char *kwnames[] = {
23829 (char *) "hours", NULL
23830 };
23831
23832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23833 {
23834 arg1 = (long)(SWIG_As_long(obj0));
23835 if (SWIG_arg_fail(1)) SWIG_fail;
23836 }
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = wxTimeSpan::Hours(arg1);
23840
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 {
23845 wxTimeSpan * resultptr;
23846 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23848 }
23849 return resultobj;
23850 fail:
23851 return NULL;
23852 }
23853
23854
23855 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23856 PyObject *resultobj;
23857 wxTimeSpan result;
23858 char *kwnames[] = {
23859 NULL
23860 };
23861
23862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23863 {
23864 PyThreadState* __tstate = wxPyBeginAllowThreads();
23865 result = wxTimeSpan::Hour();
23866
23867 wxPyEndAllowThreads(__tstate);
23868 if (PyErr_Occurred()) SWIG_fail;
23869 }
23870 {
23871 wxTimeSpan * resultptr;
23872 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23874 }
23875 return resultobj;
23876 fail:
23877 return NULL;
23878 }
23879
23880
23881 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23882 PyObject *resultobj;
23883 long arg1 ;
23884 wxTimeSpan result;
23885 PyObject * obj0 = 0 ;
23886 char *kwnames[] = {
23887 (char *) "days", NULL
23888 };
23889
23890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23891 {
23892 arg1 = (long)(SWIG_As_long(obj0));
23893 if (SWIG_arg_fail(1)) SWIG_fail;
23894 }
23895 {
23896 PyThreadState* __tstate = wxPyBeginAllowThreads();
23897 result = wxTimeSpan::Days(arg1);
23898
23899 wxPyEndAllowThreads(__tstate);
23900 if (PyErr_Occurred()) SWIG_fail;
23901 }
23902 {
23903 wxTimeSpan * resultptr;
23904 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23905 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23906 }
23907 return resultobj;
23908 fail:
23909 return NULL;
23910 }
23911
23912
23913 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23914 PyObject *resultobj;
23915 wxTimeSpan result;
23916 char *kwnames[] = {
23917 NULL
23918 };
23919
23920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23921 {
23922 PyThreadState* __tstate = wxPyBeginAllowThreads();
23923 result = wxTimeSpan::Day();
23924
23925 wxPyEndAllowThreads(__tstate);
23926 if (PyErr_Occurred()) SWIG_fail;
23927 }
23928 {
23929 wxTimeSpan * resultptr;
23930 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23932 }
23933 return resultobj;
23934 fail:
23935 return NULL;
23936 }
23937
23938
23939 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23940 PyObject *resultobj;
23941 long arg1 ;
23942 wxTimeSpan result;
23943 PyObject * obj0 = 0 ;
23944 char *kwnames[] = {
23945 (char *) "days", NULL
23946 };
23947
23948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23949 {
23950 arg1 = (long)(SWIG_As_long(obj0));
23951 if (SWIG_arg_fail(1)) SWIG_fail;
23952 }
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 result = wxTimeSpan::Weeks(arg1);
23956
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 {
23961 wxTimeSpan * resultptr;
23962 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23963 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23964 }
23965 return resultobj;
23966 fail:
23967 return NULL;
23968 }
23969
23970
23971 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23972 PyObject *resultobj;
23973 wxTimeSpan result;
23974 char *kwnames[] = {
23975 NULL
23976 };
23977
23978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23979 {
23980 PyThreadState* __tstate = wxPyBeginAllowThreads();
23981 result = wxTimeSpan::Week();
23982
23983 wxPyEndAllowThreads(__tstate);
23984 if (PyErr_Occurred()) SWIG_fail;
23985 }
23986 {
23987 wxTimeSpan * resultptr;
23988 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23990 }
23991 return resultobj;
23992 fail:
23993 return NULL;
23994 }
23995
23996
23997 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23998 PyObject *resultobj;
23999 long arg1 = (long) 0 ;
24000 long arg2 = (long) 0 ;
24001 long arg3 = (long) 0 ;
24002 long arg4 = (long) 0 ;
24003 wxTimeSpan *result;
24004 PyObject * obj0 = 0 ;
24005 PyObject * obj1 = 0 ;
24006 PyObject * obj2 = 0 ;
24007 PyObject * obj3 = 0 ;
24008 char *kwnames[] = {
24009 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24010 };
24011
24012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24013 if (obj0) {
24014 {
24015 arg1 = (long)(SWIG_As_long(obj0));
24016 if (SWIG_arg_fail(1)) SWIG_fail;
24017 }
24018 }
24019 if (obj1) {
24020 {
24021 arg2 = (long)(SWIG_As_long(obj1));
24022 if (SWIG_arg_fail(2)) SWIG_fail;
24023 }
24024 }
24025 if (obj2) {
24026 {
24027 arg3 = (long)(SWIG_As_long(obj2));
24028 if (SWIG_arg_fail(3)) SWIG_fail;
24029 }
24030 }
24031 if (obj3) {
24032 {
24033 arg4 = (long)(SWIG_As_long(obj3));
24034 if (SWIG_arg_fail(4)) SWIG_fail;
24035 }
24036 }
24037 {
24038 PyThreadState* __tstate = wxPyBeginAllowThreads();
24039 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24040
24041 wxPyEndAllowThreads(__tstate);
24042 if (PyErr_Occurred()) SWIG_fail;
24043 }
24044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24045 return resultobj;
24046 fail:
24047 return NULL;
24048 }
24049
24050
24051 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24052 PyObject *resultobj;
24053 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24054 PyObject * obj0 = 0 ;
24055 char *kwnames[] = {
24056 (char *) "self", NULL
24057 };
24058
24059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24061 if (SWIG_arg_fail(1)) SWIG_fail;
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 delete arg1;
24065
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 Py_INCREF(Py_None); resultobj = Py_None;
24070 return resultobj;
24071 fail:
24072 return NULL;
24073 }
24074
24075
24076 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24077 PyObject *resultobj;
24078 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24079 wxTimeSpan *arg2 = 0 ;
24080 wxTimeSpan *result;
24081 PyObject * obj0 = 0 ;
24082 PyObject * obj1 = 0 ;
24083 char *kwnames[] = {
24084 (char *) "self",(char *) "diff", NULL
24085 };
24086
24087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24089 if (SWIG_arg_fail(1)) SWIG_fail;
24090 {
24091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24092 if (SWIG_arg_fail(2)) SWIG_fail;
24093 if (arg2 == NULL) {
24094 SWIG_null_ref("wxTimeSpan");
24095 }
24096 if (SWIG_arg_fail(2)) SWIG_fail;
24097 }
24098 {
24099 PyThreadState* __tstate = wxPyBeginAllowThreads();
24100 {
24101 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24102 result = (wxTimeSpan *) &_result_ref;
24103 }
24104
24105 wxPyEndAllowThreads(__tstate);
24106 if (PyErr_Occurred()) SWIG_fail;
24107 }
24108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24116 PyObject *resultobj;
24117 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24118 wxTimeSpan *arg2 = 0 ;
24119 wxTimeSpan *result;
24120 PyObject * obj0 = 0 ;
24121 PyObject * obj1 = 0 ;
24122 char *kwnames[] = {
24123 (char *) "self",(char *) "diff", NULL
24124 };
24125
24126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24128 if (SWIG_arg_fail(1)) SWIG_fail;
24129 {
24130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24131 if (SWIG_arg_fail(2)) SWIG_fail;
24132 if (arg2 == NULL) {
24133 SWIG_null_ref("wxTimeSpan");
24134 }
24135 if (SWIG_arg_fail(2)) SWIG_fail;
24136 }
24137 {
24138 PyThreadState* __tstate = wxPyBeginAllowThreads();
24139 {
24140 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24141 result = (wxTimeSpan *) &_result_ref;
24142 }
24143
24144 wxPyEndAllowThreads(__tstate);
24145 if (PyErr_Occurred()) SWIG_fail;
24146 }
24147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24148 return resultobj;
24149 fail:
24150 return NULL;
24151 }
24152
24153
24154 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24155 PyObject *resultobj;
24156 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24157 int arg2 ;
24158 wxTimeSpan *result;
24159 PyObject * obj0 = 0 ;
24160 PyObject * obj1 = 0 ;
24161 char *kwnames[] = {
24162 (char *) "self",(char *) "n", NULL
24163 };
24164
24165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24167 if (SWIG_arg_fail(1)) SWIG_fail;
24168 {
24169 arg2 = (int)(SWIG_As_int(obj1));
24170 if (SWIG_arg_fail(2)) SWIG_fail;
24171 }
24172 {
24173 PyThreadState* __tstate = wxPyBeginAllowThreads();
24174 {
24175 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24176 result = (wxTimeSpan *) &_result_ref;
24177 }
24178
24179 wxPyEndAllowThreads(__tstate);
24180 if (PyErr_Occurred()) SWIG_fail;
24181 }
24182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24183 return resultobj;
24184 fail:
24185 return NULL;
24186 }
24187
24188
24189 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24190 PyObject *resultobj;
24191 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24192 wxTimeSpan *result;
24193 PyObject * obj0 = 0 ;
24194 char *kwnames[] = {
24195 (char *) "self", NULL
24196 };
24197
24198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24200 if (SWIG_arg_fail(1)) SWIG_fail;
24201 {
24202 PyThreadState* __tstate = wxPyBeginAllowThreads();
24203 {
24204 wxTimeSpan &_result_ref = (arg1)->Neg();
24205 result = (wxTimeSpan *) &_result_ref;
24206 }
24207
24208 wxPyEndAllowThreads(__tstate);
24209 if (PyErr_Occurred()) SWIG_fail;
24210 }
24211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24212 return resultobj;
24213 fail:
24214 return NULL;
24215 }
24216
24217
24218 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24219 PyObject *resultobj;
24220 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24221 wxTimeSpan result;
24222 PyObject * obj0 = 0 ;
24223 char *kwnames[] = {
24224 (char *) "self", NULL
24225 };
24226
24227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24229 if (SWIG_arg_fail(1)) SWIG_fail;
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = ((wxTimeSpan const *)arg1)->Abs();
24233
24234 wxPyEndAllowThreads(__tstate);
24235 if (PyErr_Occurred()) SWIG_fail;
24236 }
24237 {
24238 wxTimeSpan * resultptr;
24239 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24241 }
24242 return resultobj;
24243 fail:
24244 return NULL;
24245 }
24246
24247
24248 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24249 PyObject *resultobj;
24250 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24251 wxTimeSpan *arg2 = 0 ;
24252 wxTimeSpan *result;
24253 PyObject * obj0 = 0 ;
24254 PyObject * obj1 = 0 ;
24255 char *kwnames[] = {
24256 (char *) "self",(char *) "diff", NULL
24257 };
24258
24259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24261 if (SWIG_arg_fail(1)) SWIG_fail;
24262 {
24263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24264 if (SWIG_arg_fail(2)) SWIG_fail;
24265 if (arg2 == NULL) {
24266 SWIG_null_ref("wxTimeSpan");
24267 }
24268 if (SWIG_arg_fail(2)) SWIG_fail;
24269 }
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 {
24273 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24274 result = (wxTimeSpan *) &_result_ref;
24275 }
24276
24277 wxPyEndAllowThreads(__tstate);
24278 if (PyErr_Occurred()) SWIG_fail;
24279 }
24280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24281 return resultobj;
24282 fail:
24283 return NULL;
24284 }
24285
24286
24287 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24288 PyObject *resultobj;
24289 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24290 wxTimeSpan *arg2 = 0 ;
24291 wxTimeSpan *result;
24292 PyObject * obj0 = 0 ;
24293 PyObject * obj1 = 0 ;
24294 char *kwnames[] = {
24295 (char *) "self",(char *) "diff", NULL
24296 };
24297
24298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24300 if (SWIG_arg_fail(1)) SWIG_fail;
24301 {
24302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24303 if (SWIG_arg_fail(2)) SWIG_fail;
24304 if (arg2 == NULL) {
24305 SWIG_null_ref("wxTimeSpan");
24306 }
24307 if (SWIG_arg_fail(2)) SWIG_fail;
24308 }
24309 {
24310 PyThreadState* __tstate = wxPyBeginAllowThreads();
24311 {
24312 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24313 result = (wxTimeSpan *) &_result_ref;
24314 }
24315
24316 wxPyEndAllowThreads(__tstate);
24317 if (PyErr_Occurred()) SWIG_fail;
24318 }
24319 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24320 return resultobj;
24321 fail:
24322 return NULL;
24323 }
24324
24325
24326 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24327 PyObject *resultobj;
24328 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24329 int arg2 ;
24330 wxTimeSpan *result;
24331 PyObject * obj0 = 0 ;
24332 PyObject * obj1 = 0 ;
24333 char *kwnames[] = {
24334 (char *) "self",(char *) "n", NULL
24335 };
24336
24337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24339 if (SWIG_arg_fail(1)) SWIG_fail;
24340 {
24341 arg2 = (int)(SWIG_As_int(obj1));
24342 if (SWIG_arg_fail(2)) SWIG_fail;
24343 }
24344 {
24345 PyThreadState* __tstate = wxPyBeginAllowThreads();
24346 {
24347 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24348 result = (wxTimeSpan *) &_result_ref;
24349 }
24350
24351 wxPyEndAllowThreads(__tstate);
24352 if (PyErr_Occurred()) SWIG_fail;
24353 }
24354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24355 return resultobj;
24356 fail:
24357 return NULL;
24358 }
24359
24360
24361 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24362 PyObject *resultobj;
24363 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24364 wxTimeSpan *result;
24365 PyObject * obj0 = 0 ;
24366 char *kwnames[] = {
24367 (char *) "self", NULL
24368 };
24369
24370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24372 if (SWIG_arg_fail(1)) SWIG_fail;
24373 {
24374 PyThreadState* __tstate = wxPyBeginAllowThreads();
24375 {
24376 wxTimeSpan &_result_ref = (arg1)->operator -();
24377 result = (wxTimeSpan *) &_result_ref;
24378 }
24379
24380 wxPyEndAllowThreads(__tstate);
24381 if (PyErr_Occurred()) SWIG_fail;
24382 }
24383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24384 return resultobj;
24385 fail:
24386 return NULL;
24387 }
24388
24389
24390 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24391 PyObject *resultobj;
24392 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24393 wxTimeSpan *arg2 = 0 ;
24394 wxTimeSpan result;
24395 PyObject * obj0 = 0 ;
24396 PyObject * obj1 = 0 ;
24397 char *kwnames[] = {
24398 (char *) "self",(char *) "other", NULL
24399 };
24400
24401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24403 if (SWIG_arg_fail(1)) SWIG_fail;
24404 {
24405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24406 if (SWIG_arg_fail(2)) SWIG_fail;
24407 if (arg2 == NULL) {
24408 SWIG_null_ref("wxTimeSpan");
24409 }
24410 if (SWIG_arg_fail(2)) SWIG_fail;
24411 }
24412 {
24413 PyThreadState* __tstate = wxPyBeginAllowThreads();
24414 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24415
24416 wxPyEndAllowThreads(__tstate);
24417 if (PyErr_Occurred()) SWIG_fail;
24418 }
24419 {
24420 wxTimeSpan * resultptr;
24421 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24422 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24423 }
24424 return resultobj;
24425 fail:
24426 return NULL;
24427 }
24428
24429
24430 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24431 PyObject *resultobj;
24432 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24433 wxTimeSpan *arg2 = 0 ;
24434 wxTimeSpan result;
24435 PyObject * obj0 = 0 ;
24436 PyObject * obj1 = 0 ;
24437 char *kwnames[] = {
24438 (char *) "self",(char *) "other", NULL
24439 };
24440
24441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24443 if (SWIG_arg_fail(1)) SWIG_fail;
24444 {
24445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24446 if (SWIG_arg_fail(2)) SWIG_fail;
24447 if (arg2 == NULL) {
24448 SWIG_null_ref("wxTimeSpan");
24449 }
24450 if (SWIG_arg_fail(2)) SWIG_fail;
24451 }
24452 {
24453 PyThreadState* __tstate = wxPyBeginAllowThreads();
24454 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24455
24456 wxPyEndAllowThreads(__tstate);
24457 if (PyErr_Occurred()) SWIG_fail;
24458 }
24459 {
24460 wxTimeSpan * resultptr;
24461 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24463 }
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24471 PyObject *resultobj;
24472 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24473 int arg2 ;
24474 wxTimeSpan result;
24475 PyObject * obj0 = 0 ;
24476 PyObject * obj1 = 0 ;
24477 char *kwnames[] = {
24478 (char *) "self",(char *) "n", NULL
24479 };
24480
24481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24483 if (SWIG_arg_fail(1)) SWIG_fail;
24484 {
24485 arg2 = (int)(SWIG_As_int(obj1));
24486 if (SWIG_arg_fail(2)) SWIG_fail;
24487 }
24488 {
24489 PyThreadState* __tstate = wxPyBeginAllowThreads();
24490 result = wxTimeSpan___mul__(arg1,arg2);
24491
24492 wxPyEndAllowThreads(__tstate);
24493 if (PyErr_Occurred()) SWIG_fail;
24494 }
24495 {
24496 wxTimeSpan * resultptr;
24497 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24498 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24499 }
24500 return resultobj;
24501 fail:
24502 return NULL;
24503 }
24504
24505
24506 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24507 PyObject *resultobj;
24508 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24509 int arg2 ;
24510 wxTimeSpan result;
24511 PyObject * obj0 = 0 ;
24512 PyObject * obj1 = 0 ;
24513 char *kwnames[] = {
24514 (char *) "self",(char *) "n", NULL
24515 };
24516
24517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24519 if (SWIG_arg_fail(1)) SWIG_fail;
24520 {
24521 arg2 = (int)(SWIG_As_int(obj1));
24522 if (SWIG_arg_fail(2)) SWIG_fail;
24523 }
24524 {
24525 PyThreadState* __tstate = wxPyBeginAllowThreads();
24526 result = wxTimeSpan___rmul__(arg1,arg2);
24527
24528 wxPyEndAllowThreads(__tstate);
24529 if (PyErr_Occurred()) SWIG_fail;
24530 }
24531 {
24532 wxTimeSpan * resultptr;
24533 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24534 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24535 }
24536 return resultobj;
24537 fail:
24538 return NULL;
24539 }
24540
24541
24542 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24543 PyObject *resultobj;
24544 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24545 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24546 bool result;
24547 PyObject * obj0 = 0 ;
24548 PyObject * obj1 = 0 ;
24549 char *kwnames[] = {
24550 (char *) "self",(char *) "other", NULL
24551 };
24552
24553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24555 if (SWIG_arg_fail(1)) SWIG_fail;
24556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24557 if (SWIG_arg_fail(2)) SWIG_fail;
24558 {
24559 PyThreadState* __tstate = wxPyBeginAllowThreads();
24560 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24561
24562 wxPyEndAllowThreads(__tstate);
24563 if (PyErr_Occurred()) SWIG_fail;
24564 }
24565 {
24566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24567 }
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24575 PyObject *resultobj;
24576 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24577 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24578 bool result;
24579 PyObject * obj0 = 0 ;
24580 PyObject * obj1 = 0 ;
24581 char *kwnames[] = {
24582 (char *) "self",(char *) "other", NULL
24583 };
24584
24585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24587 if (SWIG_arg_fail(1)) SWIG_fail;
24588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24589 if (SWIG_arg_fail(2)) SWIG_fail;
24590 {
24591 PyThreadState* __tstate = wxPyBeginAllowThreads();
24592 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24593
24594 wxPyEndAllowThreads(__tstate);
24595 if (PyErr_Occurred()) SWIG_fail;
24596 }
24597 {
24598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24599 }
24600 return resultobj;
24601 fail:
24602 return NULL;
24603 }
24604
24605
24606 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24607 PyObject *resultobj;
24608 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24609 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24610 bool result;
24611 PyObject * obj0 = 0 ;
24612 PyObject * obj1 = 0 ;
24613 char *kwnames[] = {
24614 (char *) "self",(char *) "other", NULL
24615 };
24616
24617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24619 if (SWIG_arg_fail(1)) SWIG_fail;
24620 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24621 if (SWIG_arg_fail(2)) SWIG_fail;
24622 {
24623 PyThreadState* __tstate = wxPyBeginAllowThreads();
24624 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24625
24626 wxPyEndAllowThreads(__tstate);
24627 if (PyErr_Occurred()) SWIG_fail;
24628 }
24629 {
24630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24631 }
24632 return resultobj;
24633 fail:
24634 return NULL;
24635 }
24636
24637
24638 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24639 PyObject *resultobj;
24640 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24641 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24642 bool result;
24643 PyObject * obj0 = 0 ;
24644 PyObject * obj1 = 0 ;
24645 char *kwnames[] = {
24646 (char *) "self",(char *) "other", NULL
24647 };
24648
24649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24651 if (SWIG_arg_fail(1)) SWIG_fail;
24652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24653 if (SWIG_arg_fail(2)) SWIG_fail;
24654 {
24655 PyThreadState* __tstate = wxPyBeginAllowThreads();
24656 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24657
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 {
24662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24663 }
24664 return resultobj;
24665 fail:
24666 return NULL;
24667 }
24668
24669
24670 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24671 PyObject *resultobj;
24672 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24673 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24674 bool result;
24675 PyObject * obj0 = 0 ;
24676 PyObject * obj1 = 0 ;
24677 char *kwnames[] = {
24678 (char *) "self",(char *) "other", NULL
24679 };
24680
24681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24683 if (SWIG_arg_fail(1)) SWIG_fail;
24684 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24685 if (SWIG_arg_fail(2)) SWIG_fail;
24686 {
24687 PyThreadState* __tstate = wxPyBeginAllowThreads();
24688 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24689
24690 wxPyEndAllowThreads(__tstate);
24691 if (PyErr_Occurred()) SWIG_fail;
24692 }
24693 {
24694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24695 }
24696 return resultobj;
24697 fail:
24698 return NULL;
24699 }
24700
24701
24702 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24703 PyObject *resultobj;
24704 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24705 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24706 bool result;
24707 PyObject * obj0 = 0 ;
24708 PyObject * obj1 = 0 ;
24709 char *kwnames[] = {
24710 (char *) "self",(char *) "other", NULL
24711 };
24712
24713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24715 if (SWIG_arg_fail(1)) SWIG_fail;
24716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24717 if (SWIG_arg_fail(2)) SWIG_fail;
24718 {
24719 PyThreadState* __tstate = wxPyBeginAllowThreads();
24720 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24721
24722 wxPyEndAllowThreads(__tstate);
24723 if (PyErr_Occurred()) SWIG_fail;
24724 }
24725 {
24726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24727 }
24728 return resultobj;
24729 fail:
24730 return NULL;
24731 }
24732
24733
24734 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24735 PyObject *resultobj;
24736 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24737 bool result;
24738 PyObject * obj0 = 0 ;
24739 char *kwnames[] = {
24740 (char *) "self", NULL
24741 };
24742
24743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24745 if (SWIG_arg_fail(1)) SWIG_fail;
24746 {
24747 PyThreadState* __tstate = wxPyBeginAllowThreads();
24748 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24749
24750 wxPyEndAllowThreads(__tstate);
24751 if (PyErr_Occurred()) SWIG_fail;
24752 }
24753 {
24754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24755 }
24756 return resultobj;
24757 fail:
24758 return NULL;
24759 }
24760
24761
24762 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24763 PyObject *resultobj;
24764 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24765 bool result;
24766 PyObject * obj0 = 0 ;
24767 char *kwnames[] = {
24768 (char *) "self", NULL
24769 };
24770
24771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24773 if (SWIG_arg_fail(1)) SWIG_fail;
24774 {
24775 PyThreadState* __tstate = wxPyBeginAllowThreads();
24776 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24777
24778 wxPyEndAllowThreads(__tstate);
24779 if (PyErr_Occurred()) SWIG_fail;
24780 }
24781 {
24782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24783 }
24784 return resultobj;
24785 fail:
24786 return NULL;
24787 }
24788
24789
24790 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24791 PyObject *resultobj;
24792 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24793 bool result;
24794 PyObject * obj0 = 0 ;
24795 char *kwnames[] = {
24796 (char *) "self", NULL
24797 };
24798
24799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24801 if (SWIG_arg_fail(1)) SWIG_fail;
24802 {
24803 PyThreadState* __tstate = wxPyBeginAllowThreads();
24804 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24805
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 {
24810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24811 }
24812 return resultobj;
24813 fail:
24814 return NULL;
24815 }
24816
24817
24818 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24819 PyObject *resultobj;
24820 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24821 wxTimeSpan *arg2 = 0 ;
24822 bool result;
24823 PyObject * obj0 = 0 ;
24824 PyObject * obj1 = 0 ;
24825 char *kwnames[] = {
24826 (char *) "self",(char *) "ts", NULL
24827 };
24828
24829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24831 if (SWIG_arg_fail(1)) SWIG_fail;
24832 {
24833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24834 if (SWIG_arg_fail(2)) SWIG_fail;
24835 if (arg2 == NULL) {
24836 SWIG_null_ref("wxTimeSpan");
24837 }
24838 if (SWIG_arg_fail(2)) SWIG_fail;
24839 }
24840 {
24841 PyThreadState* __tstate = wxPyBeginAllowThreads();
24842 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24843
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 {
24848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24849 }
24850 return resultobj;
24851 fail:
24852 return NULL;
24853 }
24854
24855
24856 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24857 PyObject *resultobj;
24858 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24859 wxTimeSpan *arg2 = 0 ;
24860 bool result;
24861 PyObject * obj0 = 0 ;
24862 PyObject * obj1 = 0 ;
24863 char *kwnames[] = {
24864 (char *) "self",(char *) "ts", NULL
24865 };
24866
24867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24869 if (SWIG_arg_fail(1)) SWIG_fail;
24870 {
24871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24872 if (SWIG_arg_fail(2)) SWIG_fail;
24873 if (arg2 == NULL) {
24874 SWIG_null_ref("wxTimeSpan");
24875 }
24876 if (SWIG_arg_fail(2)) SWIG_fail;
24877 }
24878 {
24879 PyThreadState* __tstate = wxPyBeginAllowThreads();
24880 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24881
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 {
24886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24887 }
24888 return resultobj;
24889 fail:
24890 return NULL;
24891 }
24892
24893
24894 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24895 PyObject *resultobj;
24896 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24897 wxTimeSpan *arg2 = 0 ;
24898 bool result;
24899 PyObject * obj0 = 0 ;
24900 PyObject * obj1 = 0 ;
24901 char *kwnames[] = {
24902 (char *) "self",(char *) "t", NULL
24903 };
24904
24905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24907 if (SWIG_arg_fail(1)) SWIG_fail;
24908 {
24909 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24910 if (SWIG_arg_fail(2)) SWIG_fail;
24911 if (arg2 == NULL) {
24912 SWIG_null_ref("wxTimeSpan");
24913 }
24914 if (SWIG_arg_fail(2)) SWIG_fail;
24915 }
24916 {
24917 PyThreadState* __tstate = wxPyBeginAllowThreads();
24918 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24919
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 {
24924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24925 }
24926 return resultobj;
24927 fail:
24928 return NULL;
24929 }
24930
24931
24932 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24933 PyObject *resultobj;
24934 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24935 int result;
24936 PyObject * obj0 = 0 ;
24937 char *kwnames[] = {
24938 (char *) "self", NULL
24939 };
24940
24941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24943 if (SWIG_arg_fail(1)) SWIG_fail;
24944 {
24945 PyThreadState* __tstate = wxPyBeginAllowThreads();
24946 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24947
24948 wxPyEndAllowThreads(__tstate);
24949 if (PyErr_Occurred()) SWIG_fail;
24950 }
24951 {
24952 resultobj = SWIG_From_int((int)(result));
24953 }
24954 return resultobj;
24955 fail:
24956 return NULL;
24957 }
24958
24959
24960 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24961 PyObject *resultobj;
24962 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24963 int result;
24964 PyObject * obj0 = 0 ;
24965 char *kwnames[] = {
24966 (char *) "self", NULL
24967 };
24968
24969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24971 if (SWIG_arg_fail(1)) SWIG_fail;
24972 {
24973 PyThreadState* __tstate = wxPyBeginAllowThreads();
24974 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24975
24976 wxPyEndAllowThreads(__tstate);
24977 if (PyErr_Occurred()) SWIG_fail;
24978 }
24979 {
24980 resultobj = SWIG_From_int((int)(result));
24981 }
24982 return resultobj;
24983 fail:
24984 return NULL;
24985 }
24986
24987
24988 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24989 PyObject *resultobj;
24990 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24991 int result;
24992 PyObject * obj0 = 0 ;
24993 char *kwnames[] = {
24994 (char *) "self", NULL
24995 };
24996
24997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24999 if (SWIG_arg_fail(1)) SWIG_fail;
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25003
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 {
25008 resultobj = SWIG_From_int((int)(result));
25009 }
25010 return resultobj;
25011 fail:
25012 return NULL;
25013 }
25014
25015
25016 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25017 PyObject *resultobj;
25018 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25019 int result;
25020 PyObject * obj0 = 0 ;
25021 char *kwnames[] = {
25022 (char *) "self", NULL
25023 };
25024
25025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25027 if (SWIG_arg_fail(1)) SWIG_fail;
25028 {
25029 PyThreadState* __tstate = wxPyBeginAllowThreads();
25030 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25031
25032 wxPyEndAllowThreads(__tstate);
25033 if (PyErr_Occurred()) SWIG_fail;
25034 }
25035 {
25036 resultobj = SWIG_From_int((int)(result));
25037 }
25038 return resultobj;
25039 fail:
25040 return NULL;
25041 }
25042
25043
25044 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25045 PyObject *resultobj;
25046 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25047 wxLongLong result;
25048 PyObject * obj0 = 0 ;
25049 char *kwnames[] = {
25050 (char *) "self", NULL
25051 };
25052
25053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25055 if (SWIG_arg_fail(1)) SWIG_fail;
25056 {
25057 PyThreadState* __tstate = wxPyBeginAllowThreads();
25058 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25059
25060 wxPyEndAllowThreads(__tstate);
25061 if (PyErr_Occurred()) SWIG_fail;
25062 }
25063 {
25064 PyObject *hi, *lo, *shifter, *shifted;
25065 hi = PyLong_FromLong( (&result)->GetHi() );
25066 lo = PyLong_FromLong( (&result)->GetLo() );
25067 shifter = PyLong_FromLong(32);
25068 shifted = PyNumber_Lshift(hi, shifter);
25069 resultobj = PyNumber_Or(shifted, lo);
25070 Py_DECREF(hi);
25071 Py_DECREF(lo);
25072 Py_DECREF(shifter);
25073 Py_DECREF(shifted);
25074 }
25075 return resultobj;
25076 fail:
25077 return NULL;
25078 }
25079
25080
25081 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25082 PyObject *resultobj;
25083 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25084 wxLongLong result;
25085 PyObject * obj0 = 0 ;
25086 char *kwnames[] = {
25087 (char *) "self", NULL
25088 };
25089
25090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25092 if (SWIG_arg_fail(1)) SWIG_fail;
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25096
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 {
25101 PyObject *hi, *lo, *shifter, *shifted;
25102 hi = PyLong_FromLong( (&result)->GetHi() );
25103 lo = PyLong_FromLong( (&result)->GetLo() );
25104 shifter = PyLong_FromLong(32);
25105 shifted = PyNumber_Lshift(hi, shifter);
25106 resultobj = PyNumber_Or(shifted, lo);
25107 Py_DECREF(hi);
25108 Py_DECREF(lo);
25109 Py_DECREF(shifter);
25110 Py_DECREF(shifted);
25111 }
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25119 PyObject *resultobj;
25120 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25121 wxString const &arg2_defvalue = wxPyTimeSpanFormatStr ;
25122 wxString *arg2 = (wxString *) &arg2_defvalue ;
25123 wxString result;
25124 bool temp2 = false ;
25125 PyObject * obj0 = 0 ;
25126 PyObject * obj1 = 0 ;
25127 char *kwnames[] = {
25128 (char *) "self",(char *) "format", NULL
25129 };
25130
25131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25133 if (SWIG_arg_fail(1)) SWIG_fail;
25134 if (obj1) {
25135 {
25136 arg2 = wxString_in_helper(obj1);
25137 if (arg2 == NULL) SWIG_fail;
25138 temp2 = true;
25139 }
25140 }
25141 {
25142 PyThreadState* __tstate = wxPyBeginAllowThreads();
25143 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25144
25145 wxPyEndAllowThreads(__tstate);
25146 if (PyErr_Occurred()) SWIG_fail;
25147 }
25148 {
25149 #if wxUSE_UNICODE
25150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25151 #else
25152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25153 #endif
25154 }
25155 {
25156 if (temp2)
25157 delete arg2;
25158 }
25159 return resultobj;
25160 fail:
25161 {
25162 if (temp2)
25163 delete arg2;
25164 }
25165 return NULL;
25166 }
25167
25168
25169 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25170 PyObject *obj;
25171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25172 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25173 Py_INCREF(obj);
25174 return Py_BuildValue((char *)"");
25175 }
25176 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25177 PyObject *resultobj;
25178 int arg1 = (int) 0 ;
25179 int arg2 = (int) 0 ;
25180 int arg3 = (int) 0 ;
25181 int arg4 = (int) 0 ;
25182 wxDateSpan *result;
25183 PyObject * obj0 = 0 ;
25184 PyObject * obj1 = 0 ;
25185 PyObject * obj2 = 0 ;
25186 PyObject * obj3 = 0 ;
25187 char *kwnames[] = {
25188 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25189 };
25190
25191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25192 if (obj0) {
25193 {
25194 arg1 = (int)(SWIG_As_int(obj0));
25195 if (SWIG_arg_fail(1)) SWIG_fail;
25196 }
25197 }
25198 if (obj1) {
25199 {
25200 arg2 = (int)(SWIG_As_int(obj1));
25201 if (SWIG_arg_fail(2)) SWIG_fail;
25202 }
25203 }
25204 if (obj2) {
25205 {
25206 arg3 = (int)(SWIG_As_int(obj2));
25207 if (SWIG_arg_fail(3)) SWIG_fail;
25208 }
25209 }
25210 if (obj3) {
25211 {
25212 arg4 = (int)(SWIG_As_int(obj3));
25213 if (SWIG_arg_fail(4)) SWIG_fail;
25214 }
25215 }
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25219
25220 wxPyEndAllowThreads(__tstate);
25221 if (PyErr_Occurred()) SWIG_fail;
25222 }
25223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25224 return resultobj;
25225 fail:
25226 return NULL;
25227 }
25228
25229
25230 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25231 PyObject *resultobj;
25232 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25233 PyObject * obj0 = 0 ;
25234 char *kwnames[] = {
25235 (char *) "self", NULL
25236 };
25237
25238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25240 if (SWIG_arg_fail(1)) SWIG_fail;
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 delete arg1;
25244
25245 wxPyEndAllowThreads(__tstate);
25246 if (PyErr_Occurred()) SWIG_fail;
25247 }
25248 Py_INCREF(Py_None); resultobj = Py_None;
25249 return resultobj;
25250 fail:
25251 return NULL;
25252 }
25253
25254
25255 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25256 PyObject *resultobj;
25257 int arg1 ;
25258 wxDateSpan result;
25259 PyObject * obj0 = 0 ;
25260 char *kwnames[] = {
25261 (char *) "days", NULL
25262 };
25263
25264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25265 {
25266 arg1 = (int)(SWIG_As_int(obj0));
25267 if (SWIG_arg_fail(1)) SWIG_fail;
25268 }
25269 {
25270 PyThreadState* __tstate = wxPyBeginAllowThreads();
25271 result = wxDateSpan::Days(arg1);
25272
25273 wxPyEndAllowThreads(__tstate);
25274 if (PyErr_Occurred()) SWIG_fail;
25275 }
25276 {
25277 wxDateSpan * resultptr;
25278 resultptr = new wxDateSpan((wxDateSpan &)(result));
25279 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25280 }
25281 return resultobj;
25282 fail:
25283 return NULL;
25284 }
25285
25286
25287 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25288 PyObject *resultobj;
25289 wxDateSpan result;
25290 char *kwnames[] = {
25291 NULL
25292 };
25293
25294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25295 {
25296 PyThreadState* __tstate = wxPyBeginAllowThreads();
25297 result = wxDateSpan::Day();
25298
25299 wxPyEndAllowThreads(__tstate);
25300 if (PyErr_Occurred()) SWIG_fail;
25301 }
25302 {
25303 wxDateSpan * resultptr;
25304 resultptr = new wxDateSpan((wxDateSpan &)(result));
25305 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25306 }
25307 return resultobj;
25308 fail:
25309 return NULL;
25310 }
25311
25312
25313 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25314 PyObject *resultobj;
25315 int arg1 ;
25316 wxDateSpan result;
25317 PyObject * obj0 = 0 ;
25318 char *kwnames[] = {
25319 (char *) "weeks", NULL
25320 };
25321
25322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25323 {
25324 arg1 = (int)(SWIG_As_int(obj0));
25325 if (SWIG_arg_fail(1)) SWIG_fail;
25326 }
25327 {
25328 PyThreadState* __tstate = wxPyBeginAllowThreads();
25329 result = wxDateSpan::Weeks(arg1);
25330
25331 wxPyEndAllowThreads(__tstate);
25332 if (PyErr_Occurred()) SWIG_fail;
25333 }
25334 {
25335 wxDateSpan * resultptr;
25336 resultptr = new wxDateSpan((wxDateSpan &)(result));
25337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25338 }
25339 return resultobj;
25340 fail:
25341 return NULL;
25342 }
25343
25344
25345 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25346 PyObject *resultobj;
25347 wxDateSpan result;
25348 char *kwnames[] = {
25349 NULL
25350 };
25351
25352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25353 {
25354 PyThreadState* __tstate = wxPyBeginAllowThreads();
25355 result = wxDateSpan::Week();
25356
25357 wxPyEndAllowThreads(__tstate);
25358 if (PyErr_Occurred()) SWIG_fail;
25359 }
25360 {
25361 wxDateSpan * resultptr;
25362 resultptr = new wxDateSpan((wxDateSpan &)(result));
25363 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25364 }
25365 return resultobj;
25366 fail:
25367 return NULL;
25368 }
25369
25370
25371 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25372 PyObject *resultobj;
25373 int arg1 ;
25374 wxDateSpan result;
25375 PyObject * obj0 = 0 ;
25376 char *kwnames[] = {
25377 (char *) "mon", NULL
25378 };
25379
25380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25381 {
25382 arg1 = (int)(SWIG_As_int(obj0));
25383 if (SWIG_arg_fail(1)) SWIG_fail;
25384 }
25385 {
25386 PyThreadState* __tstate = wxPyBeginAllowThreads();
25387 result = wxDateSpan::Months(arg1);
25388
25389 wxPyEndAllowThreads(__tstate);
25390 if (PyErr_Occurred()) SWIG_fail;
25391 }
25392 {
25393 wxDateSpan * resultptr;
25394 resultptr = new wxDateSpan((wxDateSpan &)(result));
25395 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25396 }
25397 return resultobj;
25398 fail:
25399 return NULL;
25400 }
25401
25402
25403 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25404 PyObject *resultobj;
25405 wxDateSpan result;
25406 char *kwnames[] = {
25407 NULL
25408 };
25409
25410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25411 {
25412 PyThreadState* __tstate = wxPyBeginAllowThreads();
25413 result = wxDateSpan::Month();
25414
25415 wxPyEndAllowThreads(__tstate);
25416 if (PyErr_Occurred()) SWIG_fail;
25417 }
25418 {
25419 wxDateSpan * resultptr;
25420 resultptr = new wxDateSpan((wxDateSpan &)(result));
25421 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25422 }
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25430 PyObject *resultobj;
25431 int arg1 ;
25432 wxDateSpan result;
25433 PyObject * obj0 = 0 ;
25434 char *kwnames[] = {
25435 (char *) "years", NULL
25436 };
25437
25438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25439 {
25440 arg1 = (int)(SWIG_As_int(obj0));
25441 if (SWIG_arg_fail(1)) SWIG_fail;
25442 }
25443 {
25444 PyThreadState* __tstate = wxPyBeginAllowThreads();
25445 result = wxDateSpan::Years(arg1);
25446
25447 wxPyEndAllowThreads(__tstate);
25448 if (PyErr_Occurred()) SWIG_fail;
25449 }
25450 {
25451 wxDateSpan * resultptr;
25452 resultptr = new wxDateSpan((wxDateSpan &)(result));
25453 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25454 }
25455 return resultobj;
25456 fail:
25457 return NULL;
25458 }
25459
25460
25461 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25462 PyObject *resultobj;
25463 wxDateSpan result;
25464 char *kwnames[] = {
25465 NULL
25466 };
25467
25468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25469 {
25470 PyThreadState* __tstate = wxPyBeginAllowThreads();
25471 result = wxDateSpan::Year();
25472
25473 wxPyEndAllowThreads(__tstate);
25474 if (PyErr_Occurred()) SWIG_fail;
25475 }
25476 {
25477 wxDateSpan * resultptr;
25478 resultptr = new wxDateSpan((wxDateSpan &)(result));
25479 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25480 }
25481 return resultobj;
25482 fail:
25483 return NULL;
25484 }
25485
25486
25487 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25488 PyObject *resultobj;
25489 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25490 int arg2 ;
25491 wxDateSpan *result;
25492 PyObject * obj0 = 0 ;
25493 PyObject * obj1 = 0 ;
25494 char *kwnames[] = {
25495 (char *) "self",(char *) "n", NULL
25496 };
25497
25498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25500 if (SWIG_arg_fail(1)) SWIG_fail;
25501 {
25502 arg2 = (int)(SWIG_As_int(obj1));
25503 if (SWIG_arg_fail(2)) SWIG_fail;
25504 }
25505 {
25506 PyThreadState* __tstate = wxPyBeginAllowThreads();
25507 {
25508 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25509 result = (wxDateSpan *) &_result_ref;
25510 }
25511
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25516 return resultobj;
25517 fail:
25518 return NULL;
25519 }
25520
25521
25522 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj;
25524 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25525 int arg2 ;
25526 wxDateSpan *result;
25527 PyObject * obj0 = 0 ;
25528 PyObject * obj1 = 0 ;
25529 char *kwnames[] = {
25530 (char *) "self",(char *) "n", NULL
25531 };
25532
25533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25535 if (SWIG_arg_fail(1)) SWIG_fail;
25536 {
25537 arg2 = (int)(SWIG_As_int(obj1));
25538 if (SWIG_arg_fail(2)) SWIG_fail;
25539 }
25540 {
25541 PyThreadState* __tstate = wxPyBeginAllowThreads();
25542 {
25543 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25544 result = (wxDateSpan *) &_result_ref;
25545 }
25546
25547 wxPyEndAllowThreads(__tstate);
25548 if (PyErr_Occurred()) SWIG_fail;
25549 }
25550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25551 return resultobj;
25552 fail:
25553 return NULL;
25554 }
25555
25556
25557 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25558 PyObject *resultobj;
25559 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25560 int arg2 ;
25561 wxDateSpan *result;
25562 PyObject * obj0 = 0 ;
25563 PyObject * obj1 = 0 ;
25564 char *kwnames[] = {
25565 (char *) "self",(char *) "n", NULL
25566 };
25567
25568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25570 if (SWIG_arg_fail(1)) SWIG_fail;
25571 {
25572 arg2 = (int)(SWIG_As_int(obj1));
25573 if (SWIG_arg_fail(2)) SWIG_fail;
25574 }
25575 {
25576 PyThreadState* __tstate = wxPyBeginAllowThreads();
25577 {
25578 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25579 result = (wxDateSpan *) &_result_ref;
25580 }
25581
25582 wxPyEndAllowThreads(__tstate);
25583 if (PyErr_Occurred()) SWIG_fail;
25584 }
25585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25586 return resultobj;
25587 fail:
25588 return NULL;
25589 }
25590
25591
25592 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25593 PyObject *resultobj;
25594 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25595 int arg2 ;
25596 wxDateSpan *result;
25597 PyObject * obj0 = 0 ;
25598 PyObject * obj1 = 0 ;
25599 char *kwnames[] = {
25600 (char *) "self",(char *) "n", NULL
25601 };
25602
25603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25605 if (SWIG_arg_fail(1)) SWIG_fail;
25606 {
25607 arg2 = (int)(SWIG_As_int(obj1));
25608 if (SWIG_arg_fail(2)) SWIG_fail;
25609 }
25610 {
25611 PyThreadState* __tstate = wxPyBeginAllowThreads();
25612 {
25613 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25614 result = (wxDateSpan *) &_result_ref;
25615 }
25616
25617 wxPyEndAllowThreads(__tstate);
25618 if (PyErr_Occurred()) SWIG_fail;
25619 }
25620 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25621 return resultobj;
25622 fail:
25623 return NULL;
25624 }
25625
25626
25627 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25628 PyObject *resultobj;
25629 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25630 int result;
25631 PyObject * obj0 = 0 ;
25632 char *kwnames[] = {
25633 (char *) "self", NULL
25634 };
25635
25636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25638 if (SWIG_arg_fail(1)) SWIG_fail;
25639 {
25640 PyThreadState* __tstate = wxPyBeginAllowThreads();
25641 result = (int)((wxDateSpan const *)arg1)->GetYears();
25642
25643 wxPyEndAllowThreads(__tstate);
25644 if (PyErr_Occurred()) SWIG_fail;
25645 }
25646 {
25647 resultobj = SWIG_From_int((int)(result));
25648 }
25649 return resultobj;
25650 fail:
25651 return NULL;
25652 }
25653
25654
25655 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25656 PyObject *resultobj;
25657 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25658 int result;
25659 PyObject * obj0 = 0 ;
25660 char *kwnames[] = {
25661 (char *) "self", NULL
25662 };
25663
25664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25666 if (SWIG_arg_fail(1)) SWIG_fail;
25667 {
25668 PyThreadState* __tstate = wxPyBeginAllowThreads();
25669 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25670
25671 wxPyEndAllowThreads(__tstate);
25672 if (PyErr_Occurred()) SWIG_fail;
25673 }
25674 {
25675 resultobj = SWIG_From_int((int)(result));
25676 }
25677 return resultobj;
25678 fail:
25679 return NULL;
25680 }
25681
25682
25683 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25684 PyObject *resultobj;
25685 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25686 int result;
25687 PyObject * obj0 = 0 ;
25688 char *kwnames[] = {
25689 (char *) "self", NULL
25690 };
25691
25692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25694 if (SWIG_arg_fail(1)) SWIG_fail;
25695 {
25696 PyThreadState* __tstate = wxPyBeginAllowThreads();
25697 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25698
25699 wxPyEndAllowThreads(__tstate);
25700 if (PyErr_Occurred()) SWIG_fail;
25701 }
25702 {
25703 resultobj = SWIG_From_int((int)(result));
25704 }
25705 return resultobj;
25706 fail:
25707 return NULL;
25708 }
25709
25710
25711 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25712 PyObject *resultobj;
25713 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25714 int result;
25715 PyObject * obj0 = 0 ;
25716 char *kwnames[] = {
25717 (char *) "self", NULL
25718 };
25719
25720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25722 if (SWIG_arg_fail(1)) SWIG_fail;
25723 {
25724 PyThreadState* __tstate = wxPyBeginAllowThreads();
25725 result = (int)((wxDateSpan const *)arg1)->GetDays();
25726
25727 wxPyEndAllowThreads(__tstate);
25728 if (PyErr_Occurred()) SWIG_fail;
25729 }
25730 {
25731 resultobj = SWIG_From_int((int)(result));
25732 }
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25740 PyObject *resultobj;
25741 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25742 int result;
25743 PyObject * obj0 = 0 ;
25744 char *kwnames[] = {
25745 (char *) "self", NULL
25746 };
25747
25748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25750 if (SWIG_arg_fail(1)) SWIG_fail;
25751 {
25752 PyThreadState* __tstate = wxPyBeginAllowThreads();
25753 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25754
25755 wxPyEndAllowThreads(__tstate);
25756 if (PyErr_Occurred()) SWIG_fail;
25757 }
25758 {
25759 resultobj = SWIG_From_int((int)(result));
25760 }
25761 return resultobj;
25762 fail:
25763 return NULL;
25764 }
25765
25766
25767 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25768 PyObject *resultobj;
25769 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25770 wxDateSpan *arg2 = 0 ;
25771 wxDateSpan *result;
25772 PyObject * obj0 = 0 ;
25773 PyObject * obj1 = 0 ;
25774 char *kwnames[] = {
25775 (char *) "self",(char *) "other", NULL
25776 };
25777
25778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25780 if (SWIG_arg_fail(1)) SWIG_fail;
25781 {
25782 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25783 if (SWIG_arg_fail(2)) SWIG_fail;
25784 if (arg2 == NULL) {
25785 SWIG_null_ref("wxDateSpan");
25786 }
25787 if (SWIG_arg_fail(2)) SWIG_fail;
25788 }
25789 {
25790 PyThreadState* __tstate = wxPyBeginAllowThreads();
25791 {
25792 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25793 result = (wxDateSpan *) &_result_ref;
25794 }
25795
25796 wxPyEndAllowThreads(__tstate);
25797 if (PyErr_Occurred()) SWIG_fail;
25798 }
25799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25800 return resultobj;
25801 fail:
25802 return NULL;
25803 }
25804
25805
25806 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25807 PyObject *resultobj;
25808 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25809 wxDateSpan *arg2 = 0 ;
25810 wxDateSpan *result;
25811 PyObject * obj0 = 0 ;
25812 PyObject * obj1 = 0 ;
25813 char *kwnames[] = {
25814 (char *) "self",(char *) "other", NULL
25815 };
25816
25817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25819 if (SWIG_arg_fail(1)) SWIG_fail;
25820 {
25821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25822 if (SWIG_arg_fail(2)) SWIG_fail;
25823 if (arg2 == NULL) {
25824 SWIG_null_ref("wxDateSpan");
25825 }
25826 if (SWIG_arg_fail(2)) SWIG_fail;
25827 }
25828 {
25829 PyThreadState* __tstate = wxPyBeginAllowThreads();
25830 {
25831 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25832 result = (wxDateSpan *) &_result_ref;
25833 }
25834
25835 wxPyEndAllowThreads(__tstate);
25836 if (PyErr_Occurred()) SWIG_fail;
25837 }
25838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25839 return resultobj;
25840 fail:
25841 return NULL;
25842 }
25843
25844
25845 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25846 PyObject *resultobj;
25847 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25848 wxDateSpan *result;
25849 PyObject * obj0 = 0 ;
25850 char *kwnames[] = {
25851 (char *) "self", NULL
25852 };
25853
25854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25856 if (SWIG_arg_fail(1)) SWIG_fail;
25857 {
25858 PyThreadState* __tstate = wxPyBeginAllowThreads();
25859 {
25860 wxDateSpan &_result_ref = (arg1)->Neg();
25861 result = (wxDateSpan *) &_result_ref;
25862 }
25863
25864 wxPyEndAllowThreads(__tstate);
25865 if (PyErr_Occurred()) SWIG_fail;
25866 }
25867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25868 return resultobj;
25869 fail:
25870 return NULL;
25871 }
25872
25873
25874 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25875 PyObject *resultobj;
25876 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25877 int arg2 ;
25878 wxDateSpan *result;
25879 PyObject * obj0 = 0 ;
25880 PyObject * obj1 = 0 ;
25881 char *kwnames[] = {
25882 (char *) "self",(char *) "factor", NULL
25883 };
25884
25885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25887 if (SWIG_arg_fail(1)) SWIG_fail;
25888 {
25889 arg2 = (int)(SWIG_As_int(obj1));
25890 if (SWIG_arg_fail(2)) SWIG_fail;
25891 }
25892 {
25893 PyThreadState* __tstate = wxPyBeginAllowThreads();
25894 {
25895 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25896 result = (wxDateSpan *) &_result_ref;
25897 }
25898
25899 wxPyEndAllowThreads(__tstate);
25900 if (PyErr_Occurred()) SWIG_fail;
25901 }
25902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25903 return resultobj;
25904 fail:
25905 return NULL;
25906 }
25907
25908
25909 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25910 PyObject *resultobj;
25911 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25912 wxDateSpan *arg2 = 0 ;
25913 wxDateSpan *result;
25914 PyObject * obj0 = 0 ;
25915 PyObject * obj1 = 0 ;
25916 char *kwnames[] = {
25917 (char *) "self",(char *) "other", NULL
25918 };
25919
25920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25922 if (SWIG_arg_fail(1)) SWIG_fail;
25923 {
25924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25925 if (SWIG_arg_fail(2)) SWIG_fail;
25926 if (arg2 == NULL) {
25927 SWIG_null_ref("wxDateSpan");
25928 }
25929 if (SWIG_arg_fail(2)) SWIG_fail;
25930 }
25931 {
25932 PyThreadState* __tstate = wxPyBeginAllowThreads();
25933 {
25934 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25935 result = (wxDateSpan *) &_result_ref;
25936 }
25937
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj;
25950 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25951 wxDateSpan *arg2 = 0 ;
25952 wxDateSpan *result;
25953 PyObject * obj0 = 0 ;
25954 PyObject * obj1 = 0 ;
25955 char *kwnames[] = {
25956 (char *) "self",(char *) "other", NULL
25957 };
25958
25959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25961 if (SWIG_arg_fail(1)) SWIG_fail;
25962 {
25963 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25964 if (SWIG_arg_fail(2)) SWIG_fail;
25965 if (arg2 == NULL) {
25966 SWIG_null_ref("wxDateSpan");
25967 }
25968 if (SWIG_arg_fail(2)) SWIG_fail;
25969 }
25970 {
25971 PyThreadState* __tstate = wxPyBeginAllowThreads();
25972 {
25973 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25974 result = (wxDateSpan *) &_result_ref;
25975 }
25976
25977 wxPyEndAllowThreads(__tstate);
25978 if (PyErr_Occurred()) SWIG_fail;
25979 }
25980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25981 return resultobj;
25982 fail:
25983 return NULL;
25984 }
25985
25986
25987 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25988 PyObject *resultobj;
25989 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25990 wxDateSpan *result;
25991 PyObject * obj0 = 0 ;
25992 char *kwnames[] = {
25993 (char *) "self", NULL
25994 };
25995
25996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25998 if (SWIG_arg_fail(1)) SWIG_fail;
25999 {
26000 PyThreadState* __tstate = wxPyBeginAllowThreads();
26001 {
26002 wxDateSpan &_result_ref = (arg1)->operator -();
26003 result = (wxDateSpan *) &_result_ref;
26004 }
26005
26006 wxPyEndAllowThreads(__tstate);
26007 if (PyErr_Occurred()) SWIG_fail;
26008 }
26009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26017 PyObject *resultobj;
26018 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26019 int arg2 ;
26020 wxDateSpan *result;
26021 PyObject * obj0 = 0 ;
26022 PyObject * obj1 = 0 ;
26023 char *kwnames[] = {
26024 (char *) "self",(char *) "factor", NULL
26025 };
26026
26027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26029 if (SWIG_arg_fail(1)) SWIG_fail;
26030 {
26031 arg2 = (int)(SWIG_As_int(obj1));
26032 if (SWIG_arg_fail(2)) SWIG_fail;
26033 }
26034 {
26035 PyThreadState* __tstate = wxPyBeginAllowThreads();
26036 {
26037 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26038 result = (wxDateSpan *) &_result_ref;
26039 }
26040
26041 wxPyEndAllowThreads(__tstate);
26042 if (PyErr_Occurred()) SWIG_fail;
26043 }
26044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26045 return resultobj;
26046 fail:
26047 return NULL;
26048 }
26049
26050
26051 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26052 PyObject *resultobj;
26053 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26054 wxDateSpan *arg2 = 0 ;
26055 wxDateSpan result;
26056 PyObject * obj0 = 0 ;
26057 PyObject * obj1 = 0 ;
26058 char *kwnames[] = {
26059 (char *) "self",(char *) "other", NULL
26060 };
26061
26062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26064 if (SWIG_arg_fail(1)) SWIG_fail;
26065 {
26066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26067 if (SWIG_arg_fail(2)) SWIG_fail;
26068 if (arg2 == NULL) {
26069 SWIG_null_ref("wxDateSpan");
26070 }
26071 if (SWIG_arg_fail(2)) SWIG_fail;
26072 }
26073 {
26074 PyThreadState* __tstate = wxPyBeginAllowThreads();
26075 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26076
26077 wxPyEndAllowThreads(__tstate);
26078 if (PyErr_Occurred()) SWIG_fail;
26079 }
26080 {
26081 wxDateSpan * resultptr;
26082 resultptr = new wxDateSpan((wxDateSpan &)(result));
26083 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26084 }
26085 return resultobj;
26086 fail:
26087 return NULL;
26088 }
26089
26090
26091 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26092 PyObject *resultobj;
26093 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26094 wxDateSpan *arg2 = 0 ;
26095 wxDateSpan result;
26096 PyObject * obj0 = 0 ;
26097 PyObject * obj1 = 0 ;
26098 char *kwnames[] = {
26099 (char *) "self",(char *) "other", NULL
26100 };
26101
26102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26104 if (SWIG_arg_fail(1)) SWIG_fail;
26105 {
26106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26107 if (SWIG_arg_fail(2)) SWIG_fail;
26108 if (arg2 == NULL) {
26109 SWIG_null_ref("wxDateSpan");
26110 }
26111 if (SWIG_arg_fail(2)) SWIG_fail;
26112 }
26113 {
26114 PyThreadState* __tstate = wxPyBeginAllowThreads();
26115 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26116
26117 wxPyEndAllowThreads(__tstate);
26118 if (PyErr_Occurred()) SWIG_fail;
26119 }
26120 {
26121 wxDateSpan * resultptr;
26122 resultptr = new wxDateSpan((wxDateSpan &)(result));
26123 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26124 }
26125 return resultobj;
26126 fail:
26127 return NULL;
26128 }
26129
26130
26131 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26132 PyObject *resultobj;
26133 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26134 int arg2 ;
26135 wxDateSpan result;
26136 PyObject * obj0 = 0 ;
26137 PyObject * obj1 = 0 ;
26138 char *kwnames[] = {
26139 (char *) "self",(char *) "n", NULL
26140 };
26141
26142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26144 if (SWIG_arg_fail(1)) SWIG_fail;
26145 {
26146 arg2 = (int)(SWIG_As_int(obj1));
26147 if (SWIG_arg_fail(2)) SWIG_fail;
26148 }
26149 {
26150 PyThreadState* __tstate = wxPyBeginAllowThreads();
26151 result = wxDateSpan___mul__(arg1,arg2);
26152
26153 wxPyEndAllowThreads(__tstate);
26154 if (PyErr_Occurred()) SWIG_fail;
26155 }
26156 {
26157 wxDateSpan * resultptr;
26158 resultptr = new wxDateSpan((wxDateSpan &)(result));
26159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26160 }
26161 return resultobj;
26162 fail:
26163 return NULL;
26164 }
26165
26166
26167 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26168 PyObject *resultobj;
26169 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26170 int arg2 ;
26171 wxDateSpan result;
26172 PyObject * obj0 = 0 ;
26173 PyObject * obj1 = 0 ;
26174 char *kwnames[] = {
26175 (char *) "self",(char *) "n", NULL
26176 };
26177
26178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26180 if (SWIG_arg_fail(1)) SWIG_fail;
26181 {
26182 arg2 = (int)(SWIG_As_int(obj1));
26183 if (SWIG_arg_fail(2)) SWIG_fail;
26184 }
26185 {
26186 PyThreadState* __tstate = wxPyBeginAllowThreads();
26187 result = wxDateSpan___rmul__(arg1,arg2);
26188
26189 wxPyEndAllowThreads(__tstate);
26190 if (PyErr_Occurred()) SWIG_fail;
26191 }
26192 {
26193 wxDateSpan * resultptr;
26194 resultptr = new wxDateSpan((wxDateSpan &)(result));
26195 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26196 }
26197 return resultobj;
26198 fail:
26199 return NULL;
26200 }
26201
26202
26203 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26204 PyObject *resultobj;
26205 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26206 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26207 bool result;
26208 PyObject * obj0 = 0 ;
26209 PyObject * obj1 = 0 ;
26210 char *kwnames[] = {
26211 (char *) "self",(char *) "other", NULL
26212 };
26213
26214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26216 if (SWIG_arg_fail(1)) SWIG_fail;
26217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26218 if (SWIG_arg_fail(2)) SWIG_fail;
26219 {
26220 PyThreadState* __tstate = wxPyBeginAllowThreads();
26221 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26222
26223 wxPyEndAllowThreads(__tstate);
26224 if (PyErr_Occurred()) SWIG_fail;
26225 }
26226 {
26227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26228 }
26229 return resultobj;
26230 fail:
26231 return NULL;
26232 }
26233
26234
26235 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26236 PyObject *resultobj;
26237 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26238 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26239 bool result;
26240 PyObject * obj0 = 0 ;
26241 PyObject * obj1 = 0 ;
26242 char *kwnames[] = {
26243 (char *) "self",(char *) "other", NULL
26244 };
26245
26246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26248 if (SWIG_arg_fail(1)) SWIG_fail;
26249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26250 if (SWIG_arg_fail(2)) SWIG_fail;
26251 {
26252 PyThreadState* __tstate = wxPyBeginAllowThreads();
26253 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26254
26255 wxPyEndAllowThreads(__tstate);
26256 if (PyErr_Occurred()) SWIG_fail;
26257 }
26258 {
26259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26260 }
26261 return resultobj;
26262 fail:
26263 return NULL;
26264 }
26265
26266
26267 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26268 PyObject *obj;
26269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26270 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26271 Py_INCREF(obj);
26272 return Py_BuildValue((char *)"");
26273 }
26274 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26275 PyObject *resultobj;
26276 long result;
26277 char *kwnames[] = {
26278 NULL
26279 };
26280
26281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 result = (long)wxGetLocalTime();
26285
26286 wxPyEndAllowThreads(__tstate);
26287 if (PyErr_Occurred()) SWIG_fail;
26288 }
26289 {
26290 resultobj = SWIG_From_long((long)(result));
26291 }
26292 return resultobj;
26293 fail:
26294 return NULL;
26295 }
26296
26297
26298 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26299 PyObject *resultobj;
26300 long result;
26301 char *kwnames[] = {
26302 NULL
26303 };
26304
26305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 result = (long)wxGetUTCTime();
26309
26310 wxPyEndAllowThreads(__tstate);
26311 if (PyErr_Occurred()) SWIG_fail;
26312 }
26313 {
26314 resultobj = SWIG_From_long((long)(result));
26315 }
26316 return resultobj;
26317 fail:
26318 return NULL;
26319 }
26320
26321
26322 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26323 PyObject *resultobj;
26324 long result;
26325 char *kwnames[] = {
26326 NULL
26327 };
26328
26329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26330 {
26331 PyThreadState* __tstate = wxPyBeginAllowThreads();
26332 result = (long)wxGetCurrentTime();
26333
26334 wxPyEndAllowThreads(__tstate);
26335 if (PyErr_Occurred()) SWIG_fail;
26336 }
26337 {
26338 resultobj = SWIG_From_long((long)(result));
26339 }
26340 return resultobj;
26341 fail:
26342 return NULL;
26343 }
26344
26345
26346 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26347 PyObject *resultobj;
26348 wxLongLong result;
26349 char *kwnames[] = {
26350 NULL
26351 };
26352
26353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26354 {
26355 PyThreadState* __tstate = wxPyBeginAllowThreads();
26356 result = wxGetLocalTimeMillis();
26357
26358 wxPyEndAllowThreads(__tstate);
26359 if (PyErr_Occurred()) SWIG_fail;
26360 }
26361 {
26362 PyObject *hi, *lo, *shifter, *shifted;
26363 hi = PyLong_FromLong( (&result)->GetHi() );
26364 lo = PyLong_FromLong( (&result)->GetLo() );
26365 shifter = PyLong_FromLong(32);
26366 shifted = PyNumber_Lshift(hi, shifter);
26367 resultobj = PyNumber_Or(shifted, lo);
26368 Py_DECREF(hi);
26369 Py_DECREF(lo);
26370 Py_DECREF(shifter);
26371 Py_DECREF(shifted);
26372 }
26373 return resultobj;
26374 fail:
26375 return NULL;
26376 }
26377
26378
26379 static int _wrap_DefaultDateTime_set(PyObject *) {
26380 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26381 return 1;
26382 }
26383
26384
26385 static PyObject *_wrap_DefaultDateTime_get(void) {
26386 PyObject *pyobj;
26387
26388 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26389 return pyobj;
26390 }
26391
26392
26393 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26394 PyObject *resultobj;
26395 wxDataFormatId arg1 ;
26396 wxDataFormat *result;
26397 PyObject * obj0 = 0 ;
26398 char *kwnames[] = {
26399 (char *) "type", NULL
26400 };
26401
26402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26403 {
26404 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26405 if (SWIG_arg_fail(1)) SWIG_fail;
26406 }
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26410
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26422 PyObject *resultobj;
26423 wxString *arg1 = 0 ;
26424 wxDataFormat *result;
26425 bool temp1 = false ;
26426 PyObject * obj0 = 0 ;
26427 char *kwnames[] = {
26428 (char *) "format", NULL
26429 };
26430
26431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26432 {
26433 arg1 = wxString_in_helper(obj0);
26434 if (arg1 == NULL) SWIG_fail;
26435 temp1 = true;
26436 }
26437 {
26438 PyThreadState* __tstate = wxPyBeginAllowThreads();
26439 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26440
26441 wxPyEndAllowThreads(__tstate);
26442 if (PyErr_Occurred()) SWIG_fail;
26443 }
26444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26445 {
26446 if (temp1)
26447 delete arg1;
26448 }
26449 return resultobj;
26450 fail:
26451 {
26452 if (temp1)
26453 delete arg1;
26454 }
26455 return NULL;
26456 }
26457
26458
26459 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26460 PyObject *resultobj;
26461 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26462 PyObject * obj0 = 0 ;
26463 char *kwnames[] = {
26464 (char *) "self", NULL
26465 };
26466
26467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26469 if (SWIG_arg_fail(1)) SWIG_fail;
26470 {
26471 PyThreadState* __tstate = wxPyBeginAllowThreads();
26472 delete arg1;
26473
26474 wxPyEndAllowThreads(__tstate);
26475 if (PyErr_Occurred()) SWIG_fail;
26476 }
26477 Py_INCREF(Py_None); resultobj = Py_None;
26478 return resultobj;
26479 fail:
26480 return NULL;
26481 }
26482
26483
26484 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26485 PyObject *resultobj;
26486 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26487 wxDataFormatId arg2 ;
26488 bool result;
26489 PyObject * obj0 = 0 ;
26490 PyObject * obj1 = 0 ;
26491
26492 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26494 if (SWIG_arg_fail(1)) SWIG_fail;
26495 {
26496 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26497 if (SWIG_arg_fail(2)) SWIG_fail;
26498 }
26499 {
26500 PyThreadState* __tstate = wxPyBeginAllowThreads();
26501 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26502
26503 wxPyEndAllowThreads(__tstate);
26504 if (PyErr_Occurred()) SWIG_fail;
26505 }
26506 {
26507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26508 }
26509 return resultobj;
26510 fail:
26511 return NULL;
26512 }
26513
26514
26515 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26516 PyObject *resultobj;
26517 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26518 wxDataFormatId arg2 ;
26519 bool result;
26520 PyObject * obj0 = 0 ;
26521 PyObject * obj1 = 0 ;
26522
26523 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26525 if (SWIG_arg_fail(1)) SWIG_fail;
26526 {
26527 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26528 if (SWIG_arg_fail(2)) SWIG_fail;
26529 }
26530 {
26531 PyThreadState* __tstate = wxPyBeginAllowThreads();
26532 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26533
26534 wxPyEndAllowThreads(__tstate);
26535 if (PyErr_Occurred()) SWIG_fail;
26536 }
26537 {
26538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26539 }
26540 return resultobj;
26541 fail:
26542 return NULL;
26543 }
26544
26545
26546 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26547 PyObject *resultobj;
26548 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26549 wxDataFormat *arg2 = 0 ;
26550 bool result;
26551 PyObject * obj0 = 0 ;
26552 PyObject * obj1 = 0 ;
26553
26554 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26556 if (SWIG_arg_fail(1)) SWIG_fail;
26557 {
26558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26559 if (SWIG_arg_fail(2)) SWIG_fail;
26560 if (arg2 == NULL) {
26561 SWIG_null_ref("wxDataFormat");
26562 }
26563 if (SWIG_arg_fail(2)) SWIG_fail;
26564 }
26565 {
26566 PyThreadState* __tstate = wxPyBeginAllowThreads();
26567 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26568
26569 wxPyEndAllowThreads(__tstate);
26570 if (PyErr_Occurred()) SWIG_fail;
26571 }
26572 {
26573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26574 }
26575 return resultobj;
26576 fail:
26577 return NULL;
26578 }
26579
26580
26581 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26582 int argc;
26583 PyObject *argv[3];
26584 int ii;
26585
26586 argc = PyObject_Length(args);
26587 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26588 argv[ii] = PyTuple_GetItem(args,ii);
26589 }
26590 if (argc == 2) {
26591 int _v;
26592 {
26593 void *ptr;
26594 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26595 _v = 0;
26596 PyErr_Clear();
26597 } else {
26598 _v = 1;
26599 }
26600 }
26601 if (_v) {
26602 {
26603 void *ptr = 0;
26604 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26605 _v = 0;
26606 PyErr_Clear();
26607 } else {
26608 _v = (ptr != 0);
26609 }
26610 }
26611 if (_v) {
26612 return _wrap_DataFormat___eq____SWIG_1(self,args);
26613 }
26614 }
26615 }
26616 if (argc == 2) {
26617 int _v;
26618 {
26619 void *ptr;
26620 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26621 _v = 0;
26622 PyErr_Clear();
26623 } else {
26624 _v = 1;
26625 }
26626 }
26627 if (_v) {
26628 _v = SWIG_Check_int(argv[1]);
26629 if (_v) {
26630 return _wrap_DataFormat___eq____SWIG_0(self,args);
26631 }
26632 }
26633 }
26634
26635 Py_INCREF(Py_NotImplemented);
26636 return Py_NotImplemented;
26637 }
26638
26639
26640 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26641 PyObject *resultobj;
26642 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26643 wxDataFormat *arg2 = 0 ;
26644 bool result;
26645 PyObject * obj0 = 0 ;
26646 PyObject * obj1 = 0 ;
26647
26648 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26650 if (SWIG_arg_fail(1)) SWIG_fail;
26651 {
26652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26653 if (SWIG_arg_fail(2)) SWIG_fail;
26654 if (arg2 == NULL) {
26655 SWIG_null_ref("wxDataFormat");
26656 }
26657 if (SWIG_arg_fail(2)) SWIG_fail;
26658 }
26659 {
26660 PyThreadState* __tstate = wxPyBeginAllowThreads();
26661 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26662
26663 wxPyEndAllowThreads(__tstate);
26664 if (PyErr_Occurred()) SWIG_fail;
26665 }
26666 {
26667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26668 }
26669 return resultobj;
26670 fail:
26671 return NULL;
26672 }
26673
26674
26675 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26676 int argc;
26677 PyObject *argv[3];
26678 int ii;
26679
26680 argc = PyObject_Length(args);
26681 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26682 argv[ii] = PyTuple_GetItem(args,ii);
26683 }
26684 if (argc == 2) {
26685 int _v;
26686 {
26687 void *ptr;
26688 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26689 _v = 0;
26690 PyErr_Clear();
26691 } else {
26692 _v = 1;
26693 }
26694 }
26695 if (_v) {
26696 {
26697 void *ptr = 0;
26698 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26699 _v = 0;
26700 PyErr_Clear();
26701 } else {
26702 _v = (ptr != 0);
26703 }
26704 }
26705 if (_v) {
26706 return _wrap_DataFormat___ne____SWIG_1(self,args);
26707 }
26708 }
26709 }
26710 if (argc == 2) {
26711 int _v;
26712 {
26713 void *ptr;
26714 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26715 _v = 0;
26716 PyErr_Clear();
26717 } else {
26718 _v = 1;
26719 }
26720 }
26721 if (_v) {
26722 _v = SWIG_Check_int(argv[1]);
26723 if (_v) {
26724 return _wrap_DataFormat___ne____SWIG_0(self,args);
26725 }
26726 }
26727 }
26728
26729 Py_INCREF(Py_NotImplemented);
26730 return Py_NotImplemented;
26731 }
26732
26733
26734 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26735 PyObject *resultobj;
26736 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26737 wxDataFormatId arg2 ;
26738 PyObject * obj0 = 0 ;
26739 PyObject * obj1 = 0 ;
26740 char *kwnames[] = {
26741 (char *) "self",(char *) "format", NULL
26742 };
26743
26744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26746 if (SWIG_arg_fail(1)) SWIG_fail;
26747 {
26748 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26749 if (SWIG_arg_fail(2)) SWIG_fail;
26750 }
26751 {
26752 PyThreadState* __tstate = wxPyBeginAllowThreads();
26753 (arg1)->SetType((wxDataFormatId )arg2);
26754
26755 wxPyEndAllowThreads(__tstate);
26756 if (PyErr_Occurred()) SWIG_fail;
26757 }
26758 Py_INCREF(Py_None); resultobj = Py_None;
26759 return resultobj;
26760 fail:
26761 return NULL;
26762 }
26763
26764
26765 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26766 PyObject *resultobj;
26767 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26768 wxDataFormatId result;
26769 PyObject * obj0 = 0 ;
26770 char *kwnames[] = {
26771 (char *) "self", NULL
26772 };
26773
26774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26776 if (SWIG_arg_fail(1)) SWIG_fail;
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26780
26781 wxPyEndAllowThreads(__tstate);
26782 if (PyErr_Occurred()) SWIG_fail;
26783 }
26784 resultobj = SWIG_From_int((result));
26785 return resultobj;
26786 fail:
26787 return NULL;
26788 }
26789
26790
26791 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26792 PyObject *resultobj;
26793 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26794 wxString result;
26795 PyObject * obj0 = 0 ;
26796 char *kwnames[] = {
26797 (char *) "self", NULL
26798 };
26799
26800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26802 if (SWIG_arg_fail(1)) SWIG_fail;
26803 {
26804 PyThreadState* __tstate = wxPyBeginAllowThreads();
26805 result = ((wxDataFormat const *)arg1)->GetId();
26806
26807 wxPyEndAllowThreads(__tstate);
26808 if (PyErr_Occurred()) SWIG_fail;
26809 }
26810 {
26811 #if wxUSE_UNICODE
26812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26813 #else
26814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26815 #endif
26816 }
26817 return resultobj;
26818 fail:
26819 return NULL;
26820 }
26821
26822
26823 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26824 PyObject *resultobj;
26825 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26826 wxString *arg2 = 0 ;
26827 bool temp2 = false ;
26828 PyObject * obj0 = 0 ;
26829 PyObject * obj1 = 0 ;
26830 char *kwnames[] = {
26831 (char *) "self",(char *) "format", NULL
26832 };
26833
26834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26836 if (SWIG_arg_fail(1)) SWIG_fail;
26837 {
26838 arg2 = wxString_in_helper(obj1);
26839 if (arg2 == NULL) SWIG_fail;
26840 temp2 = true;
26841 }
26842 {
26843 PyThreadState* __tstate = wxPyBeginAllowThreads();
26844 (arg1)->SetId((wxString const &)*arg2);
26845
26846 wxPyEndAllowThreads(__tstate);
26847 if (PyErr_Occurred()) SWIG_fail;
26848 }
26849 Py_INCREF(Py_None); resultobj = Py_None;
26850 {
26851 if (temp2)
26852 delete arg2;
26853 }
26854 return resultobj;
26855 fail:
26856 {
26857 if (temp2)
26858 delete arg2;
26859 }
26860 return NULL;
26861 }
26862
26863
26864 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26865 PyObject *obj;
26866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26867 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26868 Py_INCREF(obj);
26869 return Py_BuildValue((char *)"");
26870 }
26871 static int _wrap_FormatInvalid_set(PyObject *) {
26872 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26873 return 1;
26874 }
26875
26876
26877 static PyObject *_wrap_FormatInvalid_get(void) {
26878 PyObject *pyobj;
26879
26880 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26881 return pyobj;
26882 }
26883
26884
26885 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26886 PyObject *resultobj;
26887 wxDataObject *arg1 = (wxDataObject *) 0 ;
26888 PyObject * obj0 = 0 ;
26889 char *kwnames[] = {
26890 (char *) "self", NULL
26891 };
26892
26893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26895 if (SWIG_arg_fail(1)) SWIG_fail;
26896 {
26897 PyThreadState* __tstate = wxPyBeginAllowThreads();
26898 delete arg1;
26899
26900 wxPyEndAllowThreads(__tstate);
26901 if (PyErr_Occurred()) SWIG_fail;
26902 }
26903 Py_INCREF(Py_None); resultobj = Py_None;
26904 return resultobj;
26905 fail:
26906 return NULL;
26907 }
26908
26909
26910 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26911 PyObject *resultobj;
26912 wxDataObject *arg1 = (wxDataObject *) 0 ;
26913 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26914 SwigValueWrapper<wxDataFormat > result;
26915 PyObject * obj0 = 0 ;
26916 PyObject * obj1 = 0 ;
26917 char *kwnames[] = {
26918 (char *) "self",(char *) "dir", NULL
26919 };
26920
26921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26923 if (SWIG_arg_fail(1)) SWIG_fail;
26924 if (obj1) {
26925 {
26926 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26927 if (SWIG_arg_fail(2)) SWIG_fail;
26928 }
26929 }
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26933
26934 wxPyEndAllowThreads(__tstate);
26935 if (PyErr_Occurred()) SWIG_fail;
26936 }
26937 {
26938 wxDataFormat * resultptr;
26939 resultptr = new wxDataFormat((wxDataFormat &)(result));
26940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26941 }
26942 return resultobj;
26943 fail:
26944 return NULL;
26945 }
26946
26947
26948 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26949 PyObject *resultobj;
26950 wxDataObject *arg1 = (wxDataObject *) 0 ;
26951 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26952 size_t result;
26953 PyObject * obj0 = 0 ;
26954 PyObject * obj1 = 0 ;
26955 char *kwnames[] = {
26956 (char *) "self",(char *) "dir", NULL
26957 };
26958
26959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26961 if (SWIG_arg_fail(1)) SWIG_fail;
26962 if (obj1) {
26963 {
26964 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26965 if (SWIG_arg_fail(2)) SWIG_fail;
26966 }
26967 }
26968 {
26969 PyThreadState* __tstate = wxPyBeginAllowThreads();
26970 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26971
26972 wxPyEndAllowThreads(__tstate);
26973 if (PyErr_Occurred()) SWIG_fail;
26974 }
26975 {
26976 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26977 }
26978 return resultobj;
26979 fail:
26980 return NULL;
26981 }
26982
26983
26984 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26985 PyObject *resultobj;
26986 wxDataObject *arg1 = (wxDataObject *) 0 ;
26987 wxDataFormat *arg2 = 0 ;
26988 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26989 bool result;
26990 PyObject * obj0 = 0 ;
26991 PyObject * obj1 = 0 ;
26992 PyObject * obj2 = 0 ;
26993 char *kwnames[] = {
26994 (char *) "self",(char *) "format",(char *) "dir", NULL
26995 };
26996
26997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26999 if (SWIG_arg_fail(1)) SWIG_fail;
27000 {
27001 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27002 if (SWIG_arg_fail(2)) SWIG_fail;
27003 if (arg2 == NULL) {
27004 SWIG_null_ref("wxDataFormat");
27005 }
27006 if (SWIG_arg_fail(2)) SWIG_fail;
27007 }
27008 if (obj2) {
27009 {
27010 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27011 if (SWIG_arg_fail(3)) SWIG_fail;
27012 }
27013 }
27014 {
27015 PyThreadState* __tstate = wxPyBeginAllowThreads();
27016 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27017
27018 wxPyEndAllowThreads(__tstate);
27019 if (PyErr_Occurred()) SWIG_fail;
27020 }
27021 {
27022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27023 }
27024 return resultobj;
27025 fail:
27026 return NULL;
27027 }
27028
27029
27030 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27031 PyObject *resultobj;
27032 wxDataObject *arg1 = (wxDataObject *) 0 ;
27033 wxDataFormat *arg2 = 0 ;
27034 size_t result;
27035 PyObject * obj0 = 0 ;
27036 PyObject * obj1 = 0 ;
27037 char *kwnames[] = {
27038 (char *) "self",(char *) "format", NULL
27039 };
27040
27041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27043 if (SWIG_arg_fail(1)) SWIG_fail;
27044 {
27045 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27046 if (SWIG_arg_fail(2)) SWIG_fail;
27047 if (arg2 == NULL) {
27048 SWIG_null_ref("wxDataFormat");
27049 }
27050 if (SWIG_arg_fail(2)) SWIG_fail;
27051 }
27052 {
27053 PyThreadState* __tstate = wxPyBeginAllowThreads();
27054 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27055
27056 wxPyEndAllowThreads(__tstate);
27057 if (PyErr_Occurred()) SWIG_fail;
27058 }
27059 {
27060 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27061 }
27062 return resultobj;
27063 fail:
27064 return NULL;
27065 }
27066
27067
27068 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27069 PyObject *resultobj;
27070 wxDataObject *arg1 = (wxDataObject *) 0 ;
27071 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27072 PyObject *result;
27073 PyObject * obj0 = 0 ;
27074 PyObject * obj1 = 0 ;
27075 char *kwnames[] = {
27076 (char *) "self",(char *) "dir", NULL
27077 };
27078
27079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27081 if (SWIG_arg_fail(1)) SWIG_fail;
27082 if (obj1) {
27083 {
27084 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27085 if (SWIG_arg_fail(2)) SWIG_fail;
27086 }
27087 }
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27091
27092 wxPyEndAllowThreads(__tstate);
27093 if (PyErr_Occurred()) SWIG_fail;
27094 }
27095 resultobj = result;
27096 return resultobj;
27097 fail:
27098 return NULL;
27099 }
27100
27101
27102 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27103 PyObject *resultobj;
27104 wxDataObject *arg1 = (wxDataObject *) 0 ;
27105 wxDataFormat *arg2 = 0 ;
27106 PyObject *result;
27107 PyObject * obj0 = 0 ;
27108 PyObject * obj1 = 0 ;
27109 char *kwnames[] = {
27110 (char *) "self",(char *) "format", NULL
27111 };
27112
27113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27115 if (SWIG_arg_fail(1)) SWIG_fail;
27116 {
27117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27118 if (SWIG_arg_fail(2)) SWIG_fail;
27119 if (arg2 == NULL) {
27120 SWIG_null_ref("wxDataFormat");
27121 }
27122 if (SWIG_arg_fail(2)) SWIG_fail;
27123 }
27124 {
27125 PyThreadState* __tstate = wxPyBeginAllowThreads();
27126 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27127
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 resultobj = result;
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27139 PyObject *resultobj;
27140 wxDataObject *arg1 = (wxDataObject *) 0 ;
27141 wxDataFormat *arg2 = 0 ;
27142 PyObject *arg3 = (PyObject *) 0 ;
27143 bool result;
27144 PyObject * obj0 = 0 ;
27145 PyObject * obj1 = 0 ;
27146 PyObject * obj2 = 0 ;
27147 char *kwnames[] = {
27148 (char *) "self",(char *) "format",(char *) "data", NULL
27149 };
27150
27151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27153 if (SWIG_arg_fail(1)) SWIG_fail;
27154 {
27155 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27156 if (SWIG_arg_fail(2)) SWIG_fail;
27157 if (arg2 == NULL) {
27158 SWIG_null_ref("wxDataFormat");
27159 }
27160 if (SWIG_arg_fail(2)) SWIG_fail;
27161 }
27162 arg3 = obj2;
27163 {
27164 PyThreadState* __tstate = wxPyBeginAllowThreads();
27165 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27166
27167 wxPyEndAllowThreads(__tstate);
27168 if (PyErr_Occurred()) SWIG_fail;
27169 }
27170 {
27171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27172 }
27173 return resultobj;
27174 fail:
27175 return NULL;
27176 }
27177
27178
27179 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27180 PyObject *obj;
27181 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27182 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27183 Py_INCREF(obj);
27184 return Py_BuildValue((char *)"");
27185 }
27186 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27187 PyObject *resultobj;
27188 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27189 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27190 wxDataObjectSimple *result;
27191 PyObject * obj0 = 0 ;
27192 char *kwnames[] = {
27193 (char *) "format", NULL
27194 };
27195
27196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27197 if (obj0) {
27198 {
27199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27200 if (SWIG_arg_fail(1)) SWIG_fail;
27201 if (arg1 == NULL) {
27202 SWIG_null_ref("wxDataFormat");
27203 }
27204 if (SWIG_arg_fail(1)) SWIG_fail;
27205 }
27206 }
27207 {
27208 PyThreadState* __tstate = wxPyBeginAllowThreads();
27209 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27210
27211 wxPyEndAllowThreads(__tstate);
27212 if (PyErr_Occurred()) SWIG_fail;
27213 }
27214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27215 return resultobj;
27216 fail:
27217 return NULL;
27218 }
27219
27220
27221 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27222 PyObject *resultobj;
27223 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27224 wxDataFormat *result;
27225 PyObject * obj0 = 0 ;
27226 char *kwnames[] = {
27227 (char *) "self", NULL
27228 };
27229
27230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27232 if (SWIG_arg_fail(1)) SWIG_fail;
27233 {
27234 PyThreadState* __tstate = wxPyBeginAllowThreads();
27235 {
27236 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27237 result = (wxDataFormat *) &_result_ref;
27238 }
27239
27240 wxPyEndAllowThreads(__tstate);
27241 if (PyErr_Occurred()) SWIG_fail;
27242 }
27243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27244 return resultobj;
27245 fail:
27246 return NULL;
27247 }
27248
27249
27250 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27251 PyObject *resultobj;
27252 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27253 wxDataFormat *arg2 = 0 ;
27254 PyObject * obj0 = 0 ;
27255 PyObject * obj1 = 0 ;
27256 char *kwnames[] = {
27257 (char *) "self",(char *) "format", NULL
27258 };
27259
27260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27262 if (SWIG_arg_fail(1)) SWIG_fail;
27263 {
27264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27265 if (SWIG_arg_fail(2)) SWIG_fail;
27266 if (arg2 == NULL) {
27267 SWIG_null_ref("wxDataFormat");
27268 }
27269 if (SWIG_arg_fail(2)) SWIG_fail;
27270 }
27271 {
27272 PyThreadState* __tstate = wxPyBeginAllowThreads();
27273 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27274
27275 wxPyEndAllowThreads(__tstate);
27276 if (PyErr_Occurred()) SWIG_fail;
27277 }
27278 Py_INCREF(Py_None); resultobj = Py_None;
27279 return resultobj;
27280 fail:
27281 return NULL;
27282 }
27283
27284
27285 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27286 PyObject *resultobj;
27287 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27288 size_t result;
27289 PyObject * obj0 = 0 ;
27290 char *kwnames[] = {
27291 (char *) "self", NULL
27292 };
27293
27294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27296 if (SWIG_arg_fail(1)) SWIG_fail;
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27300
27301 wxPyEndAllowThreads(__tstate);
27302 if (PyErr_Occurred()) SWIG_fail;
27303 }
27304 {
27305 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27306 }
27307 return resultobj;
27308 fail:
27309 return NULL;
27310 }
27311
27312
27313 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27314 PyObject *resultobj;
27315 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27316 PyObject *result;
27317 PyObject * obj0 = 0 ;
27318 char *kwnames[] = {
27319 (char *) "self", NULL
27320 };
27321
27322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27324 if (SWIG_arg_fail(1)) SWIG_fail;
27325 {
27326 PyThreadState* __tstate = wxPyBeginAllowThreads();
27327 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27328
27329 wxPyEndAllowThreads(__tstate);
27330 if (PyErr_Occurred()) SWIG_fail;
27331 }
27332 resultobj = result;
27333 return resultobj;
27334 fail:
27335 return NULL;
27336 }
27337
27338
27339 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27340 PyObject *resultobj;
27341 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27342 PyObject *arg2 = (PyObject *) 0 ;
27343 bool result;
27344 PyObject * obj0 = 0 ;
27345 PyObject * obj1 = 0 ;
27346 char *kwnames[] = {
27347 (char *) "self",(char *) "data", NULL
27348 };
27349
27350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27352 if (SWIG_arg_fail(1)) SWIG_fail;
27353 arg2 = obj1;
27354 {
27355 PyThreadState* __tstate = wxPyBeginAllowThreads();
27356 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27357
27358 wxPyEndAllowThreads(__tstate);
27359 if (PyErr_Occurred()) SWIG_fail;
27360 }
27361 {
27362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27363 }
27364 return resultobj;
27365 fail:
27366 return NULL;
27367 }
27368
27369
27370 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27371 PyObject *obj;
27372 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27373 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27374 Py_INCREF(obj);
27375 return Py_BuildValue((char *)"");
27376 }
27377 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27378 PyObject *resultobj;
27379 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27380 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27381 wxPyDataObjectSimple *result;
27382 PyObject * obj0 = 0 ;
27383 char *kwnames[] = {
27384 (char *) "format", NULL
27385 };
27386
27387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27388 if (obj0) {
27389 {
27390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27391 if (SWIG_arg_fail(1)) SWIG_fail;
27392 if (arg1 == NULL) {
27393 SWIG_null_ref("wxDataFormat");
27394 }
27395 if (SWIG_arg_fail(1)) SWIG_fail;
27396 }
27397 }
27398 {
27399 PyThreadState* __tstate = wxPyBeginAllowThreads();
27400 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27401
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27406 return resultobj;
27407 fail:
27408 return NULL;
27409 }
27410
27411
27412 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27413 PyObject *resultobj;
27414 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27415 PyObject *arg2 = (PyObject *) 0 ;
27416 PyObject *arg3 = (PyObject *) 0 ;
27417 PyObject * obj0 = 0 ;
27418 PyObject * obj1 = 0 ;
27419 PyObject * obj2 = 0 ;
27420 char *kwnames[] = {
27421 (char *) "self",(char *) "self",(char *) "_class", NULL
27422 };
27423
27424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27426 if (SWIG_arg_fail(1)) SWIG_fail;
27427 arg2 = obj1;
27428 arg3 = obj2;
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 (arg1)->_setCallbackInfo(arg2,arg3);
27432
27433 wxPyEndAllowThreads(__tstate);
27434 if (PyErr_Occurred()) SWIG_fail;
27435 }
27436 Py_INCREF(Py_None); resultobj = Py_None;
27437 return resultobj;
27438 fail:
27439 return NULL;
27440 }
27441
27442
27443 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27444 PyObject *obj;
27445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27446 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27447 Py_INCREF(obj);
27448 return Py_BuildValue((char *)"");
27449 }
27450 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27451 PyObject *resultobj;
27452 wxDataObjectComposite *result;
27453 char *kwnames[] = {
27454 NULL
27455 };
27456
27457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27461
27462 wxPyEndAllowThreads(__tstate);
27463 if (PyErr_Occurred()) SWIG_fail;
27464 }
27465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27466 return resultobj;
27467 fail:
27468 return NULL;
27469 }
27470
27471
27472 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27473 PyObject *resultobj;
27474 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27475 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27476 bool arg3 = (bool) false ;
27477 PyObject * obj0 = 0 ;
27478 PyObject * obj1 = 0 ;
27479 PyObject * obj2 = 0 ;
27480 char *kwnames[] = {
27481 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27482 };
27483
27484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27486 if (SWIG_arg_fail(1)) SWIG_fail;
27487 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27488 if (SWIG_arg_fail(2)) SWIG_fail;
27489 if (obj2) {
27490 {
27491 arg3 = (bool)(SWIG_As_bool(obj2));
27492 if (SWIG_arg_fail(3)) SWIG_fail;
27493 }
27494 }
27495 {
27496 PyThreadState* __tstate = wxPyBeginAllowThreads();
27497 (arg1)->Add(arg2,arg3);
27498
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 Py_INCREF(Py_None); resultobj = Py_None;
27503 return resultobj;
27504 fail:
27505 return NULL;
27506 }
27507
27508
27509 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27510 PyObject *obj;
27511 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27512 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27513 Py_INCREF(obj);
27514 return Py_BuildValue((char *)"");
27515 }
27516 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27517 PyObject *resultobj;
27518 wxString const &arg1_defvalue = wxPyEmptyString ;
27519 wxString *arg1 = (wxString *) &arg1_defvalue ;
27520 wxTextDataObject *result;
27521 bool temp1 = false ;
27522 PyObject * obj0 = 0 ;
27523 char *kwnames[] = {
27524 (char *) "text", NULL
27525 };
27526
27527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27528 if (obj0) {
27529 {
27530 arg1 = wxString_in_helper(obj0);
27531 if (arg1 == NULL) SWIG_fail;
27532 temp1 = true;
27533 }
27534 }
27535 {
27536 PyThreadState* __tstate = wxPyBeginAllowThreads();
27537 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27538
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27543 {
27544 if (temp1)
27545 delete arg1;
27546 }
27547 return resultobj;
27548 fail:
27549 {
27550 if (temp1)
27551 delete arg1;
27552 }
27553 return NULL;
27554 }
27555
27556
27557 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27558 PyObject *resultobj;
27559 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27560 size_t result;
27561 PyObject * obj0 = 0 ;
27562 char *kwnames[] = {
27563 (char *) "self", NULL
27564 };
27565
27566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27568 if (SWIG_arg_fail(1)) SWIG_fail;
27569 {
27570 PyThreadState* __tstate = wxPyBeginAllowThreads();
27571 result = (size_t)(arg1)->GetTextLength();
27572
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 {
27577 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27578 }
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27586 PyObject *resultobj;
27587 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27588 wxString result;
27589 PyObject * obj0 = 0 ;
27590 char *kwnames[] = {
27591 (char *) "self", NULL
27592 };
27593
27594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27596 if (SWIG_arg_fail(1)) SWIG_fail;
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (arg1)->GetText();
27600
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 {
27605 #if wxUSE_UNICODE
27606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27607 #else
27608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27609 #endif
27610 }
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27618 PyObject *resultobj;
27619 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27620 wxString *arg2 = 0 ;
27621 bool temp2 = false ;
27622 PyObject * obj0 = 0 ;
27623 PyObject * obj1 = 0 ;
27624 char *kwnames[] = {
27625 (char *) "self",(char *) "text", NULL
27626 };
27627
27628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27630 if (SWIG_arg_fail(1)) SWIG_fail;
27631 {
27632 arg2 = wxString_in_helper(obj1);
27633 if (arg2 == NULL) SWIG_fail;
27634 temp2 = true;
27635 }
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 (arg1)->SetText((wxString const &)*arg2);
27639
27640 wxPyEndAllowThreads(__tstate);
27641 if (PyErr_Occurred()) SWIG_fail;
27642 }
27643 Py_INCREF(Py_None); resultobj = Py_None;
27644 {
27645 if (temp2)
27646 delete arg2;
27647 }
27648 return resultobj;
27649 fail:
27650 {
27651 if (temp2)
27652 delete arg2;
27653 }
27654 return NULL;
27655 }
27656
27657
27658 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27659 PyObject *obj;
27660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27661 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27662 Py_INCREF(obj);
27663 return Py_BuildValue((char *)"");
27664 }
27665 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27666 PyObject *resultobj;
27667 wxString const &arg1_defvalue = wxPyEmptyString ;
27668 wxString *arg1 = (wxString *) &arg1_defvalue ;
27669 wxPyTextDataObject *result;
27670 bool temp1 = false ;
27671 PyObject * obj0 = 0 ;
27672 char *kwnames[] = {
27673 (char *) "text", NULL
27674 };
27675
27676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27677 if (obj0) {
27678 {
27679 arg1 = wxString_in_helper(obj0);
27680 if (arg1 == NULL) SWIG_fail;
27681 temp1 = true;
27682 }
27683 }
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27687
27688 wxPyEndAllowThreads(__tstate);
27689 if (PyErr_Occurred()) SWIG_fail;
27690 }
27691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27692 {
27693 if (temp1)
27694 delete arg1;
27695 }
27696 return resultobj;
27697 fail:
27698 {
27699 if (temp1)
27700 delete arg1;
27701 }
27702 return NULL;
27703 }
27704
27705
27706 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27707 PyObject *resultobj;
27708 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27709 PyObject *arg2 = (PyObject *) 0 ;
27710 PyObject *arg3 = (PyObject *) 0 ;
27711 PyObject * obj0 = 0 ;
27712 PyObject * obj1 = 0 ;
27713 PyObject * obj2 = 0 ;
27714 char *kwnames[] = {
27715 (char *) "self",(char *) "self",(char *) "_class", NULL
27716 };
27717
27718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27720 if (SWIG_arg_fail(1)) SWIG_fail;
27721 arg2 = obj1;
27722 arg3 = obj2;
27723 {
27724 PyThreadState* __tstate = wxPyBeginAllowThreads();
27725 (arg1)->_setCallbackInfo(arg2,arg3);
27726
27727 wxPyEndAllowThreads(__tstate);
27728 if (PyErr_Occurred()) SWIG_fail;
27729 }
27730 Py_INCREF(Py_None); resultobj = Py_None;
27731 return resultobj;
27732 fail:
27733 return NULL;
27734 }
27735
27736
27737 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27738 PyObject *obj;
27739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27740 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27741 Py_INCREF(obj);
27742 return Py_BuildValue((char *)"");
27743 }
27744 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27745 PyObject *resultobj;
27746 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27747 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27748 wxBitmapDataObject *result;
27749 PyObject * obj0 = 0 ;
27750 char *kwnames[] = {
27751 (char *) "bitmap", NULL
27752 };
27753
27754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27755 if (obj0) {
27756 {
27757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27758 if (SWIG_arg_fail(1)) SWIG_fail;
27759 if (arg1 == NULL) {
27760 SWIG_null_ref("wxBitmap");
27761 }
27762 if (SWIG_arg_fail(1)) SWIG_fail;
27763 }
27764 }
27765 {
27766 PyThreadState* __tstate = wxPyBeginAllowThreads();
27767 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27768
27769 wxPyEndAllowThreads(__tstate);
27770 if (PyErr_Occurred()) SWIG_fail;
27771 }
27772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27773 return resultobj;
27774 fail:
27775 return NULL;
27776 }
27777
27778
27779 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27780 PyObject *resultobj;
27781 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27782 wxBitmap result;
27783 PyObject * obj0 = 0 ;
27784 char *kwnames[] = {
27785 (char *) "self", NULL
27786 };
27787
27788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27790 if (SWIG_arg_fail(1)) SWIG_fail;
27791 {
27792 PyThreadState* __tstate = wxPyBeginAllowThreads();
27793 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27794
27795 wxPyEndAllowThreads(__tstate);
27796 if (PyErr_Occurred()) SWIG_fail;
27797 }
27798 {
27799 wxBitmap * resultptr;
27800 resultptr = new wxBitmap((wxBitmap &)(result));
27801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27802 }
27803 return resultobj;
27804 fail:
27805 return NULL;
27806 }
27807
27808
27809 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27810 PyObject *resultobj;
27811 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27812 wxBitmap *arg2 = 0 ;
27813 PyObject * obj0 = 0 ;
27814 PyObject * obj1 = 0 ;
27815 char *kwnames[] = {
27816 (char *) "self",(char *) "bitmap", NULL
27817 };
27818
27819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27821 if (SWIG_arg_fail(1)) SWIG_fail;
27822 {
27823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27824 if (SWIG_arg_fail(2)) SWIG_fail;
27825 if (arg2 == NULL) {
27826 SWIG_null_ref("wxBitmap");
27827 }
27828 if (SWIG_arg_fail(2)) SWIG_fail;
27829 }
27830 {
27831 PyThreadState* __tstate = wxPyBeginAllowThreads();
27832 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27833
27834 wxPyEndAllowThreads(__tstate);
27835 if (PyErr_Occurred()) SWIG_fail;
27836 }
27837 Py_INCREF(Py_None); resultobj = Py_None;
27838 return resultobj;
27839 fail:
27840 return NULL;
27841 }
27842
27843
27844 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27845 PyObject *obj;
27846 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27847 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27848 Py_INCREF(obj);
27849 return Py_BuildValue((char *)"");
27850 }
27851 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27852 PyObject *resultobj;
27853 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27854 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27855 wxPyBitmapDataObject *result;
27856 PyObject * obj0 = 0 ;
27857 char *kwnames[] = {
27858 (char *) "bitmap", NULL
27859 };
27860
27861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27862 if (obj0) {
27863 {
27864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27865 if (SWIG_arg_fail(1)) SWIG_fail;
27866 if (arg1 == NULL) {
27867 SWIG_null_ref("wxBitmap");
27868 }
27869 if (SWIG_arg_fail(1)) SWIG_fail;
27870 }
27871 }
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27875
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27887 PyObject *resultobj;
27888 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27889 PyObject *arg2 = (PyObject *) 0 ;
27890 PyObject *arg3 = (PyObject *) 0 ;
27891 PyObject * obj0 = 0 ;
27892 PyObject * obj1 = 0 ;
27893 PyObject * obj2 = 0 ;
27894 char *kwnames[] = {
27895 (char *) "self",(char *) "self",(char *) "_class", NULL
27896 };
27897
27898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27900 if (SWIG_arg_fail(1)) SWIG_fail;
27901 arg2 = obj1;
27902 arg3 = obj2;
27903 {
27904 PyThreadState* __tstate = wxPyBeginAllowThreads();
27905 (arg1)->_setCallbackInfo(arg2,arg3);
27906
27907 wxPyEndAllowThreads(__tstate);
27908 if (PyErr_Occurred()) SWIG_fail;
27909 }
27910 Py_INCREF(Py_None); resultobj = Py_None;
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27918 PyObject *obj;
27919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27920 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27921 Py_INCREF(obj);
27922 return Py_BuildValue((char *)"");
27923 }
27924 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27925 PyObject *resultobj;
27926 wxFileDataObject *result;
27927 char *kwnames[] = {
27928 NULL
27929 };
27930
27931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27932 {
27933 PyThreadState* __tstate = wxPyBeginAllowThreads();
27934 result = (wxFileDataObject *)new wxFileDataObject();
27935
27936 wxPyEndAllowThreads(__tstate);
27937 if (PyErr_Occurred()) SWIG_fail;
27938 }
27939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27940 return resultobj;
27941 fail:
27942 return NULL;
27943 }
27944
27945
27946 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27947 PyObject *resultobj;
27948 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27949 wxArrayString *result;
27950 PyObject * obj0 = 0 ;
27951 char *kwnames[] = {
27952 (char *) "self", NULL
27953 };
27954
27955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27957 if (SWIG_arg_fail(1)) SWIG_fail;
27958 {
27959 PyThreadState* __tstate = wxPyBeginAllowThreads();
27960 {
27961 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27962 result = (wxArrayString *) &_result_ref;
27963 }
27964
27965 wxPyEndAllowThreads(__tstate);
27966 if (PyErr_Occurred()) SWIG_fail;
27967 }
27968 {
27969 resultobj = wxArrayString2PyList_helper(*result);
27970 }
27971 return resultobj;
27972 fail:
27973 return NULL;
27974 }
27975
27976
27977 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27978 PyObject *resultobj;
27979 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27980 wxString *arg2 = 0 ;
27981 bool temp2 = false ;
27982 PyObject * obj0 = 0 ;
27983 PyObject * obj1 = 0 ;
27984 char *kwnames[] = {
27985 (char *) "self",(char *) "filename", NULL
27986 };
27987
27988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27990 if (SWIG_arg_fail(1)) SWIG_fail;
27991 {
27992 arg2 = wxString_in_helper(obj1);
27993 if (arg2 == NULL) SWIG_fail;
27994 temp2 = true;
27995 }
27996 {
27997 PyThreadState* __tstate = wxPyBeginAllowThreads();
27998 (arg1)->AddFile((wxString const &)*arg2);
27999
28000 wxPyEndAllowThreads(__tstate);
28001 if (PyErr_Occurred()) SWIG_fail;
28002 }
28003 Py_INCREF(Py_None); resultobj = Py_None;
28004 {
28005 if (temp2)
28006 delete arg2;
28007 }
28008 return resultobj;
28009 fail:
28010 {
28011 if (temp2)
28012 delete arg2;
28013 }
28014 return NULL;
28015 }
28016
28017
28018 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28019 PyObject *obj;
28020 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28021 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28022 Py_INCREF(obj);
28023 return Py_BuildValue((char *)"");
28024 }
28025 static PyObject *_wrap_new_CustomDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28026 PyObject *resultobj;
28027 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28028 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28029 wxCustomDataObject *result;
28030 PyObject * obj0 = 0 ;
28031 char *kwnames[] = {
28032 (char *) "format", NULL
28033 };
28034
28035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_CustomDataObject",kwnames,&obj0)) goto fail;
28036 if (obj0) {
28037 {
28038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28039 if (SWIG_arg_fail(1)) SWIG_fail;
28040 if (arg1 == NULL) {
28041 SWIG_null_ref("wxDataFormat");
28042 }
28043 if (SWIG_arg_fail(1)) SWIG_fail;
28044 }
28045 }
28046 {
28047 PyThreadState* __tstate = wxPyBeginAllowThreads();
28048 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28049
28050 wxPyEndAllowThreads(__tstate);
28051 if (PyErr_Occurred()) SWIG_fail;
28052 }
28053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28054 return resultobj;
28055 fail:
28056 return NULL;
28057 }
28058
28059
28060 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28061 PyObject *resultobj;
28062 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28063 PyObject *arg2 = (PyObject *) 0 ;
28064 bool result;
28065 PyObject * obj0 = 0 ;
28066 PyObject * obj1 = 0 ;
28067 char *kwnames[] = {
28068 (char *) "self",(char *) "data", NULL
28069 };
28070
28071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28073 if (SWIG_arg_fail(1)) SWIG_fail;
28074 arg2 = obj1;
28075 {
28076 PyThreadState* __tstate = wxPyBeginAllowThreads();
28077 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28078
28079 wxPyEndAllowThreads(__tstate);
28080 if (PyErr_Occurred()) SWIG_fail;
28081 }
28082 {
28083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28084 }
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28092 PyObject *resultobj;
28093 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28094 size_t result;
28095 PyObject * obj0 = 0 ;
28096 char *kwnames[] = {
28097 (char *) "self", NULL
28098 };
28099
28100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28102 if (SWIG_arg_fail(1)) SWIG_fail;
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 result = (size_t)(arg1)->GetSize();
28106
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 {
28111 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28112 }
28113 return resultobj;
28114 fail:
28115 return NULL;
28116 }
28117
28118
28119 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28120 PyObject *resultobj;
28121 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28122 PyObject *result;
28123 PyObject * obj0 = 0 ;
28124 char *kwnames[] = {
28125 (char *) "self", NULL
28126 };
28127
28128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28130 if (SWIG_arg_fail(1)) SWIG_fail;
28131 {
28132 PyThreadState* __tstate = wxPyBeginAllowThreads();
28133 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28134
28135 wxPyEndAllowThreads(__tstate);
28136 if (PyErr_Occurred()) SWIG_fail;
28137 }
28138 resultobj = result;
28139 return resultobj;
28140 fail:
28141 return NULL;
28142 }
28143
28144
28145 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28146 PyObject *obj;
28147 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28148 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28149 Py_INCREF(obj);
28150 return Py_BuildValue((char *)"");
28151 }
28152 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28153 PyObject *resultobj;
28154 wxURLDataObject *result;
28155 char *kwnames[] = {
28156 NULL
28157 };
28158
28159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28160 {
28161 PyThreadState* __tstate = wxPyBeginAllowThreads();
28162 result = (wxURLDataObject *)new wxURLDataObject();
28163
28164 wxPyEndAllowThreads(__tstate);
28165 if (PyErr_Occurred()) SWIG_fail;
28166 }
28167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28168 return resultobj;
28169 fail:
28170 return NULL;
28171 }
28172
28173
28174 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28175 PyObject *resultobj;
28176 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28177 wxString result;
28178 PyObject * obj0 = 0 ;
28179 char *kwnames[] = {
28180 (char *) "self", NULL
28181 };
28182
28183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28185 if (SWIG_arg_fail(1)) SWIG_fail;
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 result = (arg1)->GetURL();
28189
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 {
28194 #if wxUSE_UNICODE
28195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28196 #else
28197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28198 #endif
28199 }
28200 return resultobj;
28201 fail:
28202 return NULL;
28203 }
28204
28205
28206 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28207 PyObject *resultobj;
28208 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28209 wxString *arg2 = 0 ;
28210 bool temp2 = false ;
28211 PyObject * obj0 = 0 ;
28212 PyObject * obj1 = 0 ;
28213 char *kwnames[] = {
28214 (char *) "self",(char *) "url", NULL
28215 };
28216
28217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28219 if (SWIG_arg_fail(1)) SWIG_fail;
28220 {
28221 arg2 = wxString_in_helper(obj1);
28222 if (arg2 == NULL) SWIG_fail;
28223 temp2 = true;
28224 }
28225 {
28226 PyThreadState* __tstate = wxPyBeginAllowThreads();
28227 (arg1)->SetURL((wxString const &)*arg2);
28228
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 Py_INCREF(Py_None); resultobj = Py_None;
28233 {
28234 if (temp2)
28235 delete arg2;
28236 }
28237 return resultobj;
28238 fail:
28239 {
28240 if (temp2)
28241 delete arg2;
28242 }
28243 return NULL;
28244 }
28245
28246
28247 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28248 PyObject *obj;
28249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28250 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28251 Py_INCREF(obj);
28252 return Py_BuildValue((char *)"");
28253 }
28254 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj;
28256 wxMetafileDataObject *result;
28257 char *kwnames[] = {
28258 NULL
28259 };
28260
28261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28265
28266 wxPyEndAllowThreads(__tstate);
28267 if (PyErr_Occurred()) SWIG_fail;
28268 }
28269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28270 return resultobj;
28271 fail:
28272 return NULL;
28273 }
28274
28275
28276 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28277 PyObject *resultobj;
28278 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28279 wxMetafile *arg2 = 0 ;
28280 PyObject * obj0 = 0 ;
28281 PyObject * obj1 = 0 ;
28282 char *kwnames[] = {
28283 (char *) "self",(char *) "metafile", NULL
28284 };
28285
28286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28288 if (SWIG_arg_fail(1)) SWIG_fail;
28289 {
28290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28291 if (SWIG_arg_fail(2)) SWIG_fail;
28292 if (arg2 == NULL) {
28293 SWIG_null_ref("wxMetafile");
28294 }
28295 if (SWIG_arg_fail(2)) SWIG_fail;
28296 }
28297 {
28298 PyThreadState* __tstate = wxPyBeginAllowThreads();
28299 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28300
28301 wxPyEndAllowThreads(__tstate);
28302 if (PyErr_Occurred()) SWIG_fail;
28303 }
28304 Py_INCREF(Py_None); resultobj = Py_None;
28305 return resultobj;
28306 fail:
28307 return NULL;
28308 }
28309
28310
28311 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28312 PyObject *resultobj;
28313 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28314 wxMetafile result;
28315 PyObject * obj0 = 0 ;
28316 char *kwnames[] = {
28317 (char *) "self", NULL
28318 };
28319
28320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28322 if (SWIG_arg_fail(1)) SWIG_fail;
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28326
28327 wxPyEndAllowThreads(__tstate);
28328 if (PyErr_Occurred()) SWIG_fail;
28329 }
28330 {
28331 wxMetafile * resultptr;
28332 resultptr = new wxMetafile((wxMetafile &)(result));
28333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28334 }
28335 return resultobj;
28336 fail:
28337 return NULL;
28338 }
28339
28340
28341 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28342 PyObject *obj;
28343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28344 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28345 Py_INCREF(obj);
28346 return Py_BuildValue((char *)"");
28347 }
28348 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28349 PyObject *resultobj;
28350 wxDragResult arg1 ;
28351 bool result;
28352 PyObject * obj0 = 0 ;
28353 char *kwnames[] = {
28354 (char *) "res", NULL
28355 };
28356
28357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28358 {
28359 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28360 if (SWIG_arg_fail(1)) SWIG_fail;
28361 }
28362 {
28363 PyThreadState* __tstate = wxPyBeginAllowThreads();
28364 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28365
28366 wxPyEndAllowThreads(__tstate);
28367 if (PyErr_Occurred()) SWIG_fail;
28368 }
28369 {
28370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28371 }
28372 return resultobj;
28373 fail:
28374 return NULL;
28375 }
28376
28377
28378 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28379 PyObject *resultobj;
28380 wxWindow *arg1 = (wxWindow *) 0 ;
28381 wxCursor const &arg2_defvalue = wxNullCursor ;
28382 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28383 wxCursor const &arg3_defvalue = wxNullCursor ;
28384 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28385 wxCursor const &arg4_defvalue = wxNullCursor ;
28386 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28387 wxPyDropSource *result;
28388 PyObject * obj0 = 0 ;
28389 PyObject * obj1 = 0 ;
28390 PyObject * obj2 = 0 ;
28391 PyObject * obj3 = 0 ;
28392 char *kwnames[] = {
28393 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28394 };
28395
28396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28398 if (SWIG_arg_fail(1)) SWIG_fail;
28399 if (obj1) {
28400 {
28401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28402 if (SWIG_arg_fail(2)) SWIG_fail;
28403 if (arg2 == NULL) {
28404 SWIG_null_ref("wxCursor");
28405 }
28406 if (SWIG_arg_fail(2)) SWIG_fail;
28407 }
28408 }
28409 if (obj2) {
28410 {
28411 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28412 if (SWIG_arg_fail(3)) SWIG_fail;
28413 if (arg3 == NULL) {
28414 SWIG_null_ref("wxCursor");
28415 }
28416 if (SWIG_arg_fail(3)) SWIG_fail;
28417 }
28418 }
28419 if (obj3) {
28420 {
28421 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28422 if (SWIG_arg_fail(4)) SWIG_fail;
28423 if (arg4 == NULL) {
28424 SWIG_null_ref("wxCursor");
28425 }
28426 if (SWIG_arg_fail(4)) SWIG_fail;
28427 }
28428 }
28429 {
28430 PyThreadState* __tstate = wxPyBeginAllowThreads();
28431 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28432
28433 wxPyEndAllowThreads(__tstate);
28434 if (PyErr_Occurred()) SWIG_fail;
28435 }
28436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28444 PyObject *resultobj;
28445 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28446 PyObject *arg2 = (PyObject *) 0 ;
28447 PyObject *arg3 = (PyObject *) 0 ;
28448 int arg4 ;
28449 PyObject * obj0 = 0 ;
28450 PyObject * obj1 = 0 ;
28451 PyObject * obj2 = 0 ;
28452 PyObject * obj3 = 0 ;
28453 char *kwnames[] = {
28454 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28455 };
28456
28457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28459 if (SWIG_arg_fail(1)) SWIG_fail;
28460 arg2 = obj1;
28461 arg3 = obj2;
28462 {
28463 arg4 = (int)(SWIG_As_int(obj3));
28464 if (SWIG_arg_fail(4)) SWIG_fail;
28465 }
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28469
28470 wxPyEndAllowThreads(__tstate);
28471 if (PyErr_Occurred()) SWIG_fail;
28472 }
28473 Py_INCREF(Py_None); resultobj = Py_None;
28474 return resultobj;
28475 fail:
28476 return NULL;
28477 }
28478
28479
28480 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28481 PyObject *resultobj;
28482 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28483 PyObject * obj0 = 0 ;
28484 char *kwnames[] = {
28485 (char *) "self", NULL
28486 };
28487
28488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28490 if (SWIG_arg_fail(1)) SWIG_fail;
28491 {
28492 PyThreadState* __tstate = wxPyBeginAllowThreads();
28493 delete arg1;
28494
28495 wxPyEndAllowThreads(__tstate);
28496 if (PyErr_Occurred()) SWIG_fail;
28497 }
28498 Py_INCREF(Py_None); resultobj = Py_None;
28499 return resultobj;
28500 fail:
28501 return NULL;
28502 }
28503
28504
28505 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28506 PyObject *resultobj;
28507 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28508 wxDataObject *arg2 = 0 ;
28509 PyObject * obj0 = 0 ;
28510 PyObject * obj1 = 0 ;
28511 char *kwnames[] = {
28512 (char *) "self",(char *) "data", NULL
28513 };
28514
28515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28517 if (SWIG_arg_fail(1)) SWIG_fail;
28518 {
28519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28520 if (SWIG_arg_fail(2)) SWIG_fail;
28521 if (arg2 == NULL) {
28522 SWIG_null_ref("wxDataObject");
28523 }
28524 if (SWIG_arg_fail(2)) SWIG_fail;
28525 }
28526 {
28527 PyThreadState* __tstate = wxPyBeginAllowThreads();
28528 (arg1)->SetData(*arg2);
28529
28530 wxPyEndAllowThreads(__tstate);
28531 if (PyErr_Occurred()) SWIG_fail;
28532 }
28533 Py_INCREF(Py_None); resultobj = Py_None;
28534 return resultobj;
28535 fail:
28536 return NULL;
28537 }
28538
28539
28540 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28541 PyObject *resultobj;
28542 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28543 wxDataObject *result;
28544 PyObject * obj0 = 0 ;
28545 char *kwnames[] = {
28546 (char *) "self", NULL
28547 };
28548
28549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28551 if (SWIG_arg_fail(1)) SWIG_fail;
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 result = (wxDataObject *)(arg1)->GetDataObject();
28555
28556 wxPyEndAllowThreads(__tstate);
28557 if (PyErr_Occurred()) SWIG_fail;
28558 }
28559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28560 return resultobj;
28561 fail:
28562 return NULL;
28563 }
28564
28565
28566 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28567 PyObject *resultobj;
28568 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28569 wxDragResult arg2 ;
28570 wxCursor *arg3 = 0 ;
28571 PyObject * obj0 = 0 ;
28572 PyObject * obj1 = 0 ;
28573 PyObject * obj2 = 0 ;
28574 char *kwnames[] = {
28575 (char *) "self",(char *) "res",(char *) "cursor", NULL
28576 };
28577
28578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28580 if (SWIG_arg_fail(1)) SWIG_fail;
28581 {
28582 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28583 if (SWIG_arg_fail(2)) SWIG_fail;
28584 }
28585 {
28586 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28587 if (SWIG_arg_fail(3)) SWIG_fail;
28588 if (arg3 == NULL) {
28589 SWIG_null_ref("wxCursor");
28590 }
28591 if (SWIG_arg_fail(3)) SWIG_fail;
28592 }
28593 {
28594 PyThreadState* __tstate = wxPyBeginAllowThreads();
28595 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
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_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28608 PyObject *resultobj;
28609 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28610 int arg2 = (int) wxDrag_CopyOnly ;
28611 wxDragResult result;
28612 PyObject * obj0 = 0 ;
28613 PyObject * obj1 = 0 ;
28614 char *kwnames[] = {
28615 (char *) "self",(char *) "flags", NULL
28616 };
28617
28618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28620 if (SWIG_arg_fail(1)) SWIG_fail;
28621 if (obj1) {
28622 {
28623 arg2 = (int)(SWIG_As_int(obj1));
28624 if (SWIG_arg_fail(2)) SWIG_fail;
28625 }
28626 }
28627 {
28628 PyThreadState* __tstate = wxPyBeginAllowThreads();
28629 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28630
28631 wxPyEndAllowThreads(__tstate);
28632 if (PyErr_Occurred()) SWIG_fail;
28633 }
28634 resultobj = SWIG_From_int((result));
28635 return resultobj;
28636 fail:
28637 return NULL;
28638 }
28639
28640
28641 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28642 PyObject *resultobj;
28643 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28644 wxDragResult arg2 ;
28645 bool result;
28646 PyObject * obj0 = 0 ;
28647 PyObject * obj1 = 0 ;
28648 char *kwnames[] = {
28649 (char *) "self",(char *) "effect", NULL
28650 };
28651
28652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28654 if (SWIG_arg_fail(1)) SWIG_fail;
28655 {
28656 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28657 if (SWIG_arg_fail(2)) SWIG_fail;
28658 }
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28662
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 {
28667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28668 }
28669 return resultobj;
28670 fail:
28671 return NULL;
28672 }
28673
28674
28675 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28676 PyObject *obj;
28677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28678 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28679 Py_INCREF(obj);
28680 return Py_BuildValue((char *)"");
28681 }
28682 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28683 PyObject *resultobj;
28684 wxDataObject *arg1 = (wxDataObject *) NULL ;
28685 wxPyDropTarget *result;
28686 PyObject * obj0 = 0 ;
28687 char *kwnames[] = {
28688 (char *) "dataObject", NULL
28689 };
28690
28691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28692 if (obj0) {
28693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28694 if (SWIG_arg_fail(1)) SWIG_fail;
28695 }
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28699
28700 wxPyEndAllowThreads(__tstate);
28701 if (PyErr_Occurred()) SWIG_fail;
28702 }
28703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28704 return resultobj;
28705 fail:
28706 return NULL;
28707 }
28708
28709
28710 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28711 PyObject *resultobj;
28712 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28713 PyObject *arg2 = (PyObject *) 0 ;
28714 PyObject *arg3 = (PyObject *) 0 ;
28715 PyObject * obj0 = 0 ;
28716 PyObject * obj1 = 0 ;
28717 PyObject * obj2 = 0 ;
28718 char *kwnames[] = {
28719 (char *) "self",(char *) "self",(char *) "_class", NULL
28720 };
28721
28722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28724 if (SWIG_arg_fail(1)) SWIG_fail;
28725 arg2 = obj1;
28726 arg3 = obj2;
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 (arg1)->_setCallbackInfo(arg2,arg3);
28730
28731 wxPyEndAllowThreads(__tstate);
28732 if (PyErr_Occurred()) SWIG_fail;
28733 }
28734 Py_INCREF(Py_None); resultobj = Py_None;
28735 return resultobj;
28736 fail:
28737 return NULL;
28738 }
28739
28740
28741 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28742 PyObject *resultobj;
28743 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28744 PyObject * obj0 = 0 ;
28745 char *kwnames[] = {
28746 (char *) "self", NULL
28747 };
28748
28749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28751 if (SWIG_arg_fail(1)) SWIG_fail;
28752 {
28753 PyThreadState* __tstate = wxPyBeginAllowThreads();
28754 delete arg1;
28755
28756 wxPyEndAllowThreads(__tstate);
28757 if (PyErr_Occurred()) SWIG_fail;
28758 }
28759 Py_INCREF(Py_None); resultobj = Py_None;
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj;
28768 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28769 wxDataObject *result;
28770 PyObject * obj0 = 0 ;
28771 char *kwnames[] = {
28772 (char *) "self", NULL
28773 };
28774
28775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28777 if (SWIG_arg_fail(1)) SWIG_fail;
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 result = (wxDataObject *)(arg1)->GetDataObject();
28781
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28786 return resultobj;
28787 fail:
28788 return NULL;
28789 }
28790
28791
28792 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28793 PyObject *resultobj;
28794 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28795 wxDataObject *arg2 = (wxDataObject *) 0 ;
28796 PyObject * obj0 = 0 ;
28797 PyObject * obj1 = 0 ;
28798 char *kwnames[] = {
28799 (char *) "self",(char *) "dataObject", NULL
28800 };
28801
28802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28804 if (SWIG_arg_fail(1)) SWIG_fail;
28805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28806 if (SWIG_arg_fail(2)) SWIG_fail;
28807 {
28808 PyThreadState* __tstate = wxPyBeginAllowThreads();
28809 (arg1)->SetDataObject(arg2);
28810
28811 wxPyEndAllowThreads(__tstate);
28812 if (PyErr_Occurred()) SWIG_fail;
28813 }
28814 Py_INCREF(Py_None); resultobj = Py_None;
28815 return resultobj;
28816 fail:
28817 return NULL;
28818 }
28819
28820
28821 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28822 PyObject *resultobj;
28823 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28824 int arg2 ;
28825 int arg3 ;
28826 wxDragResult arg4 ;
28827 wxDragResult result;
28828 PyObject * obj0 = 0 ;
28829 PyObject * obj1 = 0 ;
28830 PyObject * obj2 = 0 ;
28831 PyObject * obj3 = 0 ;
28832 char *kwnames[] = {
28833 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28834 };
28835
28836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28838 if (SWIG_arg_fail(1)) SWIG_fail;
28839 {
28840 arg2 = (int)(SWIG_As_int(obj1));
28841 if (SWIG_arg_fail(2)) SWIG_fail;
28842 }
28843 {
28844 arg3 = (int)(SWIG_As_int(obj2));
28845 if (SWIG_arg_fail(3)) SWIG_fail;
28846 }
28847 {
28848 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28849 if (SWIG_arg_fail(4)) SWIG_fail;
28850 }
28851 {
28852 PyThreadState* __tstate = wxPyBeginAllowThreads();
28853 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28854
28855 wxPyEndAllowThreads(__tstate);
28856 if (PyErr_Occurred()) SWIG_fail;
28857 }
28858 resultobj = SWIG_From_int((result));
28859 return resultobj;
28860 fail:
28861 return NULL;
28862 }
28863
28864
28865 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28866 PyObject *resultobj;
28867 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28868 int arg2 ;
28869 int arg3 ;
28870 wxDragResult arg4 ;
28871 wxDragResult result;
28872 PyObject * obj0 = 0 ;
28873 PyObject * obj1 = 0 ;
28874 PyObject * obj2 = 0 ;
28875 PyObject * obj3 = 0 ;
28876 char *kwnames[] = {
28877 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28878 };
28879
28880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28882 if (SWIG_arg_fail(1)) SWIG_fail;
28883 {
28884 arg2 = (int)(SWIG_As_int(obj1));
28885 if (SWIG_arg_fail(2)) SWIG_fail;
28886 }
28887 {
28888 arg3 = (int)(SWIG_As_int(obj2));
28889 if (SWIG_arg_fail(3)) SWIG_fail;
28890 }
28891 {
28892 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28893 if (SWIG_arg_fail(4)) SWIG_fail;
28894 }
28895 {
28896 PyThreadState* __tstate = wxPyBeginAllowThreads();
28897 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28898
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 resultobj = SWIG_From_int((result));
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28910 PyObject *resultobj;
28911 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28912 PyObject * obj0 = 0 ;
28913 char *kwnames[] = {
28914 (char *) "self", NULL
28915 };
28916
28917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28919 if (SWIG_arg_fail(1)) SWIG_fail;
28920 {
28921 PyThreadState* __tstate = wxPyBeginAllowThreads();
28922 (arg1)->base_OnLeave();
28923
28924 wxPyEndAllowThreads(__tstate);
28925 if (PyErr_Occurred()) SWIG_fail;
28926 }
28927 Py_INCREF(Py_None); resultobj = Py_None;
28928 return resultobj;
28929 fail:
28930 return NULL;
28931 }
28932
28933
28934 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28935 PyObject *resultobj;
28936 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28937 int arg2 ;
28938 int arg3 ;
28939 bool result;
28940 PyObject * obj0 = 0 ;
28941 PyObject * obj1 = 0 ;
28942 PyObject * obj2 = 0 ;
28943 char *kwnames[] = {
28944 (char *) "self",(char *) "x",(char *) "y", NULL
28945 };
28946
28947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28949 if (SWIG_arg_fail(1)) SWIG_fail;
28950 {
28951 arg2 = (int)(SWIG_As_int(obj1));
28952 if (SWIG_arg_fail(2)) SWIG_fail;
28953 }
28954 {
28955 arg3 = (int)(SWIG_As_int(obj2));
28956 if (SWIG_arg_fail(3)) SWIG_fail;
28957 }
28958 {
28959 PyThreadState* __tstate = wxPyBeginAllowThreads();
28960 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28961
28962 wxPyEndAllowThreads(__tstate);
28963 if (PyErr_Occurred()) SWIG_fail;
28964 }
28965 {
28966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28967 }
28968 return resultobj;
28969 fail:
28970 return NULL;
28971 }
28972
28973
28974 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28975 PyObject *resultobj;
28976 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28977 bool result;
28978 PyObject * obj0 = 0 ;
28979 char *kwnames[] = {
28980 (char *) "self", NULL
28981 };
28982
28983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28985 if (SWIG_arg_fail(1)) SWIG_fail;
28986 {
28987 PyThreadState* __tstate = wxPyBeginAllowThreads();
28988 result = (bool)(arg1)->GetData();
28989
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 {
28994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28995 }
28996 return resultobj;
28997 fail:
28998 return NULL;
28999 }
29000
29001
29002 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29003 PyObject *obj;
29004 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29005 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29006 Py_INCREF(obj);
29007 return Py_BuildValue((char *)"");
29008 }
29009 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29010 PyObject *resultobj;
29011 wxPyTextDropTarget *result;
29012 char *kwnames[] = {
29013 NULL
29014 };
29015
29016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29017 {
29018 PyThreadState* __tstate = wxPyBeginAllowThreads();
29019 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29020
29021 wxPyEndAllowThreads(__tstate);
29022 if (PyErr_Occurred()) SWIG_fail;
29023 }
29024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29025 return resultobj;
29026 fail:
29027 return NULL;
29028 }
29029
29030
29031 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29032 PyObject *resultobj;
29033 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29034 PyObject *arg2 = (PyObject *) 0 ;
29035 PyObject *arg3 = (PyObject *) 0 ;
29036 PyObject * obj0 = 0 ;
29037 PyObject * obj1 = 0 ;
29038 PyObject * obj2 = 0 ;
29039 char *kwnames[] = {
29040 (char *) "self",(char *) "self",(char *) "_class", NULL
29041 };
29042
29043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29045 if (SWIG_arg_fail(1)) SWIG_fail;
29046 arg2 = obj1;
29047 arg3 = obj2;
29048 {
29049 PyThreadState* __tstate = wxPyBeginAllowThreads();
29050 (arg1)->_setCallbackInfo(arg2,arg3);
29051
29052 wxPyEndAllowThreads(__tstate);
29053 if (PyErr_Occurred()) SWIG_fail;
29054 }
29055 Py_INCREF(Py_None); resultobj = Py_None;
29056 return resultobj;
29057 fail:
29058 return NULL;
29059 }
29060
29061
29062 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29063 PyObject *resultobj;
29064 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29065 int arg2 ;
29066 int arg3 ;
29067 wxDragResult arg4 ;
29068 wxDragResult result;
29069 PyObject * obj0 = 0 ;
29070 PyObject * obj1 = 0 ;
29071 PyObject * obj2 = 0 ;
29072 PyObject * obj3 = 0 ;
29073 char *kwnames[] = {
29074 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29075 };
29076
29077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29079 if (SWIG_arg_fail(1)) SWIG_fail;
29080 {
29081 arg2 = (int)(SWIG_As_int(obj1));
29082 if (SWIG_arg_fail(2)) SWIG_fail;
29083 }
29084 {
29085 arg3 = (int)(SWIG_As_int(obj2));
29086 if (SWIG_arg_fail(3)) SWIG_fail;
29087 }
29088 {
29089 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29090 if (SWIG_arg_fail(4)) SWIG_fail;
29091 }
29092 {
29093 PyThreadState* __tstate = wxPyBeginAllowThreads();
29094 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29095
29096 wxPyEndAllowThreads(__tstate);
29097 if (PyErr_Occurred()) SWIG_fail;
29098 }
29099 resultobj = SWIG_From_int((result));
29100 return resultobj;
29101 fail:
29102 return NULL;
29103 }
29104
29105
29106 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29107 PyObject *resultobj;
29108 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29109 int arg2 ;
29110 int arg3 ;
29111 wxDragResult arg4 ;
29112 wxDragResult result;
29113 PyObject * obj0 = 0 ;
29114 PyObject * obj1 = 0 ;
29115 PyObject * obj2 = 0 ;
29116 PyObject * obj3 = 0 ;
29117 char *kwnames[] = {
29118 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29119 };
29120
29121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29123 if (SWIG_arg_fail(1)) SWIG_fail;
29124 {
29125 arg2 = (int)(SWIG_As_int(obj1));
29126 if (SWIG_arg_fail(2)) SWIG_fail;
29127 }
29128 {
29129 arg3 = (int)(SWIG_As_int(obj2));
29130 if (SWIG_arg_fail(3)) SWIG_fail;
29131 }
29132 {
29133 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29134 if (SWIG_arg_fail(4)) SWIG_fail;
29135 }
29136 {
29137 PyThreadState* __tstate = wxPyBeginAllowThreads();
29138 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29139
29140 wxPyEndAllowThreads(__tstate);
29141 if (PyErr_Occurred()) SWIG_fail;
29142 }
29143 resultobj = SWIG_From_int((result));
29144 return resultobj;
29145 fail:
29146 return NULL;
29147 }
29148
29149
29150 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29151 PyObject *resultobj;
29152 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29153 PyObject * obj0 = 0 ;
29154 char *kwnames[] = {
29155 (char *) "self", NULL
29156 };
29157
29158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29160 if (SWIG_arg_fail(1)) SWIG_fail;
29161 {
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 (arg1)->base_OnLeave();
29164
29165 wxPyEndAllowThreads(__tstate);
29166 if (PyErr_Occurred()) SWIG_fail;
29167 }
29168 Py_INCREF(Py_None); resultobj = Py_None;
29169 return resultobj;
29170 fail:
29171 return NULL;
29172 }
29173
29174
29175 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29176 PyObject *resultobj;
29177 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29178 int arg2 ;
29179 int arg3 ;
29180 bool result;
29181 PyObject * obj0 = 0 ;
29182 PyObject * obj1 = 0 ;
29183 PyObject * obj2 = 0 ;
29184 char *kwnames[] = {
29185 (char *) "self",(char *) "x",(char *) "y", NULL
29186 };
29187
29188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29190 if (SWIG_arg_fail(1)) SWIG_fail;
29191 {
29192 arg2 = (int)(SWIG_As_int(obj1));
29193 if (SWIG_arg_fail(2)) SWIG_fail;
29194 }
29195 {
29196 arg3 = (int)(SWIG_As_int(obj2));
29197 if (SWIG_arg_fail(3)) SWIG_fail;
29198 }
29199 {
29200 PyThreadState* __tstate = wxPyBeginAllowThreads();
29201 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29202
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 {
29207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29208 }
29209 return resultobj;
29210 fail:
29211 return NULL;
29212 }
29213
29214
29215 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29216 PyObject *resultobj;
29217 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29218 int arg2 ;
29219 int arg3 ;
29220 wxDragResult arg4 ;
29221 wxDragResult result;
29222 PyObject * obj0 = 0 ;
29223 PyObject * obj1 = 0 ;
29224 PyObject * obj2 = 0 ;
29225 PyObject * obj3 = 0 ;
29226 char *kwnames[] = {
29227 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29228 };
29229
29230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29232 if (SWIG_arg_fail(1)) SWIG_fail;
29233 {
29234 arg2 = (int)(SWIG_As_int(obj1));
29235 if (SWIG_arg_fail(2)) SWIG_fail;
29236 }
29237 {
29238 arg3 = (int)(SWIG_As_int(obj2));
29239 if (SWIG_arg_fail(3)) SWIG_fail;
29240 }
29241 {
29242 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29243 if (SWIG_arg_fail(4)) SWIG_fail;
29244 }
29245 {
29246 PyThreadState* __tstate = wxPyBeginAllowThreads();
29247 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29248
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 resultobj = SWIG_From_int((result));
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29260 PyObject *obj;
29261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29262 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29263 Py_INCREF(obj);
29264 return Py_BuildValue((char *)"");
29265 }
29266 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29267 PyObject *resultobj;
29268 wxPyFileDropTarget *result;
29269 char *kwnames[] = {
29270 NULL
29271 };
29272
29273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29274 {
29275 PyThreadState* __tstate = wxPyBeginAllowThreads();
29276 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29277
29278 wxPyEndAllowThreads(__tstate);
29279 if (PyErr_Occurred()) SWIG_fail;
29280 }
29281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29282 return resultobj;
29283 fail:
29284 return NULL;
29285 }
29286
29287
29288 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29289 PyObject *resultobj;
29290 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29291 PyObject *arg2 = (PyObject *) 0 ;
29292 PyObject *arg3 = (PyObject *) 0 ;
29293 PyObject * obj0 = 0 ;
29294 PyObject * obj1 = 0 ;
29295 PyObject * obj2 = 0 ;
29296 char *kwnames[] = {
29297 (char *) "self",(char *) "self",(char *) "_class", NULL
29298 };
29299
29300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29302 if (SWIG_arg_fail(1)) SWIG_fail;
29303 arg2 = obj1;
29304 arg3 = obj2;
29305 {
29306 PyThreadState* __tstate = wxPyBeginAllowThreads();
29307 (arg1)->_setCallbackInfo(arg2,arg3);
29308
29309 wxPyEndAllowThreads(__tstate);
29310 if (PyErr_Occurred()) SWIG_fail;
29311 }
29312 Py_INCREF(Py_None); resultobj = Py_None;
29313 return resultobj;
29314 fail:
29315 return NULL;
29316 }
29317
29318
29319 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29320 PyObject *resultobj;
29321 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29322 int arg2 ;
29323 int arg3 ;
29324 wxDragResult arg4 ;
29325 wxDragResult result;
29326 PyObject * obj0 = 0 ;
29327 PyObject * obj1 = 0 ;
29328 PyObject * obj2 = 0 ;
29329 PyObject * obj3 = 0 ;
29330 char *kwnames[] = {
29331 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29332 };
29333
29334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29336 if (SWIG_arg_fail(1)) SWIG_fail;
29337 {
29338 arg2 = (int)(SWIG_As_int(obj1));
29339 if (SWIG_arg_fail(2)) SWIG_fail;
29340 }
29341 {
29342 arg3 = (int)(SWIG_As_int(obj2));
29343 if (SWIG_arg_fail(3)) SWIG_fail;
29344 }
29345 {
29346 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29347 if (SWIG_arg_fail(4)) SWIG_fail;
29348 }
29349 {
29350 PyThreadState* __tstate = wxPyBeginAllowThreads();
29351 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29352
29353 wxPyEndAllowThreads(__tstate);
29354 if (PyErr_Occurred()) SWIG_fail;
29355 }
29356 resultobj = SWIG_From_int((result));
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj;
29365 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29366 int arg2 ;
29367 int arg3 ;
29368 wxDragResult arg4 ;
29369 wxDragResult result;
29370 PyObject * obj0 = 0 ;
29371 PyObject * obj1 = 0 ;
29372 PyObject * obj2 = 0 ;
29373 PyObject * obj3 = 0 ;
29374 char *kwnames[] = {
29375 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29376 };
29377
29378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29380 if (SWIG_arg_fail(1)) SWIG_fail;
29381 {
29382 arg2 = (int)(SWIG_As_int(obj1));
29383 if (SWIG_arg_fail(2)) SWIG_fail;
29384 }
29385 {
29386 arg3 = (int)(SWIG_As_int(obj2));
29387 if (SWIG_arg_fail(3)) SWIG_fail;
29388 }
29389 {
29390 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29391 if (SWIG_arg_fail(4)) SWIG_fail;
29392 }
29393 {
29394 PyThreadState* __tstate = wxPyBeginAllowThreads();
29395 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29396
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 resultobj = SWIG_From_int((result));
29401 return resultobj;
29402 fail:
29403 return NULL;
29404 }
29405
29406
29407 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29408 PyObject *resultobj;
29409 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29410 PyObject * obj0 = 0 ;
29411 char *kwnames[] = {
29412 (char *) "self", NULL
29413 };
29414
29415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29417 if (SWIG_arg_fail(1)) SWIG_fail;
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 (arg1)->base_OnLeave();
29421
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 Py_INCREF(Py_None); resultobj = Py_None;
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29433 PyObject *resultobj;
29434 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29435 int arg2 ;
29436 int arg3 ;
29437 bool result;
29438 PyObject * obj0 = 0 ;
29439 PyObject * obj1 = 0 ;
29440 PyObject * obj2 = 0 ;
29441 char *kwnames[] = {
29442 (char *) "self",(char *) "x",(char *) "y", NULL
29443 };
29444
29445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29447 if (SWIG_arg_fail(1)) SWIG_fail;
29448 {
29449 arg2 = (int)(SWIG_As_int(obj1));
29450 if (SWIG_arg_fail(2)) SWIG_fail;
29451 }
29452 {
29453 arg3 = (int)(SWIG_As_int(obj2));
29454 if (SWIG_arg_fail(3)) SWIG_fail;
29455 }
29456 {
29457 PyThreadState* __tstate = wxPyBeginAllowThreads();
29458 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29459
29460 wxPyEndAllowThreads(__tstate);
29461 if (PyErr_Occurred()) SWIG_fail;
29462 }
29463 {
29464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29465 }
29466 return resultobj;
29467 fail:
29468 return NULL;
29469 }
29470
29471
29472 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29473 PyObject *resultobj;
29474 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29475 int arg2 ;
29476 int arg3 ;
29477 wxDragResult arg4 ;
29478 wxDragResult result;
29479 PyObject * obj0 = 0 ;
29480 PyObject * obj1 = 0 ;
29481 PyObject * obj2 = 0 ;
29482 PyObject * obj3 = 0 ;
29483 char *kwnames[] = {
29484 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29485 };
29486
29487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29489 if (SWIG_arg_fail(1)) SWIG_fail;
29490 {
29491 arg2 = (int)(SWIG_As_int(obj1));
29492 if (SWIG_arg_fail(2)) SWIG_fail;
29493 }
29494 {
29495 arg3 = (int)(SWIG_As_int(obj2));
29496 if (SWIG_arg_fail(3)) SWIG_fail;
29497 }
29498 {
29499 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29500 if (SWIG_arg_fail(4)) SWIG_fail;
29501 }
29502 {
29503 PyThreadState* __tstate = wxPyBeginAllowThreads();
29504 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29505
29506 wxPyEndAllowThreads(__tstate);
29507 if (PyErr_Occurred()) SWIG_fail;
29508 }
29509 resultobj = SWIG_From_int((result));
29510 return resultobj;
29511 fail:
29512 return NULL;
29513 }
29514
29515
29516 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29517 PyObject *obj;
29518 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29519 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29520 Py_INCREF(obj);
29521 return Py_BuildValue((char *)"");
29522 }
29523 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29524 PyObject *resultobj;
29525 wxClipboard *result;
29526 char *kwnames[] = {
29527 NULL
29528 };
29529
29530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29531 {
29532 PyThreadState* __tstate = wxPyBeginAllowThreads();
29533 result = (wxClipboard *)new wxClipboard();
29534
29535 wxPyEndAllowThreads(__tstate);
29536 if (PyErr_Occurred()) SWIG_fail;
29537 }
29538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj;
29547 wxClipboard *arg1 = (wxClipboard *) 0 ;
29548 PyObject * obj0 = 0 ;
29549 char *kwnames[] = {
29550 (char *) "self", NULL
29551 };
29552
29553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29555 if (SWIG_arg_fail(1)) SWIG_fail;
29556 {
29557 PyThreadState* __tstate = wxPyBeginAllowThreads();
29558 delete arg1;
29559
29560 wxPyEndAllowThreads(__tstate);
29561 if (PyErr_Occurred()) SWIG_fail;
29562 }
29563 Py_INCREF(Py_None); resultobj = Py_None;
29564 return resultobj;
29565 fail:
29566 return NULL;
29567 }
29568
29569
29570 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29571 PyObject *resultobj;
29572 wxClipboard *arg1 = (wxClipboard *) 0 ;
29573 bool result;
29574 PyObject * obj0 = 0 ;
29575 char *kwnames[] = {
29576 (char *) "self", NULL
29577 };
29578
29579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29581 if (SWIG_arg_fail(1)) SWIG_fail;
29582 {
29583 PyThreadState* __tstate = wxPyBeginAllowThreads();
29584 result = (bool)(arg1)->Open();
29585
29586 wxPyEndAllowThreads(__tstate);
29587 if (PyErr_Occurred()) SWIG_fail;
29588 }
29589 {
29590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29591 }
29592 return resultobj;
29593 fail:
29594 return NULL;
29595 }
29596
29597
29598 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29599 PyObject *resultobj;
29600 wxClipboard *arg1 = (wxClipboard *) 0 ;
29601 PyObject * obj0 = 0 ;
29602 char *kwnames[] = {
29603 (char *) "self", NULL
29604 };
29605
29606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29608 if (SWIG_arg_fail(1)) SWIG_fail;
29609 {
29610 PyThreadState* __tstate = wxPyBeginAllowThreads();
29611 (arg1)->Close();
29612
29613 wxPyEndAllowThreads(__tstate);
29614 if (PyErr_Occurred()) SWIG_fail;
29615 }
29616 Py_INCREF(Py_None); resultobj = Py_None;
29617 return resultobj;
29618 fail:
29619 return NULL;
29620 }
29621
29622
29623 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29624 PyObject *resultobj;
29625 wxClipboard *arg1 = (wxClipboard *) 0 ;
29626 bool result;
29627 PyObject * obj0 = 0 ;
29628 char *kwnames[] = {
29629 (char *) "self", NULL
29630 };
29631
29632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29634 if (SWIG_arg_fail(1)) SWIG_fail;
29635 {
29636 PyThreadState* __tstate = wxPyBeginAllowThreads();
29637 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29638
29639 wxPyEndAllowThreads(__tstate);
29640 if (PyErr_Occurred()) SWIG_fail;
29641 }
29642 {
29643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29644 }
29645 return resultobj;
29646 fail:
29647 return NULL;
29648 }
29649
29650
29651 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29652 PyObject *resultobj;
29653 wxClipboard *arg1 = (wxClipboard *) 0 ;
29654 wxDataObject *arg2 = (wxDataObject *) 0 ;
29655 bool result;
29656 PyObject * obj0 = 0 ;
29657 PyObject * obj1 = 0 ;
29658 char *kwnames[] = {
29659 (char *) "self",(char *) "data", NULL
29660 };
29661
29662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29664 if (SWIG_arg_fail(1)) SWIG_fail;
29665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29666 if (SWIG_arg_fail(2)) SWIG_fail;
29667 {
29668 PyThreadState* __tstate = wxPyBeginAllowThreads();
29669 result = (bool)(arg1)->AddData(arg2);
29670
29671 wxPyEndAllowThreads(__tstate);
29672 if (PyErr_Occurred()) SWIG_fail;
29673 }
29674 {
29675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29676 }
29677 return resultobj;
29678 fail:
29679 return NULL;
29680 }
29681
29682
29683 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29684 PyObject *resultobj;
29685 wxClipboard *arg1 = (wxClipboard *) 0 ;
29686 wxDataObject *arg2 = (wxDataObject *) 0 ;
29687 bool result;
29688 PyObject * obj0 = 0 ;
29689 PyObject * obj1 = 0 ;
29690 char *kwnames[] = {
29691 (char *) "self",(char *) "data", NULL
29692 };
29693
29694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29696 if (SWIG_arg_fail(1)) SWIG_fail;
29697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29698 if (SWIG_arg_fail(2)) SWIG_fail;
29699 {
29700 PyThreadState* __tstate = wxPyBeginAllowThreads();
29701 result = (bool)(arg1)->SetData(arg2);
29702
29703 wxPyEndAllowThreads(__tstate);
29704 if (PyErr_Occurred()) SWIG_fail;
29705 }
29706 {
29707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29708 }
29709 return resultobj;
29710 fail:
29711 return NULL;
29712 }
29713
29714
29715 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29716 PyObject *resultobj;
29717 wxClipboard *arg1 = (wxClipboard *) 0 ;
29718 wxDataFormat *arg2 = 0 ;
29719 bool result;
29720 PyObject * obj0 = 0 ;
29721 PyObject * obj1 = 0 ;
29722 char *kwnames[] = {
29723 (char *) "self",(char *) "format", NULL
29724 };
29725
29726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29728 if (SWIG_arg_fail(1)) SWIG_fail;
29729 {
29730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29731 if (SWIG_arg_fail(2)) SWIG_fail;
29732 if (arg2 == NULL) {
29733 SWIG_null_ref("wxDataFormat");
29734 }
29735 if (SWIG_arg_fail(2)) SWIG_fail;
29736 }
29737 {
29738 PyThreadState* __tstate = wxPyBeginAllowThreads();
29739 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
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_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29754 PyObject *resultobj;
29755 wxClipboard *arg1 = (wxClipboard *) 0 ;
29756 wxDataObject *arg2 = 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_GetData",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 {
29768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29769 if (SWIG_arg_fail(2)) SWIG_fail;
29770 if (arg2 == NULL) {
29771 SWIG_null_ref("wxDataObject");
29772 }
29773 if (SWIG_arg_fail(2)) SWIG_fail;
29774 }
29775 {
29776 PyThreadState* __tstate = wxPyBeginAllowThreads();
29777 result = (bool)(arg1)->GetData(*arg2);
29778
29779 wxPyEndAllowThreads(__tstate);
29780 if (PyErr_Occurred()) SWIG_fail;
29781 }
29782 {
29783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29784 }
29785 return resultobj;
29786 fail:
29787 return NULL;
29788 }
29789
29790
29791 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29792 PyObject *resultobj;
29793 wxClipboard *arg1 = (wxClipboard *) 0 ;
29794 PyObject * obj0 = 0 ;
29795 char *kwnames[] = {
29796 (char *) "self", NULL
29797 };
29798
29799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29801 if (SWIG_arg_fail(1)) SWIG_fail;
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 (arg1)->Clear();
29805
29806 wxPyEndAllowThreads(__tstate);
29807 if (PyErr_Occurred()) SWIG_fail;
29808 }
29809 Py_INCREF(Py_None); resultobj = Py_None;
29810 return resultobj;
29811 fail:
29812 return NULL;
29813 }
29814
29815
29816 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29817 PyObject *resultobj;
29818 wxClipboard *arg1 = (wxClipboard *) 0 ;
29819 bool result;
29820 PyObject * obj0 = 0 ;
29821 char *kwnames[] = {
29822 (char *) "self", NULL
29823 };
29824
29825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29827 if (SWIG_arg_fail(1)) SWIG_fail;
29828 {
29829 PyThreadState* __tstate = wxPyBeginAllowThreads();
29830 result = (bool)(arg1)->Flush();
29831
29832 wxPyEndAllowThreads(__tstate);
29833 if (PyErr_Occurred()) SWIG_fail;
29834 }
29835 {
29836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29837 }
29838 return resultobj;
29839 fail:
29840 return NULL;
29841 }
29842
29843
29844 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29845 PyObject *resultobj;
29846 wxClipboard *arg1 = (wxClipboard *) 0 ;
29847 bool arg2 = (bool) true ;
29848 PyObject * obj0 = 0 ;
29849 PyObject * obj1 = 0 ;
29850 char *kwnames[] = {
29851 (char *) "self",(char *) "primary", NULL
29852 };
29853
29854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29856 if (SWIG_arg_fail(1)) SWIG_fail;
29857 if (obj1) {
29858 {
29859 arg2 = (bool)(SWIG_As_bool(obj1));
29860 if (SWIG_arg_fail(2)) SWIG_fail;
29861 }
29862 }
29863 {
29864 PyThreadState* __tstate = wxPyBeginAllowThreads();
29865 (arg1)->UsePrimarySelection(arg2);
29866
29867 wxPyEndAllowThreads(__tstate);
29868 if (PyErr_Occurred()) SWIG_fail;
29869 }
29870 Py_INCREF(Py_None); resultobj = Py_None;
29871 return resultobj;
29872 fail:
29873 return NULL;
29874 }
29875
29876
29877 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29878 PyObject *resultobj;
29879 wxClipboard *result;
29880 char *kwnames[] = {
29881 NULL
29882 };
29883
29884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29885 {
29886 PyThreadState* __tstate = wxPyBeginAllowThreads();
29887 result = (wxClipboard *)wxClipboard::Get();
29888
29889 wxPyEndAllowThreads(__tstate);
29890 if (PyErr_Occurred()) SWIG_fail;
29891 }
29892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29893 return resultobj;
29894 fail:
29895 return NULL;
29896 }
29897
29898
29899 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29900 PyObject *obj;
29901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29902 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29903 Py_INCREF(obj);
29904 return Py_BuildValue((char *)"");
29905 }
29906 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29907 PyObject *resultobj;
29908 wxClipboard *arg1 = (wxClipboard *) NULL ;
29909 wxClipboardLocker *result;
29910 PyObject * obj0 = 0 ;
29911 char *kwnames[] = {
29912 (char *) "clipboard", NULL
29913 };
29914
29915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29916 if (obj0) {
29917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29918 if (SWIG_arg_fail(1)) SWIG_fail;
29919 }
29920 {
29921 PyThreadState* __tstate = wxPyBeginAllowThreads();
29922 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29923
29924 wxPyEndAllowThreads(__tstate);
29925 if (PyErr_Occurred()) SWIG_fail;
29926 }
29927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29928 return resultobj;
29929 fail:
29930 return NULL;
29931 }
29932
29933
29934 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29935 PyObject *resultobj;
29936 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29937 PyObject * obj0 = 0 ;
29938 char *kwnames[] = {
29939 (char *) "self", NULL
29940 };
29941
29942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29944 if (SWIG_arg_fail(1)) SWIG_fail;
29945 {
29946 PyThreadState* __tstate = wxPyBeginAllowThreads();
29947 delete arg1;
29948
29949 wxPyEndAllowThreads(__tstate);
29950 if (PyErr_Occurred()) SWIG_fail;
29951 }
29952 Py_INCREF(Py_None); resultobj = Py_None;
29953 return resultobj;
29954 fail:
29955 return NULL;
29956 }
29957
29958
29959 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29960 PyObject *resultobj;
29961 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29962 bool result;
29963 PyObject * obj0 = 0 ;
29964 char *kwnames[] = {
29965 (char *) "self", NULL
29966 };
29967
29968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29970 if (SWIG_arg_fail(1)) SWIG_fail;
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 result = (bool)wxClipboardLocker___nonzero__(arg1);
29974
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 {
29979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29980 }
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29988 PyObject *obj;
29989 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29990 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29991 Py_INCREF(obj);
29992 return Py_BuildValue((char *)"");
29993 }
29994 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29995 PyObject *resultobj;
29996 int arg1 = (int) 0 ;
29997 int arg2 = (int) 0 ;
29998 int arg3 = (int) 0 ;
29999 int arg4 = (int) 0 ;
30000 wxVideoMode *result;
30001 PyObject * obj0 = 0 ;
30002 PyObject * obj1 = 0 ;
30003 PyObject * obj2 = 0 ;
30004 PyObject * obj3 = 0 ;
30005 char *kwnames[] = {
30006 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30007 };
30008
30009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30010 if (obj0) {
30011 {
30012 arg1 = (int)(SWIG_As_int(obj0));
30013 if (SWIG_arg_fail(1)) SWIG_fail;
30014 }
30015 }
30016 if (obj1) {
30017 {
30018 arg2 = (int)(SWIG_As_int(obj1));
30019 if (SWIG_arg_fail(2)) SWIG_fail;
30020 }
30021 }
30022 if (obj2) {
30023 {
30024 arg3 = (int)(SWIG_As_int(obj2));
30025 if (SWIG_arg_fail(3)) SWIG_fail;
30026 }
30027 }
30028 if (obj3) {
30029 {
30030 arg4 = (int)(SWIG_As_int(obj3));
30031 if (SWIG_arg_fail(4)) SWIG_fail;
30032 }
30033 }
30034 {
30035 PyThreadState* __tstate = wxPyBeginAllowThreads();
30036 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30037
30038 wxPyEndAllowThreads(__tstate);
30039 if (PyErr_Occurred()) SWIG_fail;
30040 }
30041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30042 return resultobj;
30043 fail:
30044 return NULL;
30045 }
30046
30047
30048 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30049 PyObject *resultobj;
30050 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30051 PyObject * obj0 = 0 ;
30052 char *kwnames[] = {
30053 (char *) "self", NULL
30054 };
30055
30056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30058 if (SWIG_arg_fail(1)) SWIG_fail;
30059 {
30060 PyThreadState* __tstate = wxPyBeginAllowThreads();
30061 delete arg1;
30062
30063 wxPyEndAllowThreads(__tstate);
30064 if (PyErr_Occurred()) SWIG_fail;
30065 }
30066 Py_INCREF(Py_None); resultobj = Py_None;
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30074 PyObject *resultobj;
30075 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30076 wxVideoMode *arg2 = 0 ;
30077 bool result;
30078 PyObject * obj0 = 0 ;
30079 PyObject * obj1 = 0 ;
30080 char *kwnames[] = {
30081 (char *) "self",(char *) "other", NULL
30082 };
30083
30084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30086 if (SWIG_arg_fail(1)) SWIG_fail;
30087 {
30088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30089 if (SWIG_arg_fail(2)) SWIG_fail;
30090 if (arg2 == NULL) {
30091 SWIG_null_ref("wxVideoMode");
30092 }
30093 if (SWIG_arg_fail(2)) SWIG_fail;
30094 }
30095 {
30096 PyThreadState* __tstate = wxPyBeginAllowThreads();
30097 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30098
30099 wxPyEndAllowThreads(__tstate);
30100 if (PyErr_Occurred()) SWIG_fail;
30101 }
30102 {
30103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30104 }
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30112 PyObject *resultobj;
30113 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30114 int result;
30115 PyObject * obj0 = 0 ;
30116 char *kwnames[] = {
30117 (char *) "self", NULL
30118 };
30119
30120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30122 if (SWIG_arg_fail(1)) SWIG_fail;
30123 {
30124 PyThreadState* __tstate = wxPyBeginAllowThreads();
30125 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30126
30127 wxPyEndAllowThreads(__tstate);
30128 if (PyErr_Occurred()) SWIG_fail;
30129 }
30130 {
30131 resultobj = SWIG_From_int((int)(result));
30132 }
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30140 PyObject *resultobj;
30141 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30142 int result;
30143 PyObject * obj0 = 0 ;
30144 char *kwnames[] = {
30145 (char *) "self", NULL
30146 };
30147
30148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30150 if (SWIG_arg_fail(1)) SWIG_fail;
30151 {
30152 PyThreadState* __tstate = wxPyBeginAllowThreads();
30153 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30154
30155 wxPyEndAllowThreads(__tstate);
30156 if (PyErr_Occurred()) SWIG_fail;
30157 }
30158 {
30159 resultobj = SWIG_From_int((int)(result));
30160 }
30161 return resultobj;
30162 fail:
30163 return NULL;
30164 }
30165
30166
30167 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30168 PyObject *resultobj;
30169 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30170 int result;
30171 PyObject * obj0 = 0 ;
30172 char *kwnames[] = {
30173 (char *) "self", NULL
30174 };
30175
30176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30178 if (SWIG_arg_fail(1)) SWIG_fail;
30179 {
30180 PyThreadState* __tstate = wxPyBeginAllowThreads();
30181 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30182
30183 wxPyEndAllowThreads(__tstate);
30184 if (PyErr_Occurred()) SWIG_fail;
30185 }
30186 {
30187 resultobj = SWIG_From_int((int)(result));
30188 }
30189 return resultobj;
30190 fail:
30191 return NULL;
30192 }
30193
30194
30195 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30196 PyObject *resultobj;
30197 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30198 bool result;
30199 PyObject * obj0 = 0 ;
30200 char *kwnames[] = {
30201 (char *) "self", NULL
30202 };
30203
30204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30206 if (SWIG_arg_fail(1)) SWIG_fail;
30207 {
30208 PyThreadState* __tstate = wxPyBeginAllowThreads();
30209 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30210
30211 wxPyEndAllowThreads(__tstate);
30212 if (PyErr_Occurred()) SWIG_fail;
30213 }
30214 {
30215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30216 }
30217 return resultobj;
30218 fail:
30219 return NULL;
30220 }
30221
30222
30223 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30224 PyObject *resultobj;
30225 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30226 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30227 bool result;
30228 PyObject * obj0 = 0 ;
30229 PyObject * obj1 = 0 ;
30230 char *kwnames[] = {
30231 (char *) "self",(char *) "other", NULL
30232 };
30233
30234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30236 if (SWIG_arg_fail(1)) SWIG_fail;
30237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30238 if (SWIG_arg_fail(2)) SWIG_fail;
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30242
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 {
30247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30248 }
30249 return resultobj;
30250 fail:
30251 return NULL;
30252 }
30253
30254
30255 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30256 PyObject *resultobj;
30257 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30258 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30259 bool result;
30260 PyObject * obj0 = 0 ;
30261 PyObject * obj1 = 0 ;
30262 char *kwnames[] = {
30263 (char *) "self",(char *) "other", NULL
30264 };
30265
30266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30268 if (SWIG_arg_fail(1)) SWIG_fail;
30269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30270 if (SWIG_arg_fail(2)) SWIG_fail;
30271 {
30272 PyThreadState* __tstate = wxPyBeginAllowThreads();
30273 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30274
30275 wxPyEndAllowThreads(__tstate);
30276 if (PyErr_Occurred()) SWIG_fail;
30277 }
30278 {
30279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30280 }
30281 return resultobj;
30282 fail:
30283 return NULL;
30284 }
30285
30286
30287 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30288 PyObject *resultobj;
30289 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30290 int arg2 ;
30291 PyObject * obj0 = 0 ;
30292 PyObject * obj1 = 0 ;
30293 char *kwnames[] = {
30294 (char *) "self",(char *) "w", NULL
30295 };
30296
30297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30299 if (SWIG_arg_fail(1)) SWIG_fail;
30300 {
30301 arg2 = (int)(SWIG_As_int(obj1));
30302 if (SWIG_arg_fail(2)) SWIG_fail;
30303 }
30304 if (arg1) (arg1)->w = arg2;
30305
30306 Py_INCREF(Py_None); resultobj = Py_None;
30307 return resultobj;
30308 fail:
30309 return NULL;
30310 }
30311
30312
30313 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30314 PyObject *resultobj;
30315 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30316 int result;
30317 PyObject * obj0 = 0 ;
30318 char *kwnames[] = {
30319 (char *) "self", NULL
30320 };
30321
30322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30324 if (SWIG_arg_fail(1)) SWIG_fail;
30325 result = (int) ((arg1)->w);
30326
30327 {
30328 resultobj = SWIG_From_int((int)(result));
30329 }
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30337 PyObject *resultobj;
30338 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30339 int arg2 ;
30340 PyObject * obj0 = 0 ;
30341 PyObject * obj1 = 0 ;
30342 char *kwnames[] = {
30343 (char *) "self",(char *) "h", NULL
30344 };
30345
30346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30348 if (SWIG_arg_fail(1)) SWIG_fail;
30349 {
30350 arg2 = (int)(SWIG_As_int(obj1));
30351 if (SWIG_arg_fail(2)) SWIG_fail;
30352 }
30353 if (arg1) (arg1)->h = arg2;
30354
30355 Py_INCREF(Py_None); resultobj = Py_None;
30356 return resultobj;
30357 fail:
30358 return NULL;
30359 }
30360
30361
30362 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30363 PyObject *resultobj;
30364 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30365 int result;
30366 PyObject * obj0 = 0 ;
30367 char *kwnames[] = {
30368 (char *) "self", NULL
30369 };
30370
30371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30373 if (SWIG_arg_fail(1)) SWIG_fail;
30374 result = (int) ((arg1)->h);
30375
30376 {
30377 resultobj = SWIG_From_int((int)(result));
30378 }
30379 return resultobj;
30380 fail:
30381 return NULL;
30382 }
30383
30384
30385 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30386 PyObject *resultobj;
30387 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30388 int arg2 ;
30389 PyObject * obj0 = 0 ;
30390 PyObject * obj1 = 0 ;
30391 char *kwnames[] = {
30392 (char *) "self",(char *) "bpp", NULL
30393 };
30394
30395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30397 if (SWIG_arg_fail(1)) SWIG_fail;
30398 {
30399 arg2 = (int)(SWIG_As_int(obj1));
30400 if (SWIG_arg_fail(2)) SWIG_fail;
30401 }
30402 if (arg1) (arg1)->bpp = arg2;
30403
30404 Py_INCREF(Py_None); resultobj = Py_None;
30405 return resultobj;
30406 fail:
30407 return NULL;
30408 }
30409
30410
30411 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30412 PyObject *resultobj;
30413 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30414 int result;
30415 PyObject * obj0 = 0 ;
30416 char *kwnames[] = {
30417 (char *) "self", NULL
30418 };
30419
30420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30422 if (SWIG_arg_fail(1)) SWIG_fail;
30423 result = (int) ((arg1)->bpp);
30424
30425 {
30426 resultobj = SWIG_From_int((int)(result));
30427 }
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30435 PyObject *resultobj;
30436 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30437 int arg2 ;
30438 PyObject * obj0 = 0 ;
30439 PyObject * obj1 = 0 ;
30440 char *kwnames[] = {
30441 (char *) "self",(char *) "refresh", NULL
30442 };
30443
30444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30446 if (SWIG_arg_fail(1)) SWIG_fail;
30447 {
30448 arg2 = (int)(SWIG_As_int(obj1));
30449 if (SWIG_arg_fail(2)) SWIG_fail;
30450 }
30451 if (arg1) (arg1)->refresh = arg2;
30452
30453 Py_INCREF(Py_None); resultobj = Py_None;
30454 return resultobj;
30455 fail:
30456 return NULL;
30457 }
30458
30459
30460 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30461 PyObject *resultobj;
30462 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30463 int result;
30464 PyObject * obj0 = 0 ;
30465 char *kwnames[] = {
30466 (char *) "self", NULL
30467 };
30468
30469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30471 if (SWIG_arg_fail(1)) SWIG_fail;
30472 result = (int) ((arg1)->refresh);
30473
30474 {
30475 resultobj = SWIG_From_int((int)(result));
30476 }
30477 return resultobj;
30478 fail:
30479 return NULL;
30480 }
30481
30482
30483 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30484 PyObject *obj;
30485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30486 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30487 Py_INCREF(obj);
30488 return Py_BuildValue((char *)"");
30489 }
30490 static int _wrap_DefaultVideoMode_set(PyObject *) {
30491 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30492 return 1;
30493 }
30494
30495
30496 static PyObject *_wrap_DefaultVideoMode_get(void) {
30497 PyObject *pyobj;
30498
30499 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30500 return pyobj;
30501 }
30502
30503
30504 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30505 PyObject *resultobj;
30506 size_t arg1 = (size_t) 0 ;
30507 wxDisplay *result;
30508 PyObject * obj0 = 0 ;
30509 char *kwnames[] = {
30510 (char *) "index", NULL
30511 };
30512
30513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30514 if (obj0) {
30515 {
30516 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30517 if (SWIG_arg_fail(1)) SWIG_fail;
30518 }
30519 }
30520 {
30521 PyThreadState* __tstate = wxPyBeginAllowThreads();
30522 result = (wxDisplay *)new wxDisplay(arg1);
30523
30524 wxPyEndAllowThreads(__tstate);
30525 if (PyErr_Occurred()) SWIG_fail;
30526 }
30527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30528 return resultobj;
30529 fail:
30530 return NULL;
30531 }
30532
30533
30534 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30535 PyObject *resultobj;
30536 wxDisplay *arg1 = (wxDisplay *) 0 ;
30537 PyObject * obj0 = 0 ;
30538 char *kwnames[] = {
30539 (char *) "self", NULL
30540 };
30541
30542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30544 if (SWIG_arg_fail(1)) SWIG_fail;
30545 {
30546 PyThreadState* __tstate = wxPyBeginAllowThreads();
30547 delete arg1;
30548
30549 wxPyEndAllowThreads(__tstate);
30550 if (PyErr_Occurred()) SWIG_fail;
30551 }
30552 Py_INCREF(Py_None); resultobj = Py_None;
30553 return resultobj;
30554 fail:
30555 return NULL;
30556 }
30557
30558
30559 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30560 PyObject *resultobj;
30561 size_t result;
30562 char *kwnames[] = {
30563 NULL
30564 };
30565
30566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30567 {
30568 PyThreadState* __tstate = wxPyBeginAllowThreads();
30569 result = (size_t)wxDisplay::GetCount();
30570
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 {
30575 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30576 }
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30584 PyObject *resultobj;
30585 wxPoint *arg1 = 0 ;
30586 int result;
30587 wxPoint temp1 ;
30588 PyObject * obj0 = 0 ;
30589 char *kwnames[] = {
30590 (char *) "pt", NULL
30591 };
30592
30593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30594 {
30595 arg1 = &temp1;
30596 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30597 }
30598 {
30599 PyThreadState* __tstate = wxPyBeginAllowThreads();
30600 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30601
30602 wxPyEndAllowThreads(__tstate);
30603 if (PyErr_Occurred()) SWIG_fail;
30604 }
30605 {
30606 resultobj = SWIG_From_int((int)(result));
30607 }
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30615 PyObject *resultobj;
30616 wxWindow *arg1 = (wxWindow *) 0 ;
30617 int result;
30618 PyObject * obj0 = 0 ;
30619 char *kwnames[] = {
30620 (char *) "window", NULL
30621 };
30622
30623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30625 if (SWIG_arg_fail(1)) SWIG_fail;
30626 {
30627 PyThreadState* __tstate = wxPyBeginAllowThreads();
30628 result = (int)wxDisplay::GetFromWindow(arg1);
30629
30630 wxPyEndAllowThreads(__tstate);
30631 if (PyErr_Occurred()) SWIG_fail;
30632 }
30633 {
30634 resultobj = SWIG_From_int((int)(result));
30635 }
30636 return resultobj;
30637 fail:
30638 return NULL;
30639 }
30640
30641
30642 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30643 PyObject *resultobj;
30644 wxDisplay *arg1 = (wxDisplay *) 0 ;
30645 bool result;
30646 PyObject * obj0 = 0 ;
30647 char *kwnames[] = {
30648 (char *) "self", NULL
30649 };
30650
30651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30653 if (SWIG_arg_fail(1)) SWIG_fail;
30654 {
30655 PyThreadState* __tstate = wxPyBeginAllowThreads();
30656 result = (bool)((wxDisplay const *)arg1)->IsOk();
30657
30658 wxPyEndAllowThreads(__tstate);
30659 if (PyErr_Occurred()) SWIG_fail;
30660 }
30661 {
30662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30663 }
30664 return resultobj;
30665 fail:
30666 return NULL;
30667 }
30668
30669
30670 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30671 PyObject *resultobj;
30672 wxDisplay *arg1 = (wxDisplay *) 0 ;
30673 wxRect result;
30674 PyObject * obj0 = 0 ;
30675 char *kwnames[] = {
30676 (char *) "self", NULL
30677 };
30678
30679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30681 if (SWIG_arg_fail(1)) SWIG_fail;
30682 {
30683 PyThreadState* __tstate = wxPyBeginAllowThreads();
30684 result = ((wxDisplay const *)arg1)->GetGeometry();
30685
30686 wxPyEndAllowThreads(__tstate);
30687 if (PyErr_Occurred()) SWIG_fail;
30688 }
30689 {
30690 wxRect * resultptr;
30691 resultptr = new wxRect((wxRect &)(result));
30692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30693 }
30694 return resultobj;
30695 fail:
30696 return NULL;
30697 }
30698
30699
30700 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30701 PyObject *resultobj;
30702 wxDisplay *arg1 = (wxDisplay *) 0 ;
30703 wxString result;
30704 PyObject * obj0 = 0 ;
30705 char *kwnames[] = {
30706 (char *) "self", NULL
30707 };
30708
30709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30711 if (SWIG_arg_fail(1)) SWIG_fail;
30712 {
30713 PyThreadState* __tstate = wxPyBeginAllowThreads();
30714 result = ((wxDisplay const *)arg1)->GetName();
30715
30716 wxPyEndAllowThreads(__tstate);
30717 if (PyErr_Occurred()) SWIG_fail;
30718 }
30719 {
30720 #if wxUSE_UNICODE
30721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30722 #else
30723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30724 #endif
30725 }
30726 return resultobj;
30727 fail:
30728 return NULL;
30729 }
30730
30731
30732 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30733 PyObject *resultobj;
30734 wxDisplay *arg1 = (wxDisplay *) 0 ;
30735 bool result;
30736 PyObject * obj0 = 0 ;
30737 char *kwnames[] = {
30738 (char *) "self", NULL
30739 };
30740
30741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30743 if (SWIG_arg_fail(1)) SWIG_fail;
30744 {
30745 PyThreadState* __tstate = wxPyBeginAllowThreads();
30746 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30747
30748 wxPyEndAllowThreads(__tstate);
30749 if (PyErr_Occurred()) SWIG_fail;
30750 }
30751 {
30752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30753 }
30754 return resultobj;
30755 fail:
30756 return NULL;
30757 }
30758
30759
30760 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30761 PyObject *resultobj;
30762 wxDisplay *arg1 = (wxDisplay *) 0 ;
30763 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30764 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30765 PyObject *result;
30766 PyObject * obj0 = 0 ;
30767 PyObject * obj1 = 0 ;
30768 char *kwnames[] = {
30769 (char *) "self",(char *) "mode", NULL
30770 };
30771
30772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30774 if (SWIG_arg_fail(1)) SWIG_fail;
30775 if (obj1) {
30776 {
30777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30778 if (SWIG_arg_fail(2)) SWIG_fail;
30779 if (arg2 == NULL) {
30780 SWIG_null_ref("wxVideoMode");
30781 }
30782 if (SWIG_arg_fail(2)) SWIG_fail;
30783 }
30784 }
30785 {
30786 PyThreadState* __tstate = wxPyBeginAllowThreads();
30787 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30788
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 resultobj = result;
30793 return resultobj;
30794 fail:
30795 return NULL;
30796 }
30797
30798
30799 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30800 PyObject *resultobj;
30801 wxDisplay *arg1 = (wxDisplay *) 0 ;
30802 wxVideoMode result;
30803 PyObject * obj0 = 0 ;
30804 char *kwnames[] = {
30805 (char *) "self", NULL
30806 };
30807
30808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30810 if (SWIG_arg_fail(1)) SWIG_fail;
30811 {
30812 PyThreadState* __tstate = wxPyBeginAllowThreads();
30813 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30814
30815 wxPyEndAllowThreads(__tstate);
30816 if (PyErr_Occurred()) SWIG_fail;
30817 }
30818 {
30819 wxVideoMode * resultptr;
30820 resultptr = new wxVideoMode((wxVideoMode &)(result));
30821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30822 }
30823 return resultobj;
30824 fail:
30825 return NULL;
30826 }
30827
30828
30829 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30830 PyObject *resultobj;
30831 wxDisplay *arg1 = (wxDisplay *) 0 ;
30832 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30833 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30834 bool result;
30835 PyObject * obj0 = 0 ;
30836 PyObject * obj1 = 0 ;
30837 char *kwnames[] = {
30838 (char *) "self",(char *) "mode", NULL
30839 };
30840
30841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30843 if (SWIG_arg_fail(1)) SWIG_fail;
30844 if (obj1) {
30845 {
30846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30847 if (SWIG_arg_fail(2)) SWIG_fail;
30848 if (arg2 == NULL) {
30849 SWIG_null_ref("wxVideoMode");
30850 }
30851 if (SWIG_arg_fail(2)) SWIG_fail;
30852 }
30853 }
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30857
30858 wxPyEndAllowThreads(__tstate);
30859 if (PyErr_Occurred()) SWIG_fail;
30860 }
30861 {
30862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30863 }
30864 return resultobj;
30865 fail:
30866 return NULL;
30867 }
30868
30869
30870 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30871 PyObject *resultobj;
30872 wxDisplay *arg1 = (wxDisplay *) 0 ;
30873 PyObject * obj0 = 0 ;
30874 char *kwnames[] = {
30875 (char *) "self", NULL
30876 };
30877
30878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30880 if (SWIG_arg_fail(1)) SWIG_fail;
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 (arg1)->ResetMode();
30884
30885 wxPyEndAllowThreads(__tstate);
30886 if (PyErr_Occurred()) SWIG_fail;
30887 }
30888 Py_INCREF(Py_None); resultobj = Py_None;
30889 return resultobj;
30890 fail:
30891 return NULL;
30892 }
30893
30894
30895 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30896 PyObject *obj;
30897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30898 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30899 Py_INCREF(obj);
30900 return Py_BuildValue((char *)"");
30901 }
30902 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30903 PyObject *resultobj;
30904 wxStandardPaths *result;
30905 char *kwnames[] = {
30906 NULL
30907 };
30908
30909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30910 {
30911 PyThreadState* __tstate = wxPyBeginAllowThreads();
30912 result = (wxStandardPaths *)StandardPaths_Get();
30913
30914 wxPyEndAllowThreads(__tstate);
30915 if (PyErr_Occurred()) SWIG_fail;
30916 }
30917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30918 return resultobj;
30919 fail:
30920 return NULL;
30921 }
30922
30923
30924 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30925 PyObject *resultobj;
30926 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30927 wxString result;
30928 PyObject * obj0 = 0 ;
30929 char *kwnames[] = {
30930 (char *) "self", NULL
30931 };
30932
30933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30935 if (SWIG_arg_fail(1)) SWIG_fail;
30936 {
30937 PyThreadState* __tstate = wxPyBeginAllowThreads();
30938 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30939
30940 wxPyEndAllowThreads(__tstate);
30941 if (PyErr_Occurred()) SWIG_fail;
30942 }
30943 {
30944 #if wxUSE_UNICODE
30945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30946 #else
30947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30948 #endif
30949 }
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj;
30958 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30959 wxString result;
30960 PyObject * obj0 = 0 ;
30961 char *kwnames[] = {
30962 (char *) "self", NULL
30963 };
30964
30965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30967 if (SWIG_arg_fail(1)) SWIG_fail;
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30971
30972 wxPyEndAllowThreads(__tstate);
30973 if (PyErr_Occurred()) SWIG_fail;
30974 }
30975 {
30976 #if wxUSE_UNICODE
30977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30978 #else
30979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30980 #endif
30981 }
30982 return resultobj;
30983 fail:
30984 return NULL;
30985 }
30986
30987
30988 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30989 PyObject *resultobj;
30990 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30991 wxString result;
30992 PyObject * obj0 = 0 ;
30993 char *kwnames[] = {
30994 (char *) "self", NULL
30995 };
30996
30997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30999 if (SWIG_arg_fail(1)) SWIG_fail;
31000 {
31001 PyThreadState* __tstate = wxPyBeginAllowThreads();
31002 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31003
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 {
31008 #if wxUSE_UNICODE
31009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31010 #else
31011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31012 #endif
31013 }
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj;
31022 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31023 wxString result;
31024 PyObject * obj0 = 0 ;
31025 char *kwnames[] = {
31026 (char *) "self", NULL
31027 };
31028
31029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31031 if (SWIG_arg_fail(1)) SWIG_fail;
31032 {
31033 PyThreadState* __tstate = wxPyBeginAllowThreads();
31034 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31035
31036 wxPyEndAllowThreads(__tstate);
31037 if (PyErr_Occurred()) SWIG_fail;
31038 }
31039 {
31040 #if wxUSE_UNICODE
31041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31042 #else
31043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31044 #endif
31045 }
31046 return resultobj;
31047 fail:
31048 return NULL;
31049 }
31050
31051
31052 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31053 PyObject *resultobj;
31054 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31055 wxString result;
31056 PyObject * obj0 = 0 ;
31057 char *kwnames[] = {
31058 (char *) "self", NULL
31059 };
31060
31061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31063 if (SWIG_arg_fail(1)) SWIG_fail;
31064 {
31065 PyThreadState* __tstate = wxPyBeginAllowThreads();
31066 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31067
31068 wxPyEndAllowThreads(__tstate);
31069 if (PyErr_Occurred()) SWIG_fail;
31070 }
31071 {
31072 #if wxUSE_UNICODE
31073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31074 #else
31075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31076 #endif
31077 }
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31085 PyObject *resultobj;
31086 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31087 wxString result;
31088 PyObject * obj0 = 0 ;
31089 char *kwnames[] = {
31090 (char *) "self", NULL
31091 };
31092
31093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31095 if (SWIG_arg_fail(1)) SWIG_fail;
31096 {
31097 PyThreadState* __tstate = wxPyBeginAllowThreads();
31098 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31099
31100 wxPyEndAllowThreads(__tstate);
31101 if (PyErr_Occurred()) SWIG_fail;
31102 }
31103 {
31104 #if wxUSE_UNICODE
31105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31106 #else
31107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31108 #endif
31109 }
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31117 PyObject *resultobj;
31118 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31119 wxString result;
31120 PyObject * obj0 = 0 ;
31121 char *kwnames[] = {
31122 (char *) "self", NULL
31123 };
31124
31125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31127 if (SWIG_arg_fail(1)) SWIG_fail;
31128 {
31129 PyThreadState* __tstate = wxPyBeginAllowThreads();
31130 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31131
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 {
31136 #if wxUSE_UNICODE
31137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31138 #else
31139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31140 #endif
31141 }
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj;
31150 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31151 wxString *arg2 = 0 ;
31152 bool temp2 = false ;
31153 PyObject * obj0 = 0 ;
31154 PyObject * obj1 = 0 ;
31155 char *kwnames[] = {
31156 (char *) "self",(char *) "prefix", NULL
31157 };
31158
31159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31161 if (SWIG_arg_fail(1)) SWIG_fail;
31162 {
31163 arg2 = wxString_in_helper(obj1);
31164 if (arg2 == NULL) SWIG_fail;
31165 temp2 = true;
31166 }
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31170
31171 wxPyEndAllowThreads(__tstate);
31172 if (PyErr_Occurred()) SWIG_fail;
31173 }
31174 Py_INCREF(Py_None); resultobj = Py_None;
31175 {
31176 if (temp2)
31177 delete arg2;
31178 }
31179 return resultobj;
31180 fail:
31181 {
31182 if (temp2)
31183 delete arg2;
31184 }
31185 return NULL;
31186 }
31187
31188
31189 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31190 PyObject *resultobj;
31191 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31192 wxString result;
31193 PyObject * obj0 = 0 ;
31194 char *kwnames[] = {
31195 (char *) "self", NULL
31196 };
31197
31198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31200 if (SWIG_arg_fail(1)) SWIG_fail;
31201 {
31202 PyThreadState* __tstate = wxPyBeginAllowThreads();
31203 result = wxStandardPaths_GetInstallPrefix(arg1);
31204
31205 wxPyEndAllowThreads(__tstate);
31206 if (PyErr_Occurred()) SWIG_fail;
31207 }
31208 {
31209 #if wxUSE_UNICODE
31210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31211 #else
31212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31213 #endif
31214 }
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31222 PyObject *obj;
31223 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31224 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31225 Py_INCREF(obj);
31226 return Py_BuildValue((char *)"");
31227 }
31228 static PyMethodDef SwigMethods[] = {
31229 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31236 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31243 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31307 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31315 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31331 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31336 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31339 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31342 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31348 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31362 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31368 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31374 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31377 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31391 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31394 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31395 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31398 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31425 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31427 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31429 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31431 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31438 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31444 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31458 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31462 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31465 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31482 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31490 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31537 { (char *)"JoystickEvent_m_pos_set", (PyCFunction) _wrap_JoystickEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"JoystickEvent_m_pos_get", (PyCFunction) _wrap_JoystickEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"JoystickEvent_m_zPosition_set", (PyCFunction) _wrap_JoystickEvent_m_zPosition_set, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"JoystickEvent_m_zPosition_get", (PyCFunction) _wrap_JoystickEvent_m_zPosition_get, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"JoystickEvent_m_buttonChange_set", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_set, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"JoystickEvent_m_buttonChange_get", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_get, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"JoystickEvent_m_buttonState_set", (PyCFunction) _wrap_JoystickEvent_m_buttonState_set, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"JoystickEvent_m_buttonState_get", (PyCFunction) _wrap_JoystickEvent_m_buttonState_get, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"JoystickEvent_m_joyStick_set", (PyCFunction) _wrap_JoystickEvent_m_joyStick_set, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"JoystickEvent_m_joyStick_get", (PyCFunction) _wrap_JoystickEvent_m_joyStick_get, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31565 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31575 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31591 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31607 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31621 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31630 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31673 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31676 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31679 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31683 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31776 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31777 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31778 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31779 { (char *)"DateTime___lt__", _wrap_DateTime___lt__, METH_VARARGS, NULL},
31780 { (char *)"DateTime___le__", _wrap_DateTime___le__, METH_VARARGS, NULL},
31781 { (char *)"DateTime___gt__", _wrap_DateTime___gt__, METH_VARARGS, NULL},
31782 { (char *)"DateTime___ge__", _wrap_DateTime___ge__, METH_VARARGS, NULL},
31783 { (char *)"DateTime___eq__", _wrap_DateTime___eq__, METH_VARARGS, NULL},
31784 { (char *)"DateTime___ne__", _wrap_DateTime___ne__, METH_VARARGS, NULL},
31785 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31796 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31841 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31875 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31883 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31884 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31889 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31898 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31905 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31908 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31911 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31916 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31919 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31923 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31926 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31930 { (char *)"new_CustomDataObject", (PyCFunction) _wrap_new_CustomDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31935 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31939 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31943 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31953 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31964 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31972 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31980 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31994 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31998 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32016 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32030 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32041 { NULL, NULL, 0, NULL }
32042 };
32043
32044
32045 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32046
32047 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32048 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32049 }
32050 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32051 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32052 }
32053 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32054 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32055 }
32056 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32057 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32058 }
32059 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32060 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32061 }
32062 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32063 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32064 }
32065 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32066 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32067 }
32068 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32069 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32070 }
32071 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32072 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32073 }
32074 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32075 return (void *)((wxEvent *) ((wxPyEvent *) x));
32076 }
32077 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32078 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32079 }
32080 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32081 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32082 }
32083 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32084 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32085 }
32086 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32087 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32088 }
32089 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32090 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32091 }
32092 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32093 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32094 }
32095 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32096 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32097 }
32098 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32099 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32100 }
32101 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32102 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32103 }
32104 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32105 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32106 }
32107 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32108 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32109 }
32110 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32111 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32112 }
32113 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32114 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32115 }
32116 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32117 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32118 }
32119 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32120 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32121 }
32122 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32123 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32124 }
32125 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32126 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32127 }
32128 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32129 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32130 }
32131 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32132 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32133 }
32134 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32135 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32136 }
32137 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32138 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32139 }
32140 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32141 return (void *)((wxEvent *) ((wxShowEvent *) x));
32142 }
32143 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32144 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32145 }
32146 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32147 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32148 }
32149 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32150 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32151 }
32152 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32153 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32154 }
32155 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32156 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32157 }
32158 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32159 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32160 }
32161 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32162 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32163 }
32164 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32165 return (void *)((wxConfigBase *) ((wxConfig *) x));
32166 }
32167 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32168 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32169 }
32170 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32171 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32172 }
32173 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32174 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32175 }
32176 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32177 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32178 }
32179 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32180 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32181 }
32182 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32183 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32184 }
32185 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32186 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32187 }
32188 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32189 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32190 }
32191 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32192 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32193 }
32194 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32195 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32196 }
32197 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32198 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32199 }
32200 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32201 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32202 }
32203 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32204 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32205 }
32206 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32207 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32208 }
32209 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32210 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32211 }
32212 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32213 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32214 }
32215 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32216 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32217 }
32218 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32219 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32220 }
32221 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32222 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32223 }
32224 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32225 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32226 }
32227 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32228 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32229 }
32230 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32231 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32232 }
32233 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32234 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32235 }
32236 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32237 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32238 }
32239 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32240 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32241 }
32242 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32243 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32244 }
32245 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32246 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32247 }
32248 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32249 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32250 }
32251 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32252 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32253 }
32254 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32255 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32256 }
32257 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32258 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32259 }
32260 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32261 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32262 }
32263 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32264 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32265 }
32266 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32267 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32268 }
32269 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32270 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32271 }
32272 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32273 return (void *)((wxObject *) ((wxSizerItem *) x));
32274 }
32275 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32276 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32277 }
32278 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32279 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32280 }
32281 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32282 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32283 }
32284 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32285 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32286 }
32287 static void *_p_wxSizerTo_p_wxObject(void *x) {
32288 return (void *)((wxObject *) ((wxSizer *) x));
32289 }
32290 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32291 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32292 }
32293 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32294 return (void *)((wxObject *) ((wxFileHistory *) x));
32295 }
32296 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32297 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32298 }
32299 static void *_p_wxEventTo_p_wxObject(void *x) {
32300 return (void *)((wxObject *) ((wxEvent *) x));
32301 }
32302 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32303 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32304 }
32305 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32306 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32307 }
32308 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32309 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32310 }
32311 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32312 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32313 }
32314 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32315 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32316 }
32317 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32318 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32319 }
32320 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32321 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32322 }
32323 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32324 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32325 }
32326 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32327 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32328 }
32329 static void *_p_wxControlTo_p_wxObject(void *x) {
32330 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32331 }
32332 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32333 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32334 }
32335 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32336 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32337 }
32338 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32339 return (void *)((wxObject *) ((wxFSFile *) x));
32340 }
32341 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32342 return (void *)((wxObject *) ((wxClipboard *) x));
32343 }
32344 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32345 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32346 }
32347 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32348 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32349 }
32350 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32351 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32352 }
32353 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32354 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32355 }
32356 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32357 return (void *)((wxObject *) ((wxToolTip *) x));
32358 }
32359 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32360 return (void *)((wxObject *) ((wxMenuItem *) x));
32361 }
32362 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32363 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32364 }
32365 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32366 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32367 }
32368 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32369 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32370 }
32371 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32372 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32373 }
32374 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32375 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32376 }
32377 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32378 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32379 }
32380 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32381 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32382 }
32383 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32384 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32385 }
32386 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32387 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32388 }
32389 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32390 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32391 }
32392 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32393 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32394 }
32395 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32396 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32397 }
32398 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32399 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32400 }
32401 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32402 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32403 }
32404 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32405 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32406 }
32407 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32408 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32409 }
32410 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32411 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32412 }
32413 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32414 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32415 }
32416 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32417 return (void *)((wxObject *) ((wxImageHandler *) x));
32418 }
32419 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32420 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32421 }
32422 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32423 return (void *)((wxObject *) ((wxEvtHandler *) x));
32424 }
32425 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32426 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32427 }
32428 static void *_p_wxImageTo_p_wxObject(void *x) {
32429 return (void *)((wxObject *) ((wxImage *) x));
32430 }
32431 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32432 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32433 }
32434 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32435 return (void *)((wxObject *) ((wxSystemOptions *) x));
32436 }
32437 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32438 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32439 }
32440 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32441 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32442 }
32443 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32444 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32445 }
32446 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32447 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32448 }
32449 static void *_p_wxWindowTo_p_wxObject(void *x) {
32450 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32451 }
32452 static void *_p_wxMenuTo_p_wxObject(void *x) {
32453 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32454 }
32455 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32456 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32457 }
32458 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32459 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32460 }
32461 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32462 return (void *)((wxObject *) ((wxFileSystem *) x));
32463 }
32464 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32465 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32466 }
32467 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32468 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32469 }
32470 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32471 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32472 }
32473 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32474 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32475 }
32476 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32477 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32478 }
32479 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32480 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32481 }
32482 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32483 return (void *)((wxObject *) ((wxBusyInfo *) x));
32484 }
32485 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32486 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32487 }
32488 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32489 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32490 }
32491 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32492 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32493 }
32494 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32495 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32496 }
32497 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32498 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32499 }
32500 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32501 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32502 }
32503 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32504 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32505 }
32506 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32507 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32508 }
32509 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32510 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32511 }
32512 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32513 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32514 }
32515 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32516 return (void *)((wxLog *) ((wxLogStderr *) x));
32517 }
32518 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32519 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32520 }
32521 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32522 return (void *)((wxLog *) ((wxLogWindow *) x));
32523 }
32524 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32525 return (void *)((wxLog *) ((wxLogChain *) x));
32526 }
32527 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32528 return (void *)((wxLog *) ((wxLogGui *) x));
32529 }
32530 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32531 return (void *)((wxLog *) ((wxPyLog *) x));
32532 }
32533 static void *_p_wxControlTo_p_wxWindow(void *x) {
32534 return (void *)((wxWindow *) ((wxControl *) x));
32535 }
32536 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32537 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32538 }
32539 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32540 return (void *)((wxWindow *) ((wxMenuBar *) x));
32541 }
32542 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32543 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32544 }
32545 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32546 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32547 }
32548 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}};
32549 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}};
32550 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}};
32551 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}};
32552 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}};
32553 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}};
32554 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32555 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}};
32556 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}};
32557 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}};
32558 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}};
32559 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}};
32560 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}};
32561 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}};
32562 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}};
32563 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}};
32564 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}};
32565 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}};
32566 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}};
32567 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}};
32568 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}};
32569 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}};
32570 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}};
32571 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}};
32572 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}};
32573 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}};
32574 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}};
32575 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}};
32576 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}};
32577 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}};
32578 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}};
32579 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}};
32580 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}};
32581 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}};
32582 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}};
32583 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}};
32584 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}};
32585 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}};
32586 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}};
32587 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}};
32588 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}};
32589 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}};
32590 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}};
32591 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}};
32592 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}};
32593 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}};
32594 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}};
32595 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}};
32596 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}};
32597 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}};
32598 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}};
32599 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}};
32600 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}};
32601 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}};
32602 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}};
32603 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}};
32604 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}};
32605 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}};
32606 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}};
32607 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}};
32608 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}};
32609 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}};
32610 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}};
32611 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}};
32612 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}};
32613 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}};
32614 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}};
32615 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}};
32616 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}};
32617 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}};
32618 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}};
32619 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_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}};
32620 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}};
32621 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}};
32622 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}};
32623 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}};
32624 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}};
32625 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}};
32626 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}};
32627 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}};
32628 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}};
32629 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}};
32630 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}};
32631 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}};
32632 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}};
32633 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}};
32634 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}};
32635 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}};
32636 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}};
32637 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}};
32638 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}};
32639 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}};
32640 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}};
32641 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}};
32642 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}};
32643 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}};
32644 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}};
32645
32646 static swig_type_info *swig_types_initial[] = {
32647 _swigt__p_wxLogChain,
32648 _swigt__p_wxMutexGuiLocker,
32649 _swigt__p_wxMetafile,
32650 _swigt__p_wxFileHistory,
32651 _swigt__p_wxLog,
32652 _swigt__p_wxMenu,
32653 _swigt__p_wxEvent,
32654 _swigt__p_wxDateTime__TimeZone,
32655 _swigt__p_wxConfigBase,
32656 _swigt__p_wxDisplay,
32657 _swigt__p_wxFileType,
32658 _swigt__p_wxLogGui,
32659 _swigt__p_wxFont,
32660 _swigt__p_wxDataFormat,
32661 _swigt__p_wxTimerEvent,
32662 _swigt__p_wxCaret,
32663 _swigt__ptrdiff_t,
32664 _swigt__std__ptrdiff_t,
32665 _swigt__p_int,
32666 _swigt__p_wxSize,
32667 _swigt__p_wxClipboard,
32668 _swigt__p_wxStopWatch,
32669 _swigt__p_wxDC,
32670 _swigt__p_wxClipboardLocker,
32671 _swigt__p_wxIcon,
32672 _swigt__p_wxLogStderr,
32673 _swigt__p_wxLogTextCtrl,
32674 _swigt__p_wxTextCtrl,
32675 _swigt__p_wxBusyCursor,
32676 _swigt__p_wxBitmapDataObject,
32677 _swigt__p_wxTextDataObject,
32678 _swigt__p_wxDataObject,
32679 _swigt__p_wxPyTextDataObject,
32680 _swigt__p_wxPyBitmapDataObject,
32681 _swigt__p_wxFileDataObject,
32682 _swigt__p_wxCustomDataObject,
32683 _swigt__p_wxURLDataObject,
32684 _swigt__p_wxMetafileDataObject,
32685 _swigt__p_wxSound,
32686 _swigt__p_wxTimerRunner,
32687 _swigt__p_wxLogWindow,
32688 _swigt__p_wxTimeSpan,
32689 _swigt__p_wxArrayString,
32690 _swigt__p_wxWindowDisabler,
32691 _swigt__p_form_ops_t,
32692 _swigt__p_wxToolTip,
32693 _swigt__p_wxDataObjectComposite,
32694 _swigt__p_wxSystemSettings,
32695 _swigt__p_wxFileConfig,
32696 _swigt__p_wxVideoMode,
32697 _swigt__p_wxDataObjectSimple,
32698 _swigt__p_wxPyDataObjectSimple,
32699 _swigt__p_wxDuplexMode,
32700 _swigt__p_wxEvtHandler,
32701 _swigt__p_wxRect,
32702 _swigt__p_char,
32703 _swigt__p_wxSingleInstanceChecker,
32704 _swigt__p_wxStandardPaths,
32705 _swigt__p_wxFileTypeInfo,
32706 _swigt__p_wxFrame,
32707 _swigt__p_wxTimer,
32708 _swigt__p_wxPaperSize,
32709 _swigt__p_wxMimeTypesManager,
32710 _swigt__p_wxPyArtProvider,
32711 _swigt__p_wxPyTipProvider,
32712 _swigt__p_wxTipProvider,
32713 _swigt__p_wxJoystick,
32714 _swigt__p_wxSystemOptions,
32715 _swigt__p_wxPoint,
32716 _swigt__p_wxJoystickEvent,
32717 _swigt__p_wxCursor,
32718 _swigt__p_wxObject,
32719 _swigt__p_wxOutputStream,
32720 _swigt__p_wxDateTime,
32721 _swigt__p_wxPyDropSource,
32722 _swigt__p_unsigned_long,
32723 _swigt__p_wxKillError,
32724 _swigt__p_wxWindow,
32725 _swigt__p_wxString,
32726 _swigt__p_wxPyProcess,
32727 _swigt__p_wxBitmap,
32728 _swigt__p_wxConfig,
32729 _swigt__unsigned_int,
32730 _swigt__p_unsigned_int,
32731 _swigt__p_unsigned_char,
32732 _swigt__p_wxChar,
32733 _swigt__p_wxBusyInfo,
32734 _swigt__p_wxPyDropTarget,
32735 _swigt__p_wxPyTextDropTarget,
32736 _swigt__p_wxPyFileDropTarget,
32737 _swigt__p_wxProcessEvent,
32738 _swigt__p_wxPyLog,
32739 _swigt__p_wxLogNull,
32740 _swigt__p_wxColour,
32741 _swigt__p_wxPyTimer,
32742 _swigt__p_wxConfigPathChanger,
32743 _swigt__p_wxDateSpan,
32744 0
32745 };
32746
32747
32748 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32749
32750 static swig_const_info swig_const_table[] = {
32751 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32752 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32753 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32754 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32755 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32756 {0, 0, 0, 0.0, 0, 0}};
32757
32758 #ifdef __cplusplus
32759 }
32760 #endif
32761
32762
32763 #ifdef __cplusplus
32764 extern "C" {
32765 #endif
32766
32767 /* Python-specific SWIG API */
32768 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32769 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32770 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32771
32772 /* -----------------------------------------------------------------------------
32773 * global variable support code.
32774 * ----------------------------------------------------------------------------- */
32775
32776 typedef struct swig_globalvar {
32777 char *name; /* Name of global variable */
32778 PyObject *(*get_attr)(); /* Return the current value */
32779 int (*set_attr)(PyObject *); /* Set the value */
32780 struct swig_globalvar *next;
32781 } swig_globalvar;
32782
32783 typedef struct swig_varlinkobject {
32784 PyObject_HEAD
32785 swig_globalvar *vars;
32786 } swig_varlinkobject;
32787
32788 static PyObject *
32789 swig_varlink_repr(swig_varlinkobject *v) {
32790 v = v;
32791 return PyString_FromString("<Swig global variables>");
32792 }
32793
32794 static int
32795 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32796 swig_globalvar *var;
32797 flags = flags;
32798 fprintf(fp,"Swig global variables { ");
32799 for (var = v->vars; var; var=var->next) {
32800 fprintf(fp,"%s", var->name);
32801 if (var->next) fprintf(fp,", ");
32802 }
32803 fprintf(fp," }\n");
32804 return 0;
32805 }
32806
32807 static PyObject *
32808 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32809 swig_globalvar *var = v->vars;
32810 while (var) {
32811 if (strcmp(var->name,n) == 0) {
32812 return (*var->get_attr)();
32813 }
32814 var = var->next;
32815 }
32816 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32817 return NULL;
32818 }
32819
32820 static int
32821 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32822 swig_globalvar *var = v->vars;
32823 while (var) {
32824 if (strcmp(var->name,n) == 0) {
32825 return (*var->set_attr)(p);
32826 }
32827 var = var->next;
32828 }
32829 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32830 return 1;
32831 }
32832
32833 static PyTypeObject varlinktype = {
32834 PyObject_HEAD_INIT(0)
32835 0, /* Number of items in variable part (ob_size) */
32836 (char *)"swigvarlink", /* Type name (tp_name) */
32837 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32838 0, /* Itemsize (tp_itemsize) */
32839 0, /* Deallocator (tp_dealloc) */
32840 (printfunc) swig_varlink_print, /* Print (tp_print) */
32841 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32842 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32843 0, /* tp_compare */
32844 (reprfunc) swig_varlink_repr, /* tp_repr */
32845 0, /* tp_as_number */
32846 0, /* tp_as_sequence */
32847 0, /* tp_as_mapping */
32848 0, /* tp_hash */
32849 0, /* tp_call */
32850 0, /* tp_str */
32851 0, /* tp_getattro */
32852 0, /* tp_setattro */
32853 0, /* tp_as_buffer */
32854 0, /* tp_flags */
32855 0, /* tp_doc */
32856 #if PY_VERSION_HEX >= 0x02000000
32857 0, /* tp_traverse */
32858 0, /* tp_clear */
32859 #endif
32860 #if PY_VERSION_HEX >= 0x02010000
32861 0, /* tp_richcompare */
32862 0, /* tp_weaklistoffset */
32863 #endif
32864 #if PY_VERSION_HEX >= 0x02020000
32865 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32866 #endif
32867 #if PY_VERSION_HEX >= 0x02030000
32868 0, /* tp_del */
32869 #endif
32870 #ifdef COUNT_ALLOCS
32871 0,0,0,0 /* tp_alloc -> tp_next */
32872 #endif
32873 };
32874
32875 /* Create a variable linking object for use later */
32876 static PyObject *
32877 SWIG_Python_newvarlink(void) {
32878 swig_varlinkobject *result = 0;
32879 result = PyMem_NEW(swig_varlinkobject,1);
32880 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32881 result->ob_type = &varlinktype;
32882 result->vars = 0;
32883 result->ob_refcnt = 0;
32884 Py_XINCREF((PyObject *) result);
32885 return ((PyObject*) result);
32886 }
32887
32888 static void
32889 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32890 swig_varlinkobject *v;
32891 swig_globalvar *gv;
32892 v= (swig_varlinkobject *) p;
32893 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32894 gv->name = (char *) malloc(strlen(name)+1);
32895 strcpy(gv->name,name);
32896 gv->get_attr = get_attr;
32897 gv->set_attr = set_attr;
32898 gv->next = v->vars;
32899 v->vars = gv;
32900 }
32901
32902 /* -----------------------------------------------------------------------------
32903 * constants/methods manipulation
32904 * ----------------------------------------------------------------------------- */
32905
32906 /* Install Constants */
32907 static void
32908 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32909 PyObject *obj = 0;
32910 size_t i;
32911 for (i = 0; constants[i].type; i++) {
32912 switch(constants[i].type) {
32913 case SWIG_PY_INT:
32914 obj = PyInt_FromLong(constants[i].lvalue);
32915 break;
32916 case SWIG_PY_FLOAT:
32917 obj = PyFloat_FromDouble(constants[i].dvalue);
32918 break;
32919 case SWIG_PY_STRING:
32920 if (constants[i].pvalue) {
32921 obj = PyString_FromString((char *) constants[i].pvalue);
32922 } else {
32923 Py_INCREF(Py_None);
32924 obj = Py_None;
32925 }
32926 break;
32927 case SWIG_PY_POINTER:
32928 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32929 break;
32930 case SWIG_PY_BINARY:
32931 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32932 break;
32933 default:
32934 obj = 0;
32935 break;
32936 }
32937 if (obj) {
32938 PyDict_SetItemString(d,constants[i].name,obj);
32939 Py_DECREF(obj);
32940 }
32941 }
32942 }
32943
32944 /* -----------------------------------------------------------------------------*/
32945 /* Fix SwigMethods to carry the callback ptrs when needed */
32946 /* -----------------------------------------------------------------------------*/
32947
32948 static void
32949 SWIG_Python_FixMethods(PyMethodDef *methods,
32950 swig_const_info *const_table,
32951 swig_type_info **types,
32952 swig_type_info **types_initial) {
32953 size_t i;
32954 for (i = 0; methods[i].ml_name; ++i) {
32955 char *c = methods[i].ml_doc;
32956 if (c && (c = strstr(c, "swig_ptr: "))) {
32957 int j;
32958 swig_const_info *ci = 0;
32959 char *name = c + 10;
32960 for (j = 0; const_table[j].type; j++) {
32961 if (strncmp(const_table[j].name, name,
32962 strlen(const_table[j].name)) == 0) {
32963 ci = &(const_table[j]);
32964 break;
32965 }
32966 }
32967 if (ci) {
32968 size_t shift = (ci->ptype) - types;
32969 swig_type_info *ty = types_initial[shift];
32970 size_t ldoc = (c - methods[i].ml_doc);
32971 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32972 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32973 char *buff = ndoc;
32974 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32975 strncpy(buff, methods[i].ml_doc, ldoc);
32976 buff += ldoc;
32977 strncpy(buff, "swig_ptr: ", 10);
32978 buff += 10;
32979 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32980 methods[i].ml_doc = ndoc;
32981 }
32982 }
32983 }
32984 }
32985
32986 /* -----------------------------------------------------------------------------*
32987 * Initialize type list
32988 * -----------------------------------------------------------------------------*/
32989
32990 #if PY_MAJOR_VERSION < 2
32991 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32992 is copied out of Python/modsupport.c in python version 2.3.4 */
32993 static int
32994 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32995 {
32996 PyObject *dict;
32997 if (!PyModule_Check(m)) {
32998 PyErr_SetString(PyExc_TypeError,
32999 "PyModule_AddObject() needs module as first arg");
33000 return -1;
33001 }
33002 if (!o) {
33003 PyErr_SetString(PyExc_TypeError,
33004 "PyModule_AddObject() needs non-NULL value");
33005 return -1;
33006 }
33007
33008 dict = PyModule_GetDict(m);
33009 if (dict == NULL) {
33010 /* Internal error -- modules must have a dict! */
33011 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33012 PyModule_GetName(m));
33013 return -1;
33014 }
33015 if (PyDict_SetItemString(dict, name, o))
33016 return -1;
33017 Py_DECREF(o);
33018 return 0;
33019 }
33020 #endif
33021
33022 static swig_type_info **
33023 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33024 static PyMethodDef swig_empty_runtime_method_table[] = {
33025 {
33026 NULL, NULL, 0, NULL
33027 }
33028 };/* Sentinel */
33029
33030 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33031 swig_empty_runtime_method_table);
33032 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33033 if (pointer && module) {
33034 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33035 }
33036 return type_list_handle;
33037 }
33038
33039 static swig_type_info **
33040 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33041 swig_type_info **type_pointer;
33042
33043 /* first check if module already created */
33044 type_pointer = SWIG_Python_GetTypeListHandle();
33045 if (type_pointer) {
33046 return type_pointer;
33047 } else {
33048 /* create a new module and variable */
33049 return SWIG_Python_SetTypeListHandle(type_list_handle);
33050 }
33051 }
33052
33053 #ifdef __cplusplus
33054 }
33055 #endif
33056
33057 /* -----------------------------------------------------------------------------*
33058 * Partial Init method
33059 * -----------------------------------------------------------------------------*/
33060
33061 #ifdef SWIG_LINK_RUNTIME
33062 #ifdef __cplusplus
33063 extern "C"
33064 #endif
33065 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33066 #endif
33067
33068 #ifdef __cplusplus
33069 extern "C"
33070 #endif
33071 SWIGEXPORT(void) SWIG_init(void) {
33072 static PyObject *SWIG_globals = 0;
33073 static int typeinit = 0;
33074 PyObject *m, *d;
33075 int i;
33076 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33077
33078 /* Fix SwigMethods to carry the callback ptrs when needed */
33079 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33080
33081 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33082 d = PyModule_GetDict(m);
33083
33084 if (!typeinit) {
33085 #ifdef SWIG_LINK_RUNTIME
33086 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33087 #else
33088 # ifndef SWIG_STATIC_RUNTIME
33089 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33090 # endif
33091 #endif
33092 for (i = 0; swig_types_initial[i]; i++) {
33093 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33094 }
33095 typeinit = 1;
33096 }
33097 SWIG_InstallConstants(d,swig_const_table);
33098
33099 {
33100 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33101 }
33102 {
33103 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33104 }
33105 {
33106 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33107 }
33108 {
33109 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33110 }
33111 {
33112 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33113 }
33114 {
33115 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33116 }
33117 {
33118 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33119 }
33120 {
33121 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33122 }
33123 {
33124 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33125 }
33126 {
33127 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33128 }
33129 {
33130 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33131 }
33132 {
33133 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33134 }
33135 {
33136 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33137 }
33138 {
33139 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33140 }
33141 {
33142 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33143 }
33144 {
33145 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33146 }
33147 {
33148 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33149 }
33150 {
33151 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33152 }
33153 {
33154 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33155 }
33156 {
33157 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33158 }
33159 {
33160 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33161 }
33162 {
33163 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33164 }
33165 {
33166 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33167 }
33168 {
33169 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33170 }
33171 {
33172 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33173 }
33174 {
33175 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33176 }
33177 {
33178 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33179 }
33180 {
33181 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33182 }
33183 {
33184 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33185 }
33186 {
33187 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33188 }
33189 {
33190 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33191 }
33192 {
33193 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33194 }
33195 {
33196 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33197 }
33198 {
33199 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33200 }
33201 {
33202 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33203 }
33204 {
33205 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33206 }
33207 {
33208 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33209 }
33210 {
33211 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33212 }
33213 {
33214 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33215 }
33216 {
33217 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33218 }
33219 {
33220 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33221 }
33222 {
33223 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33224 }
33225 {
33226 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33227 }
33228 {
33229 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33230 }
33231 {
33232 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33233 }
33234 {
33235 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33236 }
33237 {
33238 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33239 }
33240 {
33241 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33242 }
33243 {
33244 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33245 }
33246 {
33247 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33248 }
33249 {
33250 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33251 }
33252 {
33253 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33254 }
33255 {
33256 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33257 }
33258 {
33259 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33260 }
33261 {
33262 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33263 }
33264 {
33265 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33266 }
33267 {
33268 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33269 }
33270 {
33271 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33272 }
33273 {
33274 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33275 }
33276 {
33277 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33278 }
33279 {
33280 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33281 }
33282 {
33283 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33284 }
33285 {
33286 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33287 }
33288 {
33289 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33290 }
33291 {
33292 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33293 }
33294 {
33295 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33296 }
33297 {
33298 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33299 }
33300 {
33301 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33302 }
33303 {
33304 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33305 }
33306 {
33307 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33308 }
33309 {
33310 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33311 }
33312 {
33313 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33314 }
33315 {
33316 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33317 }
33318 {
33319 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33320 }
33321 {
33322 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33323 }
33324 {
33325 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33326 }
33327 {
33328 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33329 }
33330 {
33331 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33332 }
33333 {
33334 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33335 }
33336 {
33337 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33338 }
33339 {
33340 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33341 }
33342 {
33343 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33344 }
33345 {
33346 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33347 }
33348 {
33349 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33350 }
33351 {
33352 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33353 }
33354 {
33355 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33356 }
33357 {
33358 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33359 }
33360 {
33361 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33362 }
33363 {
33364 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33365 }
33366 {
33367 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33368 }
33369 {
33370 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33371 }
33372 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33373 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33374 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33375 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33376 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33377 {
33378 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33388 }
33389 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33390
33391 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33392
33393 {
33394 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33413 }
33414 {
33415 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33416 }
33417 {
33418 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33419 }
33420 {
33421 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33422 }
33423 {
33424 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33425 }
33426 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33427 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33428 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33429 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33430 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33431 {
33432 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33523 }
33524 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33525 {
33526 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33539 }
33540
33541 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33542
33543 {
33544 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33563 }
33564 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33565 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33566 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33567 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33568 {
33569 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33591 }
33592 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33593 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33594 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33595 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33596 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33597 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33598 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33599 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33600 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33601 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33602 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33603 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33604 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33605 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33606 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33607 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33608 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33609 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33610 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33611 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33612 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33613 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33614 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33615 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33616 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33617 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33618 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33619 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33620 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33621 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33622 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33623 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33624 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33625 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33626 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33627 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33628 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33629 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33630 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33631 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33632 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33633 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33634 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33635 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33636 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33637
33638 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33639
33640 {
33641 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33645 }
33646 {
33647 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33648 }
33649 {
33650 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33666 }
33667 SWIG_addvarlink(SWIG_globals,(char*)"DateFormatStr",_wrap_DateFormatStr_get, _wrap_DateFormatStr_set);
33668 SWIG_addvarlink(SWIG_globals,(char*)"TimeSpanFormatStr",_wrap_TimeSpanFormatStr_get, _wrap_TimeSpanFormatStr_set);
33669 {
33670 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33722 }
33723 {
33724 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33782 }
33783 {
33784 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33974 }
33975 {
33976 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33977 }
33978 {
33979 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33980 }
33981 {
33982 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34073 }
34074 {
34075 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34133 }
34134 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34135 {
34136 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34194 }
34195 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34196 {
34197 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34198 }
34199 {
34200 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34201 }
34202 {
34203 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34204 }
34205 {
34206 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34207 }
34208 {
34209 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34210 }
34211 {
34212 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34213 }
34214 {
34215 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34216 }
34217 {
34218 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34219 }
34220 {
34221 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34222 }
34223 {
34224 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34225 }
34226 {
34227 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34228 }
34229 {
34230 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34231 }
34232
34233 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34234 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34235 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34236 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34237
34238 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34239 }
34240
wxWidgets (Impactor)