]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fix some 'might not be initialized in this function' warnings
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxDC swig_types[21]
1363 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1364 #define SWIGTYPE_p_wxIcon swig_types[23]
1365 #define SWIGTYPE_p_wxLogStderr swig_types[24]
1366 #define SWIGTYPE_p_wxLogTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxBusyCursor swig_types[27]
1369 #define SWIGTYPE_p_wxBitmapDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxTextDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyTextDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxFileDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxURLDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxMetafileDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxSound swig_types[37]
1379 #define SWIGTYPE_p_wxTimerRunner swig_types[38]
1380 #define SWIGTYPE_p_wxLogWindow swig_types[39]
1381 #define SWIGTYPE_p_wxTimeSpan swig_types[40]
1382 #define SWIGTYPE_p_wxArrayString swig_types[41]
1383 #define SWIGTYPE_p_wxWindowDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxToolTip swig_types[44]
1386 #define SWIGTYPE_p_wxDataObjectComposite swig_types[45]
1387 #define SWIGTYPE_p_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxFileConfig swig_types[47]
1389 #define SWIGTYPE_p_wxVideoMode swig_types[48]
1390 #define SWIGTYPE_p_wxDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxDuplexMode swig_types[51]
1393 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
1394 #define SWIGTYPE_p_wxRect swig_types[53]
1395 #define SWIGTYPE_p_char swig_types[54]
1396 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[55]
1397 #define SWIGTYPE_p_wxStandardPaths swig_types[56]
1398 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
1399 #define SWIGTYPE_p_wxFrame swig_types[58]
1400 #define SWIGTYPE_p_wxTimer swig_types[59]
1401 #define SWIGTYPE_p_wxPaperSize swig_types[60]
1402 #define SWIGTYPE_p_wxMimeTypesManager swig_types[61]
1403 #define SWIGTYPE_p_wxPyArtProvider swig_types[62]
1404 #define SWIGTYPE_p_wxPyTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxJoystick swig_types[65]
1407 #define SWIGTYPE_p_wxSystemOptions swig_types[66]
1408 #define SWIGTYPE_p_wxPoint swig_types[67]
1409 #define SWIGTYPE_p_wxJoystickEvent swig_types[68]
1410 #define SWIGTYPE_p_wxCursor swig_types[69]
1411 #define SWIGTYPE_p_wxObject swig_types[70]
1412 #define SWIGTYPE_p_wxOutputStream swig_types[71]
1413 #define SWIGTYPE_p_wxDateTime swig_types[72]
1414 #define SWIGTYPE_p_wxPyDropSource swig_types[73]
1415 #define SWIGTYPE_p_unsigned_long swig_types[74]
1416 #define SWIGTYPE_p_wxKillError swig_types[75]
1417 #define SWIGTYPE_p_wxWindow swig_types[76]
1418 #define SWIGTYPE_p_wxString swig_types[77]
1419 #define SWIGTYPE_p_wxPyProcess swig_types[78]
1420 #define SWIGTYPE_p_wxBitmap swig_types[79]
1421 #define SWIGTYPE_p_wxConfig swig_types[80]
1422 #define SWIGTYPE_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_char swig_types[83]
1425 #define SWIGTYPE_p_wxChar swig_types[84]
1426 #define SWIGTYPE_p_wxBusyInfo swig_types[85]
1427 #define SWIGTYPE_p_wxPyDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxProcessEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPyLog swig_types[90]
1432 #define SWIGTYPE_p_wxLogNull swig_types[91]
1433 #define SWIGTYPE_p_wxColour swig_types[92]
1434 #define SWIGTYPE_p_wxPyTimer swig_types[93]
1435 #define SWIGTYPE_p_wxConfigPathChanger swig_types[94]
1436 #define SWIGTYPE_p_wxDateSpan swig_types[95]
1437 static swig_type_info *swig_types[97];
1438
1439 /* -------- TYPES TABLE (END) -------- */
1440
1441
1442 /*-----------------------------------------------
1443 @(target):= _misc_.so
1444 ------------------------------------------------*/
1445 #define SWIG_init init_misc_
1446
1447 #define SWIG_name "_misc_"
1448
1449 #include "wx/wxPython/wxPython.h"
1450 #include "wx/wxPython/pyclasses.h"
1451 #include "wx/wxPython/pyistream.h"
1452
1453 static const wxString wxPyEmptyString(wxEmptyString);
1454
1455
1456
1457 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1458 #define SWIG_From_int PyInt_FromLong
1459 /*@@*/
1460
1461
1462 #include <limits.h>
1463
1464
1465 SWIGINTERN int
1466 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1467 const char *errmsg)
1468 {
1469 if (value < min_value) {
1470 if (errmsg) {
1471 PyErr_Format(PyExc_OverflowError,
1472 "value %ld is less than '%s' minimum %ld",
1473 value, errmsg, min_value);
1474 }
1475 return 0;
1476 } else if (value > max_value) {
1477 if (errmsg) {
1478 PyErr_Format(PyExc_OverflowError,
1479 "value %ld is greater than '%s' maximum %ld",
1480 value, errmsg, max_value);
1481 }
1482 return 0;
1483 }
1484 return 1;
1485 }
1486
1487
1488 SWIGINTERN int
1489 SWIG_AsVal_long(PyObject* obj, long* val)
1490 {
1491 if (PyNumber_Check(obj)) {
1492 if (val) *val = PyInt_AsLong(obj);
1493 return 1;
1494 }
1495 else {
1496 SWIG_type_error("number", obj);
1497 }
1498 return 0;
1499 }
1500
1501
1502 #if INT_MAX != LONG_MAX
1503 SWIGINTERN int
1504 SWIG_AsVal_int(PyObject *obj, int *val)
1505 {
1506 const char* errmsg = val ? "int" : (char*)0;
1507 long v;
1508 if (SWIG_AsVal_long(obj, &v)) {
1509 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1510 if (val) *val = (int)(v);
1511 return 1;
1512 } else {
1513 return 0;
1514 }
1515 } else {
1516 PyErr_Clear();
1517 }
1518 if (val) {
1519 SWIG_type_error(errmsg, obj);
1520 }
1521 return 0;
1522 }
1523 #else
1524 SWIGINTERNSHORT int
1525 SWIG_AsVal_int(PyObject *obj, int *val)
1526 {
1527 return SWIG_AsVal_long(obj,(long*)val);
1528 }
1529 #endif
1530
1531
1532 SWIGINTERNSHORT int
1533 SWIG_As_int(PyObject* obj)
1534 {
1535 int v;
1536 if (!SWIG_AsVal_int(obj, &v)) {
1537 /*
1538 this is needed to make valgrind/purify happier.
1539 */
1540 memset((void*)&v, 0, sizeof(int));
1541 }
1542 return v;
1543 }
1544
1545
1546 SWIGINTERNSHORT int
1547 SWIG_Check_int(PyObject* obj)
1548 {
1549 return SWIG_AsVal_int(obj, (int*)0);
1550 }
1551
1552 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1553
1554 #include <wx/stockitem.h>
1555
1556 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1557 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1558 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1559
1560 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1561 #define SWIG_From_long PyInt_FromLong
1562 /*@@*/
1563
1564
1565 SWIGINTERNSHORT long
1566 SWIG_As_long(PyObject* obj)
1567 {
1568 long v;
1569 if (!SWIG_AsVal_long(obj, &v)) {
1570 /*
1571 this is needed to make valgrind/purify happier.
1572 */
1573 memset((void*)&v, 0, sizeof(long));
1574 }
1575 return v;
1576 }
1577
1578
1579 SWIGINTERNSHORT int
1580 SWIG_Check_long(PyObject* obj)
1581 {
1582 return SWIG_AsVal_long(obj, (long*)0);
1583 }
1584
1585
1586 SWIGINTERN int
1587 SWIG_AsVal_bool(PyObject *obj, bool *val)
1588 {
1589 if (obj == Py_True) {
1590 if (val) *val = true;
1591 return 1;
1592 }
1593 if (obj == Py_False) {
1594 if (val) *val = false;
1595 return 1;
1596 }
1597 int res = 0;
1598 if (SWIG_AsVal_int(obj, &res)) {
1599 if (val) *val = res ? true : false;
1600 return 1;
1601 } else {
1602 PyErr_Clear();
1603 }
1604 if (val) {
1605 SWIG_type_error("bool", obj);
1606 }
1607 return 0;
1608 }
1609
1610
1611 SWIGINTERNSHORT bool
1612 SWIG_As_bool(PyObject* obj)
1613 {
1614 bool v;
1615 if (!SWIG_AsVal_bool(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(bool));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_bool(PyObject* obj)
1627 {
1628 return SWIG_AsVal_bool(obj, (bool*)0);
1629 }
1630
1631
1632 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1633 PyObject* o2;
1634 PyObject* o3;
1635
1636 if (!target) {
1637 target = o;
1638 } else if (target == Py_None) {
1639 Py_DECREF(Py_None);
1640 target = o;
1641 } else {
1642 if (!PyTuple_Check(target)) {
1643 o2 = target;
1644 target = PyTuple_New(1);
1645 PyTuple_SetItem(target, 0, o2);
1646 }
1647 o3 = PyTuple_New(1);
1648 PyTuple_SetItem(o3, 0, o);
1649
1650 o2 = target;
1651 target = PySequence_Concat(o2, o3);
1652 Py_DECREF(o2);
1653 Py_DECREF(o3);
1654 }
1655 return target;
1656 }
1657
1658
1659
1660 long wxGetFreeMemory()
1661 { wxPyRaiseNotImplemented(); return 0; }
1662
1663
1664 SWIGINTERN int
1665 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1666 {
1667 long v = 0;
1668 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1669 SWIG_type_error("unsigned number", obj);
1670 }
1671 else if (val)
1672 *val = (unsigned long)v;
1673 return 1;
1674 }
1675
1676
1677 SWIGINTERNSHORT unsigned long
1678 SWIG_As_unsigned_SS_long(PyObject* obj)
1679 {
1680 unsigned long v;
1681 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1682 /*
1683 this is needed to make valgrind/purify happier.
1684 */
1685 memset((void*)&v, 0, sizeof(unsigned long));
1686 }
1687 return v;
1688 }
1689
1690
1691 SWIGINTERNSHORT int
1692 SWIG_Check_unsigned_SS_long(PyObject* obj)
1693 {
1694 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1695 }
1696
1697
1698 SWIGINTERNSHORT PyObject*
1699 SWIG_From_unsigned_SS_long(unsigned long value)
1700 {
1701 return (value > LONG_MAX) ?
1702 PyLong_FromUnsignedLong(value)
1703 : PyInt_FromLong((long)(value));
1704 }
1705
1706
1707 void wxWakeUpMainThread() {}
1708
1709
1710 bool wxThread_IsMain() {
1711 #ifdef WXP_WITH_THREAD
1712 return wxThread::IsMain();
1713 #else
1714 return true;
1715 #endif
1716 }
1717
1718 static void wxCaret_Destroy(wxCaret *self){
1719 delete self;
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 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1733 #if 0
1734 , int method
1735 #endif
1736 )
1737 {
1738 #ifdef __WXMSW__
1739 #if 0
1740 switch (method)
1741 {
1742 case 1:
1743 // This one only partially works. Appears to be an undocumented
1744 // "standard" convention that not all widgets adhear to. For
1745 // example, for some widgets backgrounds or non-client areas may
1746 // not be painted.
1747 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1748 break;
1749
1750 case 2:
1751 #endif
1752 // This one works much better, nearly all widgets and their
1753 // children are captured correctly[**]. Prior to the big
1754 // background erase changes that Vadim did in 2004-2005 this
1755 // method failed badly on XP with Themes activated, most native
1756 // widgets draw only partially, if at all. Without themes it
1757 // worked just like on Win2k. After those changes this method
1758 // works very well.
1759 //
1760 // ** For example the radio buttons in a wxRadioBox are not its
1761 // children by default, but you can capture it via the panel
1762 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1763 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1764 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1765 PRF_ERASEBKGND | PRF_OWNED );
1766 return true;
1767 #if 0
1768 break;
1769
1770 case 3:
1771 // This one is only defined in the latest SDK and is only
1772 // available on XP. MSDN says it is similar to sending WM_PRINT
1773 // so I expect that it will work similar to the above. Since it
1774 // is avaialble only on XP, it can't be compiled like this and
1775 // will have to be loaded dynamically.
1776 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1777
1778 // fall through
1779
1780 case 4:
1781 // Use PrintWindow if available, or fallback to WM_PRINT
1782 // otherwise. Unfortunately using PrintWindow is even worse than
1783 // WM_PRINT. For most native widgets nothing is drawn to the dc
1784 // at all, with or without Themes.
1785 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1786 static bool s_triedToLoad = false;
1787 static PrintWindow_t pfnPrintWindow = NULL;
1788 if ( !s_triedToLoad )
1789 {
1790
1791 s_triedToLoad = true;
1792 wxDynamicLibrary dllUser32(_T("user32.dll"));
1793 if ( dllUser32.IsLoaded() )
1794 {
1795 wxLogNull nolog; // Don't report errors here
1796 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1797 }
1798 }
1799 if (pfnPrintWindow)
1800 {
1801 //printf("Using PrintWindow\n");
1802 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1803 }
1804 else
1805 {
1806 //printf("Using WM_PRINT\n");
1807 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1808 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1809 PRF_ERASEBKGND | PRF_OWNED );
1810 }
1811 }
1812 #endif // 0
1813 #else
1814 return false;
1815 #endif // __WXMSW__
1816 }
1817
1818
1819
1820 #include <wx/tipdlg.h>
1821
1822
1823 class wxPyTipProvider : public wxTipProvider {
1824 public:
1825 wxPyTipProvider(size_t currentTip)
1826 : wxTipProvider(currentTip) {}
1827
1828 DEC_PYCALLBACK_STRING__pure(GetTip);
1829 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1830 PYPRIVATE;
1831 };
1832
1833 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1834 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1835
1836
1837 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1838
1839 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1840
1841 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1842 : wxTimer(owner, id)
1843 {
1844 if (owner == NULL) SetOwner(this);
1845 }
1846
1847
1848 void wxPyTimer::Notify() {
1849 bool found;
1850 bool blocked = wxPyBeginBlockThreads();
1851 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1852 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1853 wxPyEndBlockThreads(blocked);
1854 if (! found)
1855 wxTimer::Notify();
1856 }
1857 void wxPyTimer::base_Notify() {
1858 wxTimer::Notify();
1859 }
1860
1861
1862
1863 SWIGINTERN PyObject *
1864 SWIG_FromCharPtr(const char* cptr)
1865 {
1866 if (cptr) {
1867 size_t size = strlen(cptr);
1868 if (size > INT_MAX) {
1869 return SWIG_NewPointerObj((char*)(cptr),
1870 SWIG_TypeQuery("char *"), 0);
1871 } else {
1872 if (size != 0) {
1873 return PyString_FromStringAndSize(cptr, size);
1874 } else {
1875 return PyString_FromString(cptr);
1876 }
1877 }
1878 }
1879 Py_INCREF(Py_None);
1880 return Py_None;
1881 }
1882
1883
1884 SWIGINTERNSHORT int
1885 SWIG_CheckUnsignedLongInRange(unsigned long value,
1886 unsigned long max_value,
1887 const char *errmsg)
1888 {
1889 if (value > max_value) {
1890 if (errmsg) {
1891 PyErr_Format(PyExc_OverflowError,
1892 "value %lu is greater than '%s' minimum %lu",
1893 value, errmsg, max_value);
1894 }
1895 return 0;
1896 }
1897 return 1;
1898 }
1899
1900
1901 #if UINT_MAX != ULONG_MAX
1902 SWIGINTERN int
1903 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1904 {
1905 const char* errmsg = val ? "unsigned int" : (char*)0;
1906 unsigned long v;
1907 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1908 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1909 if (val) *val = (unsigned int)(v);
1910 return 1;
1911 }
1912 } else {
1913 PyErr_Clear();
1914 }
1915 if (val) {
1916 SWIG_type_error(errmsg, obj);
1917 }
1918 return 0;
1919 }
1920 #else
1921 SWIGINTERNSHORT unsigned int
1922 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1923 {
1924 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1925 }
1926 #endif
1927
1928
1929 SWIGINTERNSHORT unsigned int
1930 SWIG_As_unsigned_SS_int(PyObject* obj)
1931 {
1932 unsigned int v;
1933 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1934 /*
1935 this is needed to make valgrind/purify happier.
1936 */
1937 memset((void*)&v, 0, sizeof(unsigned int));
1938 }
1939 return v;
1940 }
1941
1942
1943 SWIGINTERNSHORT int
1944 SWIG_Check_unsigned_SS_int(PyObject* obj)
1945 {
1946 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1947 }
1948
1949 static wxString Log_TimeStamp(){
1950 wxString msg;
1951 wxLog::TimeStamp(&msg);
1952 return msg;
1953 }
1954 static void wxLog_Destroy(wxLog *self){ delete self; }
1955 // Make somce wrappers that double any % signs so they are 'escaped'
1956 void wxPyLogFatalError(const wxString& msg)
1957 {
1958 wxString m(msg);
1959 m.Replace(wxT("%"), wxT("%%"));
1960 wxLogFatalError(m);
1961 }
1962
1963 void wxPyLogError(const wxString& msg)
1964 {
1965 wxString m(msg);
1966 m.Replace(wxT("%"), wxT("%%"));
1967 wxLogError(m);
1968 }
1969
1970 void wxPyLogWarning(const wxString& msg)
1971 {
1972 wxString m(msg);
1973 m.Replace(wxT("%"), wxT("%%"));
1974 wxLogWarning(m);
1975 }
1976
1977 void wxPyLogMessage(const wxString& msg)
1978 {
1979 wxString m(msg);
1980 m.Replace(wxT("%"), wxT("%%"));
1981 wxLogMessage(m);
1982 }
1983
1984 void wxPyLogInfo(const wxString& msg)
1985 {
1986 wxString m(msg);
1987 m.Replace(wxT("%"), wxT("%%"));
1988 wxLogInfo(m);
1989 }
1990
1991 void wxPyLogDebug(const wxString& msg)
1992 {
1993 wxString m(msg);
1994 m.Replace(wxT("%"), wxT("%%"));
1995 wxLogDebug(m);
1996 }
1997
1998 void wxPyLogVerbose(const wxString& msg)
1999 {
2000 wxString m(msg);
2001 m.Replace(wxT("%"), wxT("%%"));
2002 wxLogVerbose(m);
2003 }
2004
2005 void wxPyLogStatus(const wxString& msg)
2006 {
2007 wxString m(msg);
2008 m.Replace(wxT("%"), wxT("%%"));
2009 wxLogStatus(m);
2010 }
2011
2012 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2013 {
2014 wxString m(msg);
2015 m.Replace(wxT("%"), wxT("%%"));
2016 wxLogStatus(pFrame, m);
2017 }
2018
2019 void wxPyLogSysError(const wxString& msg)
2020 {
2021 wxString m(msg);
2022 m.Replace(wxT("%"), wxT("%%"));
2023 wxLogSysError(m);
2024 }
2025
2026 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2027 {
2028 wxString m(msg);
2029 m.Replace(wxT("%"), wxT("%%"));
2030 wxLogGeneric(level, m);
2031 }
2032
2033 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2034 {
2035 wxString m(msg);
2036 m.Replace(wxT("%"), wxT("%%"));
2037 wxLogTrace(mask, m);
2038 }
2039
2040 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2041 {
2042 wxString m(msg);
2043 m.Replace(wxT("%"), wxT("%%"));
2044 wxLogTrace(mask, m);
2045 }
2046
2047
2048
2049 // A wxLog class that can be derived from in wxPython
2050 class wxPyLog : public wxLog {
2051 public:
2052 wxPyLog() : wxLog() {}
2053
2054 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2055 bool found;
2056 bool blocked = wxPyBeginBlockThreads();
2057 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2058 PyObject* s = wx2PyString(szString);
2059 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2060 Py_DECREF(s);
2061 }
2062 wxPyEndBlockThreads(blocked);
2063 if (! found)
2064 wxLog::DoLog(level, szString, t);
2065 }
2066
2067 virtual void DoLogString(const wxChar *szString, time_t t) {
2068 bool found;
2069 bool blocked = wxPyBeginBlockThreads();
2070 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2071 PyObject* s = wx2PyString(szString);
2072 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2073 Py_DECREF(s);
2074 }
2075 wxPyEndBlockThreads(blocked);
2076 if (! found)
2077 wxLog::DoLogString(szString, t);
2078 }
2079
2080 PYPRIVATE;
2081 };
2082
2083
2084
2085
2086 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2087
2088
2089 #include <wx/joystick.h>
2090
2091
2092 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2093 // A C++ stub class for wxJoystick for platforms that don't have it.
2094 class wxJoystick : public wxObject {
2095 public:
2096 wxJoystick(int joystick = wxJOYSTICK1) {
2097 bool blocked = wxPyBeginBlockThreads();
2098 PyErr_SetString(PyExc_NotImplementedError,
2099 "wxJoystick is not available on this platform.");
2100 wxPyEndBlockThreads(blocked);
2101 }
2102 wxPoint GetPosition() { return wxPoint(-1,-1); }
2103 int GetZPosition() { return -1; }
2104 int GetButtonState() { return -1; }
2105 int GetPOVPosition() { return -1; }
2106 int GetPOVCTSPosition() { return -1; }
2107 int GetRudderPosition() { return -1; }
2108 int GetUPosition() { return -1; }
2109 int GetVPosition() { return -1; }
2110 int GetMovementThreshold() { return -1; }
2111 void SetMovementThreshold(int threshold) {}
2112
2113 bool IsOk(void) { return false; }
2114 int GetNumberJoysticks() { return -1; }
2115 int GetManufacturerId() { return -1; }
2116 int GetProductId() { return -1; }
2117 wxString GetProductName() { return wxEmptyString; }
2118 int GetXMin() { return -1; }
2119 int GetYMin() { return -1; }
2120 int GetZMin() { return -1; }
2121 int GetXMax() { return -1; }
2122 int GetYMax() { return -1; }
2123 int GetZMax() { return -1; }
2124 int GetNumberButtons() { return -1; }
2125 int GetNumberAxes() { return -1; }
2126 int GetMaxButtons() { return -1; }
2127 int GetMaxAxes() { return -1; }
2128 int GetPollingMin() { return -1; }
2129 int GetPollingMax() { return -1; }
2130 int GetRudderMin() { return -1; }
2131 int GetRudderMax() { return -1; }
2132 int GetUMin() { return -1; }
2133 int GetUMax() { return -1; }
2134 int GetVMin() { return -1; }
2135 int GetVMax() { return -1; }
2136
2137 bool HasRudder() { return false; }
2138 bool HasZ() { return false; }
2139 bool HasU() { return false; }
2140 bool HasV() { return false; }
2141 bool HasPOV() { return false; }
2142 bool HasPOV4Dir() { return false; }
2143 bool HasPOVCTS() { return false; }
2144
2145 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2146 bool ReleaseCapture() { return false; }
2147 };
2148 #endif
2149
2150
2151 #include <wx/sound.h>
2152
2153
2154 #if !wxUSE_SOUND
2155 // A C++ stub class for wxWave for platforms that don't have it.
2156 class wxSound : public wxObject
2157 {
2158 public:
2159 wxSound() {
2160 bool blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(const wxString&/*, bool*/) {
2166 bool blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171 wxSound(int, const wxByte*) {
2172 bool blocked = wxPyBeginBlockThreads();
2173 PyErr_SetString(PyExc_NotImplementedError,
2174 "wxSound is not available on this platform.");
2175 wxPyEndBlockThreads(blocked);
2176 }
2177
2178 ~wxSound() {};
2179
2180 bool Create(const wxString&/*, bool*/) { return false; }
2181 bool Create(int, const wxByte*) { return false; };
2182 bool IsOk() { return false; };
2183 bool Play(unsigned) const { return false; }
2184 static bool Play(const wxString&, unsigned) { return false; }
2185 static void Stop() {}
2186 };
2187
2188 #endif
2189
2190 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2191 if (fileName.Length() == 0)
2192 return new wxSound;
2193 else
2194 return new wxSound(fileName);
2195 }
2196 static wxSound *new_wxSound(PyObject *data){
2197 unsigned char* buffer; int size;
2198 wxSound *sound = NULL;
2199
2200 bool blocked = wxPyBeginBlockThreads();
2201 if (!PyArg_Parse(data, "t#", &buffer, &size))
2202 goto done;
2203 sound = new wxSound(size, buffer);
2204 done:
2205 wxPyEndBlockThreads(blocked);
2206 return sound;
2207 }
2208 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2209 #ifndef __WXMAC__
2210 unsigned char* buffer;
2211 int size;
2212 bool rv = false;
2213
2214 bool blocked = wxPyBeginBlockThreads();
2215 if (!PyArg_Parse(data, "t#", &buffer, &size))
2216 goto done;
2217 rv = self->Create(size, buffer);
2218 done:
2219 wxPyEndBlockThreads(blocked);
2220 return rv;
2221 #else
2222 bool blocked = wxPyBeginBlockThreads();
2223 PyErr_SetString(PyExc_NotImplementedError,
2224 "Create from data is not available on this platform.");
2225 wxPyEndBlockThreads(blocked);
2226 return false;
2227 #endif
2228 }
2229
2230 #include <wx/mimetype.h>
2231
2232 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2233 wxString str;
2234 if (self->GetMimeType(&str))
2235 return wx2PyString(str);
2236 else
2237 RETURN_NONE();
2238 }
2239 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2240 wxArrayString arr;
2241 if (self->GetMimeTypes(arr))
2242 return wxArrayString2PyList_helper(arr);
2243 else
2244 RETURN_NONE();
2245 }
2246 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2247 wxArrayString arr;
2248 if (self->GetExtensions(arr))
2249 return wxArrayString2PyList_helper(arr);
2250 else
2251 RETURN_NONE();
2252 }
2253 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2254 wxIconLocation loc;
2255 if (self->GetIcon(&loc))
2256 return new wxIcon(loc);
2257 else
2258 return NULL;
2259 }
2260 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2261 wxIconLocation loc;
2262 if (self->GetIcon(&loc)) {
2263 wxString iconFile = loc.GetFileName();
2264 int iconIndex = -1;
2265
2266
2267
2268 // Make a tuple and put the values in it
2269 bool blocked = wxPyBeginBlockThreads();
2270 PyObject* tuple = PyTuple_New(3);
2271 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2272 wxT("wxIcon"), true));
2273 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2274 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2275 wxPyEndBlockThreads(blocked);
2276 return tuple;
2277 }
2278 else
2279 RETURN_NONE();
2280 }
2281 static PyObject *wxFileType_GetDescription(wxFileType *self){
2282 wxString str;
2283 if (self->GetDescription(&str))
2284 return wx2PyString(str);
2285 else
2286 RETURN_NONE();
2287 }
2288 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2289 wxString str;
2290 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2291 return wx2PyString(str);
2292 else
2293 RETURN_NONE();
2294 }
2295 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2296 wxString str;
2297 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2298 return wx2PyString(str);
2299 else
2300 RETURN_NONE();
2301 }
2302 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2303 wxArrayString verbs;
2304 wxArrayString commands;
2305 if (self->GetAllCommands(&verbs, &commands,
2306 wxFileType::MessageParameters(filename, mimetype))) {
2307 bool blocked = wxPyBeginBlockThreads();
2308 PyObject* tuple = PyTuple_New(2);
2309 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2310 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2311 wxPyEndBlockThreads(blocked);
2312 return tuple;
2313 }
2314 else
2315 RETURN_NONE();
2316 }
2317 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2318 return wxFileType::ExpandCommand(command,
2319 wxFileType::MessageParameters(filename, mimetype));
2320 }
2321 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2322 wxArrayString arr;
2323 self->EnumAllFileTypes(arr);
2324 return wxArrayString2PyList_helper(arr);
2325 }
2326
2327 #include <wx/artprov.h>
2328
2329 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2330 static const wxString wxPyART_MENU(wxART_MENU);
2331 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2332 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2333 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2334 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2335 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2336 static const wxString wxPyART_OTHER(wxART_OTHER);
2337 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2338 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2339 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2340 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2341 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2342 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2343 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2344 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2345 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2346 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2347 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2348 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2349 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2350 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2351 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2352 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2353 static const wxString wxPyART_PRINT(wxART_PRINT);
2354 static const wxString wxPyART_HELP(wxART_HELP);
2355 static const wxString wxPyART_TIP(wxART_TIP);
2356 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2357 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2358 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2359 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2360 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2361 static const wxString wxPyART_CDROM(wxART_CDROM);
2362 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2363 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2364 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2365 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2366 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2367 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2368 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2369 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2370 static const wxString wxPyART_ERROR(wxART_ERROR);
2371 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2372 static const wxString wxPyART_WARNING(wxART_WARNING);
2373 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2374 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2375 static const wxString wxPyART_COPY(wxART_COPY);
2376 static const wxString wxPyART_CUT(wxART_CUT);
2377 static const wxString wxPyART_PASTE(wxART_PASTE);
2378 static const wxString wxPyART_DELETE(wxART_DELETE);
2379 static const wxString wxPyART_UNDO(wxART_UNDO);
2380 static const wxString wxPyART_REDO(wxART_REDO);
2381 static const wxString wxPyART_QUIT(wxART_QUIT);
2382 static const wxString wxPyART_FIND(wxART_FIND);
2383 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2384 // Python aware wxArtProvider
2385 class wxPyArtProvider : public wxArtProvider {
2386 public:
2387
2388 virtual wxBitmap CreateBitmap(const wxArtID& id,
2389 const wxArtClient& client,
2390 const wxSize& size) {
2391 wxBitmap rval = wxNullBitmap;
2392 bool blocked = wxPyBeginBlockThreads();
2393 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2394 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2395 PyObject* ro;
2396 wxBitmap* ptr;
2397 PyObject* s1, *s2;
2398 s1 = wx2PyString(id);
2399 s2 = wx2PyString(client);
2400 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2401 Py_DECREF(so);
2402 Py_DECREF(s1);
2403 Py_DECREF(s2);
2404 if (ro) {
2405 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2406 rval = *ptr;
2407 Py_DECREF(ro);
2408 }
2409 }
2410 wxPyEndBlockThreads(blocked);
2411 return rval;
2412 }
2413
2414 PYPRIVATE;
2415 };
2416
2417 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2418
2419
2420
2421 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2422 PyObject* ret = PyTuple_New(3);
2423 if (ret) {
2424 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2425 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2426 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2427 }
2428 return ret;
2429 }
2430
2431 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2432 bool cont;
2433 long index = 0;
2434 wxString value;
2435
2436 cont = self->GetFirstGroup(value, index);
2437 return __EnumerationHelper(cont, value, index);
2438 }
2439 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2440 bool cont;
2441 wxString value;
2442
2443 cont = self->GetNextGroup(value, index);
2444 return __EnumerationHelper(cont, value, index);
2445 }
2446 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2447 bool cont;
2448 long index = 0;
2449 wxString value;
2450
2451 cont = self->GetFirstEntry(value, index);
2452 return __EnumerationHelper(cont, value, index);
2453 }
2454 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2455 bool cont;
2456 wxString value;
2457
2458 cont = self->GetNextEntry(value, index);
2459 return __EnumerationHelper(cont, value, index);
2460 }
2461 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2462 long rv;
2463 self->Read(key, &rv, defaultVal);
2464 return rv;
2465 }
2466
2467 SWIGINTERN int
2468 SWIG_AsVal_double(PyObject *obj, double* val)
2469 {
2470 if (PyNumber_Check(obj)) {
2471 if (val) *val = PyFloat_AsDouble(obj);
2472 return 1;
2473 }
2474 else {
2475 SWIG_type_error("number", obj);
2476 }
2477 return 0;
2478 }
2479
2480
2481 SWIGINTERNSHORT double
2482 SWIG_As_double(PyObject* obj)
2483 {
2484 double v;
2485 if (!SWIG_AsVal_double(obj, &v)) {
2486 /*
2487 this is needed to make valgrind/purify happier.
2488 */
2489 memset((void*)&v, 0, sizeof(double));
2490 }
2491 return v;
2492 }
2493
2494
2495 SWIGINTERNSHORT int
2496 SWIG_Check_double(PyObject* obj)
2497 {
2498 return SWIG_AsVal_double(obj, (double*)0);
2499 }
2500
2501 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2502 double rv;
2503 self->Read(key, &rv, defaultVal);
2504 return rv;
2505 }
2506
2507 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2508 #define SWIG_From_double PyFloat_FromDouble
2509 /*@@*/
2510
2511 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2512 bool rv;
2513 self->Read(key, &rv, defaultVal);
2514 return rv;
2515 }
2516
2517 #include <wx/datetime.h>
2518
2519 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2520 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2521
2522 #define LOCAL_TZ wxDateTime::Local
2523
2524
2525 #if UINT_MAX < LONG_MAX
2526 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2527 #define SWIG_From_unsigned_SS_int SWIG_From_long
2528 /*@@*/
2529 #else
2530 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2531 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2532 /*@@*/
2533 #endif
2534
2535 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2536 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2537 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2538 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2539 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2540 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2541 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2542 return (*self < *other);
2543 }
2544 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2545 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2546 return (*self <= *other);
2547 }
2548 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2549 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2550 return (*self > *other);
2551 }
2552 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2553 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2554 return (*self >= *other);
2555 }
2556 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2557 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2558 return (*self == *other);
2559 }
2560 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2561 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2562 return (*self != *other);
2563 }
2564 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2565 const wxChar* rv;
2566 const wxChar* _date = date;
2567 rv = self->ParseRfc822Date(_date);
2568 if (rv == NULL) return -1;
2569 return rv - _date;
2570 }
2571 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2572 const wxChar* rv;
2573 const wxChar* _date = date;
2574 rv = self->ParseFormat(_date, format, dateDef);
2575 if (rv == NULL) return -1;
2576 return rv - _date;
2577 }
2578 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2579 const wxChar* rv;
2580 const wxChar* _datetime = datetime;
2581 rv = self->ParseDateTime(_datetime);
2582 if (rv == NULL) return -1;
2583 return rv - _datetime;
2584 }
2585 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2586 const wxChar* rv;
2587 const wxChar* _date = date;
2588 rv = self->ParseDate(_date);
2589 if (rv == NULL) return -1;
2590 return rv - _date;
2591 }
2592 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2593 const wxChar* rv;
2594 const wxChar* _time = time;
2595 rv = self->ParseTime(_time);
2596 if (rv == NULL) return -1;
2597 return rv - _time;
2598 }
2599 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2600 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2601 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2602 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2603 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2604 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2605 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2606 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2607 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2608 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2609 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2610 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2611 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2612 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2613 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2614 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2615
2616 #include <wx/dataobj.h>
2617
2618 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2619 size_t count = self->GetFormatCount(dir);
2620 wxDataFormat* formats = new wxDataFormat[count];
2621 self->GetAllFormats(formats, dir);
2622
2623 bool blocked = wxPyBeginBlockThreads();
2624 PyObject* list = PyList_New(count);
2625 for (size_t i=0; i<count; i++) {
2626 wxDataFormat* format = new wxDataFormat(formats[i]);
2627 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2628 PyList_Append(list, obj);
2629 Py_DECREF(obj);
2630 }
2631 wxPyEndBlockThreads(blocked);
2632 delete [] formats;
2633 return list;
2634 }
2635 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2636 PyObject* rval = NULL;
2637 size_t size = self->GetDataSize(format);
2638 bool blocked = wxPyBeginBlockThreads();
2639 if (size) {
2640 char* buf = new char[size];
2641 if (self->GetDataHere(format, buf))
2642 rval = PyString_FromStringAndSize(buf, size);
2643 delete [] buf;
2644 }
2645 if (! rval) {
2646 rval = Py_None;
2647 Py_INCREF(rval);
2648 }
2649 wxPyEndBlockThreads(blocked);
2650 return rval;
2651 }
2652 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2653 bool rval;
2654 bool blocked = wxPyBeginBlockThreads();
2655 if (PyString_Check(data)) {
2656 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2657 }
2658 else {
2659 // raise a TypeError if not a string
2660 PyErr_SetString(PyExc_TypeError, "String expected.");
2661 rval = false;
2662 }
2663 wxPyEndBlockThreads(blocked);
2664 return rval;
2665 }
2666 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2667 PyObject* rval = NULL;
2668 size_t size = self->GetDataSize();
2669 bool blocked = wxPyBeginBlockThreads();
2670 if (size) {
2671 char* buf = new char[size];
2672 if (self->GetDataHere(buf))
2673 rval = PyString_FromStringAndSize(buf, size);
2674 delete [] buf;
2675 }
2676 if (! rval) {
2677 rval = Py_None;
2678 Py_INCREF(rval);
2679 }
2680 wxPyEndBlockThreads(blocked);
2681 return rval;
2682 }
2683 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2684 bool rval;
2685 bool blocked = wxPyBeginBlockThreads();
2686 if (PyString_Check(data)) {
2687 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2688 }
2689 else {
2690 // raise a TypeError if not a string
2691 PyErr_SetString(PyExc_TypeError, "String expected.");
2692 rval = false;
2693 }
2694 wxPyEndBlockThreads(blocked);
2695 return rval;
2696 }
2697 // Create a new class for wxPython to use
2698 class wxPyDataObjectSimple : public wxDataObjectSimple {
2699 public:
2700 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2701 : wxDataObjectSimple(format) {}
2702
2703 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2704 bool GetDataHere(void *buf) const;
2705 bool SetData(size_t len, const void *buf) const;
2706 PYPRIVATE;
2707 };
2708
2709 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2710
2711 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2712 // We need to get the data for this object and write it to buf. I think
2713 // the best way to do this for wxPython is to have the Python method
2714 // return either a string or None and then act appropriately with the
2715 // C++ version.
2716
2717 bool rval = false;
2718 bool blocked = wxPyBeginBlockThreads();
2719 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2720 PyObject* ro;
2721 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2722 if (ro) {
2723 rval = (ro != Py_None && PyString_Check(ro));
2724 if (rval)
2725 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2726 Py_DECREF(ro);
2727 }
2728 }
2729 wxPyEndBlockThreads(blocked);
2730 return rval;
2731 }
2732
2733 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2734 // For this one we simply need to make a string from buf and len
2735 // and send it to the Python method.
2736 bool rval = false;
2737 bool blocked = wxPyBeginBlockThreads();
2738 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2739 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2740 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2741 Py_DECREF(data);
2742 }
2743 wxPyEndBlockThreads(blocked);
2744 return rval;
2745 }
2746
2747 // Create a new class for wxPython to use
2748 class wxPyTextDataObject : public wxTextDataObject {
2749 public:
2750 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2751 : wxTextDataObject(text) {}
2752
2753 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2754 DEC_PYCALLBACK_STRING__const(GetText);
2755 DEC_PYCALLBACK__STRING(SetText);
2756 PYPRIVATE;
2757 };
2758
2759 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2760 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2761 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2762
2763
2764 // Create a new class for wxPython to use
2765 class wxPyBitmapDataObject : public wxBitmapDataObject {
2766 public:
2767 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2768 : wxBitmapDataObject(bitmap) {}
2769
2770 wxBitmap GetBitmap() const;
2771 void SetBitmap(const wxBitmap& bitmap);
2772 PYPRIVATE;
2773 };
2774
2775 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2776 wxBitmap* rval = &wxNullBitmap;
2777 bool blocked = wxPyBeginBlockThreads();
2778 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2779 PyObject* ro;
2780 wxBitmap* ptr;
2781 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2782 if (ro) {
2783 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2784 rval = ptr;
2785 Py_DECREF(ro);
2786 }
2787 }
2788 wxPyEndBlockThreads(blocked);
2789 return *rval;
2790 }
2791
2792 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2793 bool blocked = wxPyBeginBlockThreads();
2794 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2795 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2796 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2797 Py_DECREF(bo);
2798 }
2799 wxPyEndBlockThreads(blocked);
2800 }
2801
2802 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2803 return new wxCustomDataObject(wxDataFormat(formatName));
2804 }
2805 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2806 bool rval;
2807 bool blocked = wxPyBeginBlockThreads();
2808 if (PyString_Check(data)) {
2809 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2810 }
2811 else {
2812 // raise a TypeError if not a string
2813 PyErr_SetString(PyExc_TypeError, "String expected.");
2814 rval = false;
2815 }
2816 wxPyEndBlockThreads(blocked);
2817 return rval;
2818 }
2819 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2820 PyObject* obj;
2821 bool blocked = wxPyBeginBlockThreads();
2822 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2823 wxPyEndBlockThreads(blocked);
2824 return obj;
2825 }
2826
2827 class wxMetafileDataObject : public wxDataObjectSimple
2828 {
2829 public:
2830 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2831 };
2832
2833
2834 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2835
2836
2837 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2838 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2839 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2840 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2841 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2842
2843
2844 class wxPyTextDropTarget : public wxTextDropTarget {
2845 public:
2846 wxPyTextDropTarget() {}
2847
2848 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2849
2850 DEC_PYCALLBACK__(OnLeave);
2851 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2852 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2853 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2854 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2855
2856 PYPRIVATE;
2857 };
2858
2859 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2860 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2861 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2862 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2864 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2865
2866
2867
2868 class wxPyFileDropTarget : public wxFileDropTarget {
2869 public:
2870 wxPyFileDropTarget() {}
2871
2872 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2873
2874 DEC_PYCALLBACK__(OnLeave);
2875 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2876 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2878 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2879
2880 PYPRIVATE;
2881 };
2882
2883 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2884 const wxArrayString& filenames) {
2885 bool rval = false;
2886 bool blocked = wxPyBeginBlockThreads();
2887 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2888 PyObject* list = wxArrayString2PyList_helper(filenames);
2889 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2890 Py_DECREF(list);
2891 }
2892 wxPyEndBlockThreads(blocked);
2893 return rval;
2894 }
2895
2896
2897
2898 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2899 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2900 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2901 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2902 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2903
2904
2905
2906
2907 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2908
2909 #include <wx/display.h>
2910
2911 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2912 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2913
2914 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2915 #if !wxUSE_DISPLAY
2916 #include <wx/dynarray.h>
2917 #include <wx/vidmode.h>
2918
2919 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2920 #include "wx/arrimpl.cpp"
2921 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2922 const wxVideoMode wxDefaultVideoMode;
2923
2924 class wxDisplay
2925 {
2926 public:
2927 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2928 ~wxDisplay() {}
2929
2930 static size_t GetCount()
2931 { wxPyRaiseNotImplemented(); return 0; }
2932
2933 static int GetFromPoint(const wxPoint& pt)
2934 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2935 static int GetFromWindow(wxWindow *window)
2936 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2937
2938 virtual bool IsOk() const { return false; }
2939 virtual wxRect GetGeometry() const { wxRect r; return r; }
2940 virtual wxString GetName() const { return wxEmptyString; }
2941 bool IsPrimary() const { return false; }
2942
2943 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2944 { wxArrayVideoModes a; return a; }
2945
2946 virtual wxVideoMode GetCurrentMode() const
2947 { return wxDefaultVideoMode; }
2948
2949 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2950 { return false; }
2951
2952 void ResetMode() {}
2953 };
2954 #endif
2955
2956 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2957 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2958 PyObject* pyList = NULL;
2959 wxArrayVideoModes arr = self->GetModes(mode);
2960 bool blocked = wxPyBeginBlockThreads();
2961 pyList = PyList_New(0);
2962 for (int i=0; i < arr.GetCount(); i++) {
2963 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2964 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2965 PyList_Append(pyList, pyObj);
2966 Py_DECREF(pyObj);
2967 }
2968 wxPyEndBlockThreads(blocked);
2969 return pyList;
2970 }
2971
2972 #include <wx/stdpaths.h>
2973
2974 static wxStandardPaths *StandardPaths_Get(){
2975 return (wxStandardPaths*) &wxStandardPaths::Get();
2976 }
2977 #ifdef __cplusplus
2978 extern "C" {
2979 #endif
2980 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2981 PyObject *resultobj;
2982 wxSystemColour arg1 ;
2983 wxColour result;
2984 PyObject * obj0 = 0 ;
2985 char *kwnames[] = {
2986 (char *) "index", NULL
2987 };
2988
2989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2990 {
2991 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2992 if (SWIG_arg_fail(1)) SWIG_fail;
2993 }
2994 {
2995 if (!wxPyCheckForApp()) SWIG_fail;
2996 PyThreadState* __tstate = wxPyBeginAllowThreads();
2997 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2998
2999 wxPyEndAllowThreads(__tstate);
3000 if (PyErr_Occurred()) SWIG_fail;
3001 }
3002 {
3003 wxColour * resultptr;
3004 resultptr = new wxColour((wxColour &)(result));
3005 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3006 }
3007 return resultobj;
3008 fail:
3009 return NULL;
3010 }
3011
3012
3013 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3014 PyObject *resultobj;
3015 wxSystemFont arg1 ;
3016 wxFont result;
3017 PyObject * obj0 = 0 ;
3018 char *kwnames[] = {
3019 (char *) "index", NULL
3020 };
3021
3022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3023 {
3024 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3025 if (SWIG_arg_fail(1)) SWIG_fail;
3026 }
3027 {
3028 if (!wxPyCheckForApp()) SWIG_fail;
3029 PyThreadState* __tstate = wxPyBeginAllowThreads();
3030 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3031
3032 wxPyEndAllowThreads(__tstate);
3033 if (PyErr_Occurred()) SWIG_fail;
3034 }
3035 {
3036 wxFont * resultptr;
3037 resultptr = new wxFont((wxFont &)(result));
3038 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3039 }
3040 return resultobj;
3041 fail:
3042 return NULL;
3043 }
3044
3045
3046 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3047 PyObject *resultobj;
3048 wxSystemMetric arg1 ;
3049 int result;
3050 PyObject * obj0 = 0 ;
3051 char *kwnames[] = {
3052 (char *) "index", NULL
3053 };
3054
3055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3056 {
3057 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3058 if (SWIG_arg_fail(1)) SWIG_fail;
3059 }
3060 {
3061 if (!wxPyCheckForApp()) SWIG_fail;
3062 PyThreadState* __tstate = wxPyBeginAllowThreads();
3063 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3064
3065 wxPyEndAllowThreads(__tstate);
3066 if (PyErr_Occurred()) SWIG_fail;
3067 }
3068 {
3069 resultobj = SWIG_From_int((int)(result));
3070 }
3071 return resultobj;
3072 fail:
3073 return NULL;
3074 }
3075
3076
3077 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3078 PyObject *resultobj;
3079 wxSystemFeature arg1 ;
3080 bool result;
3081 PyObject * obj0 = 0 ;
3082 char *kwnames[] = {
3083 (char *) "index", NULL
3084 };
3085
3086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3087 {
3088 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3089 if (SWIG_arg_fail(1)) SWIG_fail;
3090 }
3091 {
3092 if (!wxPyCheckForApp()) SWIG_fail;
3093 PyThreadState* __tstate = wxPyBeginAllowThreads();
3094 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3095
3096 wxPyEndAllowThreads(__tstate);
3097 if (PyErr_Occurred()) SWIG_fail;
3098 }
3099 {
3100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3101 }
3102 return resultobj;
3103 fail:
3104 return NULL;
3105 }
3106
3107
3108 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3109 PyObject *resultobj;
3110 wxSystemScreenType result;
3111 char *kwnames[] = {
3112 NULL
3113 };
3114
3115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3116 {
3117 if (!wxPyCheckForApp()) SWIG_fail;
3118 PyThreadState* __tstate = wxPyBeginAllowThreads();
3119 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3120
3121 wxPyEndAllowThreads(__tstate);
3122 if (PyErr_Occurred()) SWIG_fail;
3123 }
3124 resultobj = SWIG_From_int((result));
3125 return resultobj;
3126 fail:
3127 return NULL;
3128 }
3129
3130
3131 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3132 PyObject *resultobj;
3133 wxSystemScreenType arg1 ;
3134 PyObject * obj0 = 0 ;
3135 char *kwnames[] = {
3136 (char *) "screen", NULL
3137 };
3138
3139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3140 {
3141 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3142 if (SWIG_arg_fail(1)) SWIG_fail;
3143 }
3144 {
3145 if (!wxPyCheckForApp()) SWIG_fail;
3146 PyThreadState* __tstate = wxPyBeginAllowThreads();
3147 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3148
3149 wxPyEndAllowThreads(__tstate);
3150 if (PyErr_Occurred()) SWIG_fail;
3151 }
3152 Py_INCREF(Py_None); resultobj = Py_None;
3153 return resultobj;
3154 fail:
3155 return NULL;
3156 }
3157
3158
3159 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3160 PyObject *obj;
3161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3162 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3163 Py_INCREF(obj);
3164 return Py_BuildValue((char *)"");
3165 }
3166 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3167 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3168 return 1;
3169 }
3170
3171
3172 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3173 PyObject *pyobj;
3174
3175 {
3176 #if wxUSE_UNICODE
3177 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3178 #else
3179 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3180 #endif
3181 }
3182 return pyobj;
3183 }
3184
3185
3186 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3187 PyObject *resultobj;
3188 wxSystemOptions *result;
3189 char *kwnames[] = {
3190 NULL
3191 };
3192
3193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3194 {
3195 PyThreadState* __tstate = wxPyBeginAllowThreads();
3196 result = (wxSystemOptions *)new wxSystemOptions();
3197
3198 wxPyEndAllowThreads(__tstate);
3199 if (PyErr_Occurred()) SWIG_fail;
3200 }
3201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3202 return resultobj;
3203 fail:
3204 return NULL;
3205 }
3206
3207
3208 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3209 PyObject *resultobj;
3210 wxString *arg1 = 0 ;
3211 wxString *arg2 = 0 ;
3212 bool temp1 = false ;
3213 bool temp2 = false ;
3214 PyObject * obj0 = 0 ;
3215 PyObject * obj1 = 0 ;
3216 char *kwnames[] = {
3217 (char *) "name",(char *) "value", NULL
3218 };
3219
3220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3221 {
3222 arg1 = wxString_in_helper(obj0);
3223 if (arg1 == NULL) SWIG_fail;
3224 temp1 = true;
3225 }
3226 {
3227 arg2 = wxString_in_helper(obj1);
3228 if (arg2 == NULL) SWIG_fail;
3229 temp2 = true;
3230 }
3231 {
3232 PyThreadState* __tstate = wxPyBeginAllowThreads();
3233 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3234
3235 wxPyEndAllowThreads(__tstate);
3236 if (PyErr_Occurred()) SWIG_fail;
3237 }
3238 Py_INCREF(Py_None); resultobj = Py_None;
3239 {
3240 if (temp1)
3241 delete arg1;
3242 }
3243 {
3244 if (temp2)
3245 delete arg2;
3246 }
3247 return resultobj;
3248 fail:
3249 {
3250 if (temp1)
3251 delete arg1;
3252 }
3253 {
3254 if (temp2)
3255 delete arg2;
3256 }
3257 return NULL;
3258 }
3259
3260
3261 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3262 PyObject *resultobj;
3263 wxString *arg1 = 0 ;
3264 int arg2 ;
3265 bool temp1 = false ;
3266 PyObject * obj0 = 0 ;
3267 PyObject * obj1 = 0 ;
3268 char *kwnames[] = {
3269 (char *) "name",(char *) "value", NULL
3270 };
3271
3272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3273 {
3274 arg1 = wxString_in_helper(obj0);
3275 if (arg1 == NULL) SWIG_fail;
3276 temp1 = true;
3277 }
3278 {
3279 arg2 = (int)(SWIG_As_int(obj1));
3280 if (SWIG_arg_fail(2)) SWIG_fail;
3281 }
3282 {
3283 PyThreadState* __tstate = wxPyBeginAllowThreads();
3284 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3285
3286 wxPyEndAllowThreads(__tstate);
3287 if (PyErr_Occurred()) SWIG_fail;
3288 }
3289 Py_INCREF(Py_None); resultobj = Py_None;
3290 {
3291 if (temp1)
3292 delete arg1;
3293 }
3294 return resultobj;
3295 fail:
3296 {
3297 if (temp1)
3298 delete arg1;
3299 }
3300 return NULL;
3301 }
3302
3303
3304 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3305 PyObject *resultobj;
3306 wxString *arg1 = 0 ;
3307 wxString result;
3308 bool temp1 = false ;
3309 PyObject * obj0 = 0 ;
3310 char *kwnames[] = {
3311 (char *) "name", NULL
3312 };
3313
3314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3315 {
3316 arg1 = wxString_in_helper(obj0);
3317 if (arg1 == NULL) SWIG_fail;
3318 temp1 = true;
3319 }
3320 {
3321 PyThreadState* __tstate = wxPyBeginAllowThreads();
3322 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3323
3324 wxPyEndAllowThreads(__tstate);
3325 if (PyErr_Occurred()) SWIG_fail;
3326 }
3327 {
3328 #if wxUSE_UNICODE
3329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3330 #else
3331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3332 #endif
3333 }
3334 {
3335 if (temp1)
3336 delete arg1;
3337 }
3338 return resultobj;
3339 fail:
3340 {
3341 if (temp1)
3342 delete arg1;
3343 }
3344 return NULL;
3345 }
3346
3347
3348 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3349 PyObject *resultobj;
3350 wxString *arg1 = 0 ;
3351 int result;
3352 bool temp1 = false ;
3353 PyObject * obj0 = 0 ;
3354 char *kwnames[] = {
3355 (char *) "name", NULL
3356 };
3357
3358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3359 {
3360 arg1 = wxString_in_helper(obj0);
3361 if (arg1 == NULL) SWIG_fail;
3362 temp1 = true;
3363 }
3364 {
3365 PyThreadState* __tstate = wxPyBeginAllowThreads();
3366 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3367
3368 wxPyEndAllowThreads(__tstate);
3369 if (PyErr_Occurred()) SWIG_fail;
3370 }
3371 {
3372 resultobj = SWIG_From_int((int)(result));
3373 }
3374 {
3375 if (temp1)
3376 delete arg1;
3377 }
3378 return resultobj;
3379 fail:
3380 {
3381 if (temp1)
3382 delete arg1;
3383 }
3384 return NULL;
3385 }
3386
3387
3388 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3389 PyObject *resultobj;
3390 wxString *arg1 = 0 ;
3391 bool result;
3392 bool temp1 = false ;
3393 PyObject * obj0 = 0 ;
3394 char *kwnames[] = {
3395 (char *) "name", NULL
3396 };
3397
3398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3399 {
3400 arg1 = wxString_in_helper(obj0);
3401 if (arg1 == NULL) SWIG_fail;
3402 temp1 = true;
3403 }
3404 {
3405 PyThreadState* __tstate = wxPyBeginAllowThreads();
3406 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3407
3408 wxPyEndAllowThreads(__tstate);
3409 if (PyErr_Occurred()) SWIG_fail;
3410 }
3411 {
3412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3413 }
3414 {
3415 if (temp1)
3416 delete arg1;
3417 }
3418 return resultobj;
3419 fail:
3420 {
3421 if (temp1)
3422 delete arg1;
3423 }
3424 return NULL;
3425 }
3426
3427
3428 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3429 PyObject *obj;
3430 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3431 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3432 Py_INCREF(obj);
3433 return Py_BuildValue((char *)"");
3434 }
3435 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3436 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3437 return 1;
3438 }
3439
3440
3441 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3442 PyObject *pyobj;
3443
3444 {
3445 #if wxUSE_UNICODE
3446 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3447 #else
3448 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3449 #endif
3450 }
3451 return pyobj;
3452 }
3453
3454
3455 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3456 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3457 return 1;
3458 }
3459
3460
3461 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3462 PyObject *pyobj;
3463
3464 {
3465 #if wxUSE_UNICODE
3466 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3467 #else
3468 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3469 #endif
3470 }
3471 return pyobj;
3472 }
3473
3474
3475 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3476 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3477 return 1;
3478 }
3479
3480
3481 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3482 PyObject *pyobj;
3483
3484 {
3485 #if wxUSE_UNICODE
3486 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3487 #else
3488 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3489 #endif
3490 }
3491 return pyobj;
3492 }
3493
3494
3495 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3496 PyObject *resultobj;
3497 long result;
3498 char *kwnames[] = {
3499 NULL
3500 };
3501
3502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3503 {
3504 PyThreadState* __tstate = wxPyBeginAllowThreads();
3505 result = (long)wxNewId();
3506
3507 wxPyEndAllowThreads(__tstate);
3508 if (PyErr_Occurred()) SWIG_fail;
3509 }
3510 {
3511 resultobj = SWIG_From_long((long)(result));
3512 }
3513 return resultobj;
3514 fail:
3515 return NULL;
3516 }
3517
3518
3519 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3520 PyObject *resultobj;
3521 long arg1 ;
3522 PyObject * obj0 = 0 ;
3523 char *kwnames[] = {
3524 (char *) "id", NULL
3525 };
3526
3527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3528 {
3529 arg1 = (long)(SWIG_As_long(obj0));
3530 if (SWIG_arg_fail(1)) SWIG_fail;
3531 }
3532 {
3533 PyThreadState* __tstate = wxPyBeginAllowThreads();
3534 wxRegisterId(arg1);
3535
3536 wxPyEndAllowThreads(__tstate);
3537 if (PyErr_Occurred()) SWIG_fail;
3538 }
3539 Py_INCREF(Py_None); resultobj = Py_None;
3540 return resultobj;
3541 fail:
3542 return NULL;
3543 }
3544
3545
3546 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3547 PyObject *resultobj;
3548 long result;
3549 char *kwnames[] = {
3550 NULL
3551 };
3552
3553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3554 {
3555 PyThreadState* __tstate = wxPyBeginAllowThreads();
3556 result = (long)wxGetCurrentId();
3557
3558 wxPyEndAllowThreads(__tstate);
3559 if (PyErr_Occurred()) SWIG_fail;
3560 }
3561 {
3562 resultobj = SWIG_From_long((long)(result));
3563 }
3564 return resultobj;
3565 fail:
3566 return NULL;
3567 }
3568
3569
3570 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3571 PyObject *resultobj;
3572 int arg1 ;
3573 bool result;
3574 PyObject * obj0 = 0 ;
3575 char *kwnames[] = {
3576 (char *) "id", NULL
3577 };
3578
3579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3580 {
3581 arg1 = (int)(SWIG_As_int(obj0));
3582 if (SWIG_arg_fail(1)) SWIG_fail;
3583 }
3584 {
3585 PyThreadState* __tstate = wxPyBeginAllowThreads();
3586 result = (bool)wxIsStockID(arg1);
3587
3588 wxPyEndAllowThreads(__tstate);
3589 if (PyErr_Occurred()) SWIG_fail;
3590 }
3591 {
3592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3593 }
3594 return resultobj;
3595 fail:
3596 return NULL;
3597 }
3598
3599
3600 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3601 PyObject *resultobj;
3602 int arg1 ;
3603 wxString *arg2 = 0 ;
3604 bool result;
3605 bool temp2 = false ;
3606 PyObject * obj0 = 0 ;
3607 PyObject * obj1 = 0 ;
3608 char *kwnames[] = {
3609 (char *) "id",(char *) "label", NULL
3610 };
3611
3612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3613 {
3614 arg1 = (int)(SWIG_As_int(obj0));
3615 if (SWIG_arg_fail(1)) SWIG_fail;
3616 }
3617 {
3618 arg2 = wxString_in_helper(obj1);
3619 if (arg2 == NULL) SWIG_fail;
3620 temp2 = true;
3621 }
3622 {
3623 PyThreadState* __tstate = wxPyBeginAllowThreads();
3624 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3625
3626 wxPyEndAllowThreads(__tstate);
3627 if (PyErr_Occurred()) SWIG_fail;
3628 }
3629 {
3630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3631 }
3632 {
3633 if (temp2)
3634 delete arg2;
3635 }
3636 return resultobj;
3637 fail:
3638 {
3639 if (temp2)
3640 delete arg2;
3641 }
3642 return NULL;
3643 }
3644
3645
3646 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3647 PyObject *resultobj;
3648 int arg1 ;
3649 bool arg2 = (bool) true ;
3650 wxString arg3 = (wxString) wxPyEmptyString ;
3651 wxString result;
3652 PyObject * obj0 = 0 ;
3653 PyObject * obj1 = 0 ;
3654 PyObject * obj2 = 0 ;
3655 char *kwnames[] = {
3656 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3657 };
3658
3659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3660 {
3661 arg1 = (int)(SWIG_As_int(obj0));
3662 if (SWIG_arg_fail(1)) SWIG_fail;
3663 }
3664 if (obj1) {
3665 {
3666 arg2 = (bool)(SWIG_As_bool(obj1));
3667 if (SWIG_arg_fail(2)) SWIG_fail;
3668 }
3669 }
3670 if (obj2) {
3671 {
3672 wxString* sptr = wxString_in_helper(obj2);
3673 if (sptr == NULL) SWIG_fail;
3674 arg3 = *sptr;
3675 delete sptr;
3676 }
3677 }
3678 {
3679 PyThreadState* __tstate = wxPyBeginAllowThreads();
3680 result = wxGetStockLabel(arg1,arg2,arg3);
3681
3682 wxPyEndAllowThreads(__tstate);
3683 if (PyErr_Occurred()) SWIG_fail;
3684 }
3685 {
3686 #if wxUSE_UNICODE
3687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3688 #else
3689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3690 #endif
3691 }
3692 return resultobj;
3693 fail:
3694 return NULL;
3695 }
3696
3697
3698 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3699 PyObject *resultobj;
3700 char *kwnames[] = {
3701 NULL
3702 };
3703
3704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3705 {
3706 if (!wxPyCheckForApp()) SWIG_fail;
3707 PyThreadState* __tstate = wxPyBeginAllowThreads();
3708 wxBell();
3709
3710 wxPyEndAllowThreads(__tstate);
3711 if (PyErr_Occurred()) SWIG_fail;
3712 }
3713 Py_INCREF(Py_None); resultobj = Py_None;
3714 return resultobj;
3715 fail:
3716 return NULL;
3717 }
3718
3719
3720 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3721 PyObject *resultobj;
3722 char *kwnames[] = {
3723 NULL
3724 };
3725
3726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3727 {
3728 if (!wxPyCheckForApp()) SWIG_fail;
3729 PyThreadState* __tstate = wxPyBeginAllowThreads();
3730 wxEndBusyCursor();
3731
3732 wxPyEndAllowThreads(__tstate);
3733 if (PyErr_Occurred()) SWIG_fail;
3734 }
3735 Py_INCREF(Py_None); resultobj = Py_None;
3736 return resultobj;
3737 fail:
3738 return NULL;
3739 }
3740
3741
3742 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3743 PyObject *resultobj;
3744 bool arg1 = (bool) true ;
3745 long result;
3746 PyObject * obj0 = 0 ;
3747 char *kwnames[] = {
3748 (char *) "resetTimer", NULL
3749 };
3750
3751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3752 if (obj0) {
3753 {
3754 arg1 = (bool)(SWIG_As_bool(obj0));
3755 if (SWIG_arg_fail(1)) SWIG_fail;
3756 }
3757 }
3758 {
3759 PyThreadState* __tstate = wxPyBeginAllowThreads();
3760 result = (long)wxGetElapsedTime(arg1);
3761
3762 wxPyEndAllowThreads(__tstate);
3763 if (PyErr_Occurred()) SWIG_fail;
3764 }
3765 {
3766 resultobj = SWIG_From_long((long)(result));
3767 }
3768 return resultobj;
3769 fail:
3770 return NULL;
3771 }
3772
3773
3774 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3775 PyObject *resultobj;
3776 int *arg1 = (int *) 0 ;
3777 int *arg2 = (int *) 0 ;
3778 int temp1 ;
3779 int res1 = 0 ;
3780 int temp2 ;
3781 int res2 = 0 ;
3782 char *kwnames[] = {
3783 NULL
3784 };
3785
3786 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3787 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3789 {
3790 if (!wxPyCheckForApp()) SWIG_fail;
3791 PyThreadState* __tstate = wxPyBeginAllowThreads();
3792 wxGetMousePosition(arg1,arg2);
3793
3794 wxPyEndAllowThreads(__tstate);
3795 if (PyErr_Occurred()) SWIG_fail;
3796 }
3797 Py_INCREF(Py_None); resultobj = Py_None;
3798 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3799 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3800 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3801 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3802 return resultobj;
3803 fail:
3804 return NULL;
3805 }
3806
3807
3808 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3809 PyObject *resultobj;
3810 bool result;
3811 char *kwnames[] = {
3812 NULL
3813 };
3814
3815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3816 {
3817 PyThreadState* __tstate = wxPyBeginAllowThreads();
3818 result = (bool)wxIsBusy();
3819
3820 wxPyEndAllowThreads(__tstate);
3821 if (PyErr_Occurred()) SWIG_fail;
3822 }
3823 {
3824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3825 }
3826 return resultobj;
3827 fail:
3828 return NULL;
3829 }
3830
3831
3832 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3833 PyObject *resultobj;
3834 wxString result;
3835 char *kwnames[] = {
3836 NULL
3837 };
3838
3839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3840 {
3841 PyThreadState* __tstate = wxPyBeginAllowThreads();
3842 result = wxNow();
3843
3844 wxPyEndAllowThreads(__tstate);
3845 if (PyErr_Occurred()) SWIG_fail;
3846 }
3847 {
3848 #if wxUSE_UNICODE
3849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3850 #else
3851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3852 #endif
3853 }
3854 return resultobj;
3855 fail:
3856 return NULL;
3857 }
3858
3859
3860 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3861 PyObject *resultobj;
3862 wxString const &arg1_defvalue = wxPyEmptyString ;
3863 wxString *arg1 = (wxString *) &arg1_defvalue ;
3864 bool result;
3865 bool temp1 = false ;
3866 PyObject * obj0 = 0 ;
3867 char *kwnames[] = {
3868 (char *) "command", NULL
3869 };
3870
3871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3872 if (obj0) {
3873 {
3874 arg1 = wxString_in_helper(obj0);
3875 if (arg1 == NULL) SWIG_fail;
3876 temp1 = true;
3877 }
3878 }
3879 {
3880 PyThreadState* __tstate = wxPyBeginAllowThreads();
3881 result = (bool)wxShell((wxString const &)*arg1);
3882
3883 wxPyEndAllowThreads(__tstate);
3884 if (PyErr_Occurred()) SWIG_fail;
3885 }
3886 {
3887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3888 }
3889 {
3890 if (temp1)
3891 delete arg1;
3892 }
3893 return resultobj;
3894 fail:
3895 {
3896 if (temp1)
3897 delete arg1;
3898 }
3899 return NULL;
3900 }
3901
3902
3903 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3904 PyObject *resultobj;
3905 char *kwnames[] = {
3906 NULL
3907 };
3908
3909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3910 {
3911 PyThreadState* __tstate = wxPyBeginAllowThreads();
3912 wxStartTimer();
3913
3914 wxPyEndAllowThreads(__tstate);
3915 if (PyErr_Occurred()) SWIG_fail;
3916 }
3917 Py_INCREF(Py_None); resultobj = Py_None;
3918 return resultobj;
3919 fail:
3920 return NULL;
3921 }
3922
3923
3924 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3925 PyObject *resultobj;
3926 int *arg1 = (int *) 0 ;
3927 int *arg2 = (int *) 0 ;
3928 int result;
3929 int temp1 ;
3930 int res1 = 0 ;
3931 int temp2 ;
3932 int res2 = 0 ;
3933 char *kwnames[] = {
3934 NULL
3935 };
3936
3937 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3938 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3940 {
3941 PyThreadState* __tstate = wxPyBeginAllowThreads();
3942 result = (int)wxGetOsVersion(arg1,arg2);
3943
3944 wxPyEndAllowThreads(__tstate);
3945 if (PyErr_Occurred()) SWIG_fail;
3946 }
3947 {
3948 resultobj = SWIG_From_int((int)(result));
3949 }
3950 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3951 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3952 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3953 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3954 return resultobj;
3955 fail:
3956 return NULL;
3957 }
3958
3959
3960 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3961 PyObject *resultobj;
3962 wxString result;
3963 char *kwnames[] = {
3964 NULL
3965 };
3966
3967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3968 {
3969 PyThreadState* __tstate = wxPyBeginAllowThreads();
3970 result = wxGetOsDescription();
3971
3972 wxPyEndAllowThreads(__tstate);
3973 if (PyErr_Occurred()) SWIG_fail;
3974 }
3975 {
3976 #if wxUSE_UNICODE
3977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3978 #else
3979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3980 #endif
3981 }
3982 return resultobj;
3983 fail:
3984 return NULL;
3985 }
3986
3987
3988 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3989 PyObject *resultobj;
3990 long result;
3991 char *kwnames[] = {
3992 NULL
3993 };
3994
3995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3996 {
3997 PyThreadState* __tstate = wxPyBeginAllowThreads();
3998 result = (long)wxGetFreeMemory();
3999
4000 wxPyEndAllowThreads(__tstate);
4001 if (PyErr_Occurred()) SWIG_fail;
4002 }
4003 {
4004 resultobj = SWIG_From_long((long)(result));
4005 }
4006 return resultobj;
4007 fail:
4008 return NULL;
4009 }
4010
4011
4012 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4013 PyObject *resultobj;
4014 wxShutdownFlags arg1 ;
4015 bool result;
4016 PyObject * obj0 = 0 ;
4017 char *kwnames[] = {
4018 (char *) "wFlags", NULL
4019 };
4020
4021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4022 {
4023 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4024 if (SWIG_arg_fail(1)) SWIG_fail;
4025 }
4026 {
4027 if (!wxPyCheckForApp()) SWIG_fail;
4028 PyThreadState* __tstate = wxPyBeginAllowThreads();
4029 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4030
4031 wxPyEndAllowThreads(__tstate);
4032 if (PyErr_Occurred()) SWIG_fail;
4033 }
4034 {
4035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4036 }
4037 return resultobj;
4038 fail:
4039 return NULL;
4040 }
4041
4042
4043 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4044 PyObject *resultobj;
4045 int arg1 ;
4046 PyObject * obj0 = 0 ;
4047 char *kwnames[] = {
4048 (char *) "secs", NULL
4049 };
4050
4051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4052 {
4053 arg1 = (int)(SWIG_As_int(obj0));
4054 if (SWIG_arg_fail(1)) SWIG_fail;
4055 }
4056 {
4057 PyThreadState* __tstate = wxPyBeginAllowThreads();
4058 wxSleep(arg1);
4059
4060 wxPyEndAllowThreads(__tstate);
4061 if (PyErr_Occurred()) SWIG_fail;
4062 }
4063 Py_INCREF(Py_None); resultobj = Py_None;
4064 return resultobj;
4065 fail:
4066 return NULL;
4067 }
4068
4069
4070 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4071 PyObject *resultobj;
4072 unsigned long arg1 ;
4073 PyObject * obj0 = 0 ;
4074 char *kwnames[] = {
4075 (char *) "milliseconds", NULL
4076 };
4077
4078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4079 {
4080 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4081 if (SWIG_arg_fail(1)) SWIG_fail;
4082 }
4083 {
4084 PyThreadState* __tstate = wxPyBeginAllowThreads();
4085 wxMilliSleep(arg1);
4086
4087 wxPyEndAllowThreads(__tstate);
4088 if (PyErr_Occurred()) SWIG_fail;
4089 }
4090 Py_INCREF(Py_None); resultobj = Py_None;
4091 return resultobj;
4092 fail:
4093 return NULL;
4094 }
4095
4096
4097 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4098 PyObject *resultobj;
4099 unsigned long arg1 ;
4100 PyObject * obj0 = 0 ;
4101 char *kwnames[] = {
4102 (char *) "microseconds", NULL
4103 };
4104
4105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4106 {
4107 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4108 if (SWIG_arg_fail(1)) SWIG_fail;
4109 }
4110 {
4111 PyThreadState* __tstate = wxPyBeginAllowThreads();
4112 wxMicroSleep(arg1);
4113
4114 wxPyEndAllowThreads(__tstate);
4115 if (PyErr_Occurred()) SWIG_fail;
4116 }
4117 Py_INCREF(Py_None); resultobj = Py_None;
4118 return resultobj;
4119 fail:
4120 return NULL;
4121 }
4122
4123
4124 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4125 PyObject *resultobj;
4126 bool arg1 ;
4127 PyObject * obj0 = 0 ;
4128 char *kwnames[] = {
4129 (char *) "enable", NULL
4130 };
4131
4132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4133 {
4134 arg1 = (bool)(SWIG_As_bool(obj0));
4135 if (SWIG_arg_fail(1)) SWIG_fail;
4136 }
4137 {
4138 PyThreadState* __tstate = wxPyBeginAllowThreads();
4139 wxEnableTopLevelWindows(arg1);
4140
4141 wxPyEndAllowThreads(__tstate);
4142 if (PyErr_Occurred()) SWIG_fail;
4143 }
4144 Py_INCREF(Py_None); resultobj = Py_None;
4145 return resultobj;
4146 fail:
4147 return NULL;
4148 }
4149
4150
4151 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4152 PyObject *resultobj;
4153 wxString *arg1 = 0 ;
4154 wxString result;
4155 bool temp1 = false ;
4156 PyObject * obj0 = 0 ;
4157 char *kwnames[] = {
4158 (char *) "in", NULL
4159 };
4160
4161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4162 {
4163 arg1 = wxString_in_helper(obj0);
4164 if (arg1 == NULL) SWIG_fail;
4165 temp1 = true;
4166 }
4167 {
4168 PyThreadState* __tstate = wxPyBeginAllowThreads();
4169 result = wxStripMenuCodes((wxString const &)*arg1);
4170
4171 wxPyEndAllowThreads(__tstate);
4172 if (PyErr_Occurred()) SWIG_fail;
4173 }
4174 {
4175 #if wxUSE_UNICODE
4176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4177 #else
4178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4179 #endif
4180 }
4181 {
4182 if (temp1)
4183 delete arg1;
4184 }
4185 return resultobj;
4186 fail:
4187 {
4188 if (temp1)
4189 delete arg1;
4190 }
4191 return NULL;
4192 }
4193
4194
4195 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4196 PyObject *resultobj;
4197 wxString result;
4198 char *kwnames[] = {
4199 NULL
4200 };
4201
4202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4203 {
4204 PyThreadState* __tstate = wxPyBeginAllowThreads();
4205 result = wxGetEmailAddress();
4206
4207 wxPyEndAllowThreads(__tstate);
4208 if (PyErr_Occurred()) SWIG_fail;
4209 }
4210 {
4211 #if wxUSE_UNICODE
4212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4213 #else
4214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4215 #endif
4216 }
4217 return resultobj;
4218 fail:
4219 return NULL;
4220 }
4221
4222
4223 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4224 PyObject *resultobj;
4225 wxString result;
4226 char *kwnames[] = {
4227 NULL
4228 };
4229
4230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4231 {
4232 PyThreadState* __tstate = wxPyBeginAllowThreads();
4233 result = wxGetHostName();
4234
4235 wxPyEndAllowThreads(__tstate);
4236 if (PyErr_Occurred()) SWIG_fail;
4237 }
4238 {
4239 #if wxUSE_UNICODE
4240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4241 #else
4242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4243 #endif
4244 }
4245 return resultobj;
4246 fail:
4247 return NULL;
4248 }
4249
4250
4251 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4252 PyObject *resultobj;
4253 wxString result;
4254 char *kwnames[] = {
4255 NULL
4256 };
4257
4258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4259 {
4260 PyThreadState* __tstate = wxPyBeginAllowThreads();
4261 result = wxGetFullHostName();
4262
4263 wxPyEndAllowThreads(__tstate);
4264 if (PyErr_Occurred()) SWIG_fail;
4265 }
4266 {
4267 #if wxUSE_UNICODE
4268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4269 #else
4270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4271 #endif
4272 }
4273 return resultobj;
4274 fail:
4275 return NULL;
4276 }
4277
4278
4279 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4280 PyObject *resultobj;
4281 wxString result;
4282 char *kwnames[] = {
4283 NULL
4284 };
4285
4286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4287 {
4288 PyThreadState* __tstate = wxPyBeginAllowThreads();
4289 result = wxGetUserId();
4290
4291 wxPyEndAllowThreads(__tstate);
4292 if (PyErr_Occurred()) SWIG_fail;
4293 }
4294 {
4295 #if wxUSE_UNICODE
4296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4297 #else
4298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4299 #endif
4300 }
4301 return resultobj;
4302 fail:
4303 return NULL;
4304 }
4305
4306
4307 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4308 PyObject *resultobj;
4309 wxString result;
4310 char *kwnames[] = {
4311 NULL
4312 };
4313
4314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4315 {
4316 PyThreadState* __tstate = wxPyBeginAllowThreads();
4317 result = wxGetUserName();
4318
4319 wxPyEndAllowThreads(__tstate);
4320 if (PyErr_Occurred()) SWIG_fail;
4321 }
4322 {
4323 #if wxUSE_UNICODE
4324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4325 #else
4326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4327 #endif
4328 }
4329 return resultobj;
4330 fail:
4331 return NULL;
4332 }
4333
4334
4335 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4336 PyObject *resultobj;
4337 wxString result;
4338 char *kwnames[] = {
4339 NULL
4340 };
4341
4342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4343 {
4344 PyThreadState* __tstate = wxPyBeginAllowThreads();
4345 result = wxGetHomeDir();
4346
4347 wxPyEndAllowThreads(__tstate);
4348 if (PyErr_Occurred()) SWIG_fail;
4349 }
4350 {
4351 #if wxUSE_UNICODE
4352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4353 #else
4354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4355 #endif
4356 }
4357 return resultobj;
4358 fail:
4359 return NULL;
4360 }
4361
4362
4363 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4364 PyObject *resultobj;
4365 wxString const &arg1_defvalue = wxPyEmptyString ;
4366 wxString *arg1 = (wxString *) &arg1_defvalue ;
4367 wxString result;
4368 bool temp1 = false ;
4369 PyObject * obj0 = 0 ;
4370 char *kwnames[] = {
4371 (char *) "user", NULL
4372 };
4373
4374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4375 if (obj0) {
4376 {
4377 arg1 = wxString_in_helper(obj0);
4378 if (arg1 == NULL) SWIG_fail;
4379 temp1 = true;
4380 }
4381 }
4382 {
4383 PyThreadState* __tstate = wxPyBeginAllowThreads();
4384 result = wxGetUserHome((wxString const &)*arg1);
4385
4386 wxPyEndAllowThreads(__tstate);
4387 if (PyErr_Occurred()) SWIG_fail;
4388 }
4389 {
4390 #if wxUSE_UNICODE
4391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4392 #else
4393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4394 #endif
4395 }
4396 {
4397 if (temp1)
4398 delete arg1;
4399 }
4400 return resultobj;
4401 fail:
4402 {
4403 if (temp1)
4404 delete arg1;
4405 }
4406 return NULL;
4407 }
4408
4409
4410 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4411 PyObject *resultobj;
4412 unsigned long result;
4413 char *kwnames[] = {
4414 NULL
4415 };
4416
4417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4418 {
4419 PyThreadState* __tstate = wxPyBeginAllowThreads();
4420 result = (unsigned long)wxGetProcessId();
4421
4422 wxPyEndAllowThreads(__tstate);
4423 if (PyErr_Occurred()) SWIG_fail;
4424 }
4425 {
4426 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4427 }
4428 return resultobj;
4429 fail:
4430 return NULL;
4431 }
4432
4433
4434 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4435 PyObject *resultobj;
4436 char *kwnames[] = {
4437 NULL
4438 };
4439
4440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 wxTrap();
4444
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 Py_INCREF(Py_None); resultobj = Py_None;
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4456 PyObject *resultobj;
4457 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4458 wxString *arg1 = (wxString *) &arg1_defvalue ;
4459 wxString const &arg2_defvalue = wxPyEmptyString ;
4460 wxString *arg2 = (wxString *) &arg2_defvalue ;
4461 wxString const &arg3_defvalue = wxPyEmptyString ;
4462 wxString *arg3 = (wxString *) &arg3_defvalue ;
4463 wxString const &arg4_defvalue = wxPyEmptyString ;
4464 wxString *arg4 = (wxString *) &arg4_defvalue ;
4465 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4466 wxString *arg5 = (wxString *) &arg5_defvalue ;
4467 int arg6 = (int) 0 ;
4468 wxWindow *arg7 = (wxWindow *) NULL ;
4469 int arg8 = (int) -1 ;
4470 int arg9 = (int) -1 ;
4471 wxString result;
4472 bool temp1 = false ;
4473 bool temp2 = false ;
4474 bool temp3 = false ;
4475 bool temp4 = false ;
4476 bool temp5 = false ;
4477 PyObject * obj0 = 0 ;
4478 PyObject * obj1 = 0 ;
4479 PyObject * obj2 = 0 ;
4480 PyObject * obj3 = 0 ;
4481 PyObject * obj4 = 0 ;
4482 PyObject * obj5 = 0 ;
4483 PyObject * obj6 = 0 ;
4484 PyObject * obj7 = 0 ;
4485 PyObject * obj8 = 0 ;
4486 char *kwnames[] = {
4487 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4488 };
4489
4490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4491 if (obj0) {
4492 {
4493 arg1 = wxString_in_helper(obj0);
4494 if (arg1 == NULL) SWIG_fail;
4495 temp1 = true;
4496 }
4497 }
4498 if (obj1) {
4499 {
4500 arg2 = wxString_in_helper(obj1);
4501 if (arg2 == NULL) SWIG_fail;
4502 temp2 = true;
4503 }
4504 }
4505 if (obj2) {
4506 {
4507 arg3 = wxString_in_helper(obj2);
4508 if (arg3 == NULL) SWIG_fail;
4509 temp3 = true;
4510 }
4511 }
4512 if (obj3) {
4513 {
4514 arg4 = wxString_in_helper(obj3);
4515 if (arg4 == NULL) SWIG_fail;
4516 temp4 = true;
4517 }
4518 }
4519 if (obj4) {
4520 {
4521 arg5 = wxString_in_helper(obj4);
4522 if (arg5 == NULL) SWIG_fail;
4523 temp5 = true;
4524 }
4525 }
4526 if (obj5) {
4527 {
4528 arg6 = (int)(SWIG_As_int(obj5));
4529 if (SWIG_arg_fail(6)) SWIG_fail;
4530 }
4531 }
4532 if (obj6) {
4533 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4534 if (SWIG_arg_fail(7)) SWIG_fail;
4535 }
4536 if (obj7) {
4537 {
4538 arg8 = (int)(SWIG_As_int(obj7));
4539 if (SWIG_arg_fail(8)) SWIG_fail;
4540 }
4541 }
4542 if (obj8) {
4543 {
4544 arg9 = (int)(SWIG_As_int(obj8));
4545 if (SWIG_arg_fail(9)) SWIG_fail;
4546 }
4547 }
4548 {
4549 if (!wxPyCheckForApp()) SWIG_fail;
4550 PyThreadState* __tstate = wxPyBeginAllowThreads();
4551 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4552
4553 wxPyEndAllowThreads(__tstate);
4554 if (PyErr_Occurred()) SWIG_fail;
4555 }
4556 {
4557 #if wxUSE_UNICODE
4558 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4559 #else
4560 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4561 #endif
4562 }
4563 {
4564 if (temp1)
4565 delete arg1;
4566 }
4567 {
4568 if (temp2)
4569 delete arg2;
4570 }
4571 {
4572 if (temp3)
4573 delete arg3;
4574 }
4575 {
4576 if (temp4)
4577 delete arg4;
4578 }
4579 {
4580 if (temp5)
4581 delete arg5;
4582 }
4583 return resultobj;
4584 fail:
4585 {
4586 if (temp1)
4587 delete arg1;
4588 }
4589 {
4590 if (temp2)
4591 delete arg2;
4592 }
4593 {
4594 if (temp3)
4595 delete arg3;
4596 }
4597 {
4598 if (temp4)
4599 delete arg4;
4600 }
4601 {
4602 if (temp5)
4603 delete arg5;
4604 }
4605 return NULL;
4606 }
4607
4608
4609 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4610 PyObject *resultobj;
4611 wxString *arg1 = 0 ;
4612 wxString *arg2 = 0 ;
4613 wxString const &arg3_defvalue = wxPyEmptyString ;
4614 wxString *arg3 = (wxString *) &arg3_defvalue ;
4615 wxWindow *arg4 = (wxWindow *) NULL ;
4616 wxString result;
4617 bool temp1 = false ;
4618 bool temp2 = false ;
4619 bool temp3 = false ;
4620 PyObject * obj0 = 0 ;
4621 PyObject * obj1 = 0 ;
4622 PyObject * obj2 = 0 ;
4623 PyObject * obj3 = 0 ;
4624 char *kwnames[] = {
4625 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4626 };
4627
4628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4629 {
4630 arg1 = wxString_in_helper(obj0);
4631 if (arg1 == NULL) SWIG_fail;
4632 temp1 = true;
4633 }
4634 {
4635 arg2 = wxString_in_helper(obj1);
4636 if (arg2 == NULL) SWIG_fail;
4637 temp2 = true;
4638 }
4639 if (obj2) {
4640 {
4641 arg3 = wxString_in_helper(obj2);
4642 if (arg3 == NULL) SWIG_fail;
4643 temp3 = true;
4644 }
4645 }
4646 if (obj3) {
4647 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4648 if (SWIG_arg_fail(4)) SWIG_fail;
4649 }
4650 {
4651 if (!wxPyCheckForApp()) SWIG_fail;
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4654
4655 wxPyEndAllowThreads(__tstate);
4656 if (PyErr_Occurred()) SWIG_fail;
4657 }
4658 {
4659 #if wxUSE_UNICODE
4660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4661 #else
4662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4663 #endif
4664 }
4665 {
4666 if (temp1)
4667 delete arg1;
4668 }
4669 {
4670 if (temp2)
4671 delete arg2;
4672 }
4673 {
4674 if (temp3)
4675 delete arg3;
4676 }
4677 return resultobj;
4678 fail:
4679 {
4680 if (temp1)
4681 delete arg1;
4682 }
4683 {
4684 if (temp2)
4685 delete arg2;
4686 }
4687 {
4688 if (temp3)
4689 delete arg3;
4690 }
4691 return NULL;
4692 }
4693
4694
4695 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4696 PyObject *resultobj;
4697 wxString *arg1 = 0 ;
4698 wxString *arg2 = 0 ;
4699 wxString const &arg3_defvalue = wxPyEmptyString ;
4700 wxString *arg3 = (wxString *) &arg3_defvalue ;
4701 wxWindow *arg4 = (wxWindow *) NULL ;
4702 wxString result;
4703 bool temp1 = false ;
4704 bool temp2 = false ;
4705 bool temp3 = false ;
4706 PyObject * obj0 = 0 ;
4707 PyObject * obj1 = 0 ;
4708 PyObject * obj2 = 0 ;
4709 PyObject * obj3 = 0 ;
4710 char *kwnames[] = {
4711 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4712 };
4713
4714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4715 {
4716 arg1 = wxString_in_helper(obj0);
4717 if (arg1 == NULL) SWIG_fail;
4718 temp1 = true;
4719 }
4720 {
4721 arg2 = wxString_in_helper(obj1);
4722 if (arg2 == NULL) SWIG_fail;
4723 temp2 = true;
4724 }
4725 if (obj2) {
4726 {
4727 arg3 = wxString_in_helper(obj2);
4728 if (arg3 == NULL) SWIG_fail;
4729 temp3 = true;
4730 }
4731 }
4732 if (obj3) {
4733 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4734 if (SWIG_arg_fail(4)) SWIG_fail;
4735 }
4736 {
4737 if (!wxPyCheckForApp()) SWIG_fail;
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4740
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 {
4745 #if wxUSE_UNICODE
4746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4747 #else
4748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4749 #endif
4750 }
4751 {
4752 if (temp1)
4753 delete arg1;
4754 }
4755 {
4756 if (temp2)
4757 delete arg2;
4758 }
4759 {
4760 if (temp3)
4761 delete arg3;
4762 }
4763 return resultobj;
4764 fail:
4765 {
4766 if (temp1)
4767 delete arg1;
4768 }
4769 {
4770 if (temp2)
4771 delete arg2;
4772 }
4773 {
4774 if (temp3)
4775 delete arg3;
4776 }
4777 return NULL;
4778 }
4779
4780
4781 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4782 PyObject *resultobj;
4783 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4784 wxString *arg1 = (wxString *) &arg1_defvalue ;
4785 wxString const &arg2_defvalue = wxPyEmptyString ;
4786 wxString *arg2 = (wxString *) &arg2_defvalue ;
4787 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4788 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4789 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4790 wxWindow *arg5 = (wxWindow *) NULL ;
4791 wxString result;
4792 bool temp1 = false ;
4793 bool temp2 = false ;
4794 wxPoint temp4 ;
4795 PyObject * obj0 = 0 ;
4796 PyObject * obj1 = 0 ;
4797 PyObject * obj2 = 0 ;
4798 PyObject * obj3 = 0 ;
4799 PyObject * obj4 = 0 ;
4800 char *kwnames[] = {
4801 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4802 };
4803
4804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4805 if (obj0) {
4806 {
4807 arg1 = wxString_in_helper(obj0);
4808 if (arg1 == NULL) SWIG_fail;
4809 temp1 = true;
4810 }
4811 }
4812 if (obj1) {
4813 {
4814 arg2 = wxString_in_helper(obj1);
4815 if (arg2 == NULL) SWIG_fail;
4816 temp2 = true;
4817 }
4818 }
4819 if (obj2) {
4820 {
4821 arg3 = (long)(SWIG_As_long(obj2));
4822 if (SWIG_arg_fail(3)) SWIG_fail;
4823 }
4824 }
4825 if (obj3) {
4826 {
4827 arg4 = &temp4;
4828 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4829 }
4830 }
4831 if (obj4) {
4832 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4833 if (SWIG_arg_fail(5)) SWIG_fail;
4834 }
4835 {
4836 if (!wxPyCheckForApp()) SWIG_fail;
4837 PyThreadState* __tstate = wxPyBeginAllowThreads();
4838 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4839
4840 wxPyEndAllowThreads(__tstate);
4841 if (PyErr_Occurred()) SWIG_fail;
4842 }
4843 {
4844 #if wxUSE_UNICODE
4845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4846 #else
4847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4848 #endif
4849 }
4850 {
4851 if (temp1)
4852 delete arg1;
4853 }
4854 {
4855 if (temp2)
4856 delete arg2;
4857 }
4858 return resultobj;
4859 fail:
4860 {
4861 if (temp1)
4862 delete arg1;
4863 }
4864 {
4865 if (temp2)
4866 delete arg2;
4867 }
4868 return NULL;
4869 }
4870
4871
4872 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4873 PyObject *resultobj;
4874 wxString *arg1 = 0 ;
4875 wxString const &arg2_defvalue = wxPyEmptyString ;
4876 wxString *arg2 = (wxString *) &arg2_defvalue ;
4877 wxString const &arg3_defvalue = wxPyEmptyString ;
4878 wxString *arg3 = (wxString *) &arg3_defvalue ;
4879 wxWindow *arg4 = (wxWindow *) NULL ;
4880 int arg5 = (int) -1 ;
4881 int arg6 = (int) -1 ;
4882 bool arg7 = (bool) true ;
4883 wxString result;
4884 bool temp1 = false ;
4885 bool temp2 = false ;
4886 bool temp3 = false ;
4887 PyObject * obj0 = 0 ;
4888 PyObject * obj1 = 0 ;
4889 PyObject * obj2 = 0 ;
4890 PyObject * obj3 = 0 ;
4891 PyObject * obj4 = 0 ;
4892 PyObject * obj5 = 0 ;
4893 PyObject * obj6 = 0 ;
4894 char *kwnames[] = {
4895 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4896 };
4897
4898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4899 {
4900 arg1 = wxString_in_helper(obj0);
4901 if (arg1 == NULL) SWIG_fail;
4902 temp1 = true;
4903 }
4904 if (obj1) {
4905 {
4906 arg2 = wxString_in_helper(obj1);
4907 if (arg2 == NULL) SWIG_fail;
4908 temp2 = true;
4909 }
4910 }
4911 if (obj2) {
4912 {
4913 arg3 = wxString_in_helper(obj2);
4914 if (arg3 == NULL) SWIG_fail;
4915 temp3 = true;
4916 }
4917 }
4918 if (obj3) {
4919 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4920 if (SWIG_arg_fail(4)) SWIG_fail;
4921 }
4922 if (obj4) {
4923 {
4924 arg5 = (int)(SWIG_As_int(obj4));
4925 if (SWIG_arg_fail(5)) SWIG_fail;
4926 }
4927 }
4928 if (obj5) {
4929 {
4930 arg6 = (int)(SWIG_As_int(obj5));
4931 if (SWIG_arg_fail(6)) SWIG_fail;
4932 }
4933 }
4934 if (obj6) {
4935 {
4936 arg7 = (bool)(SWIG_As_bool(obj6));
4937 if (SWIG_arg_fail(7)) SWIG_fail;
4938 }
4939 }
4940 {
4941 if (!wxPyCheckForApp()) SWIG_fail;
4942 PyThreadState* __tstate = wxPyBeginAllowThreads();
4943 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4944
4945 wxPyEndAllowThreads(__tstate);
4946 if (PyErr_Occurred()) SWIG_fail;
4947 }
4948 {
4949 #if wxUSE_UNICODE
4950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4951 #else
4952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4953 #endif
4954 }
4955 {
4956 if (temp1)
4957 delete arg1;
4958 }
4959 {
4960 if (temp2)
4961 delete arg2;
4962 }
4963 {
4964 if (temp3)
4965 delete arg3;
4966 }
4967 return resultobj;
4968 fail:
4969 {
4970 if (temp1)
4971 delete arg1;
4972 }
4973 {
4974 if (temp2)
4975 delete arg2;
4976 }
4977 {
4978 if (temp3)
4979 delete arg3;
4980 }
4981 return NULL;
4982 }
4983
4984
4985 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4986 PyObject *resultobj;
4987 wxString *arg1 = 0 ;
4988 wxString const &arg2_defvalue = wxPyEmptyString ;
4989 wxString *arg2 = (wxString *) &arg2_defvalue ;
4990 wxString const &arg3_defvalue = wxPyEmptyString ;
4991 wxString *arg3 = (wxString *) &arg3_defvalue ;
4992 wxWindow *arg4 = (wxWindow *) NULL ;
4993 wxString result;
4994 bool temp1 = false ;
4995 bool temp2 = false ;
4996 bool temp3 = false ;
4997 PyObject * obj0 = 0 ;
4998 PyObject * obj1 = 0 ;
4999 PyObject * obj2 = 0 ;
5000 PyObject * obj3 = 0 ;
5001 char *kwnames[] = {
5002 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5003 };
5004
5005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5006 {
5007 arg1 = wxString_in_helper(obj0);
5008 if (arg1 == NULL) SWIG_fail;
5009 temp1 = true;
5010 }
5011 if (obj1) {
5012 {
5013 arg2 = wxString_in_helper(obj1);
5014 if (arg2 == NULL) SWIG_fail;
5015 temp2 = true;
5016 }
5017 }
5018 if (obj2) {
5019 {
5020 arg3 = wxString_in_helper(obj2);
5021 if (arg3 == NULL) SWIG_fail;
5022 temp3 = true;
5023 }
5024 }
5025 if (obj3) {
5026 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5027 if (SWIG_arg_fail(4)) SWIG_fail;
5028 }
5029 {
5030 if (!wxPyCheckForApp()) SWIG_fail;
5031 PyThreadState* __tstate = wxPyBeginAllowThreads();
5032 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5033
5034 wxPyEndAllowThreads(__tstate);
5035 if (PyErr_Occurred()) SWIG_fail;
5036 }
5037 {
5038 #if wxUSE_UNICODE
5039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5040 #else
5041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5042 #endif
5043 }
5044 {
5045 if (temp1)
5046 delete arg1;
5047 }
5048 {
5049 if (temp2)
5050 delete arg2;
5051 }
5052 {
5053 if (temp3)
5054 delete arg3;
5055 }
5056 return resultobj;
5057 fail:
5058 {
5059 if (temp1)
5060 delete arg1;
5061 }
5062 {
5063 if (temp2)
5064 delete arg2;
5065 }
5066 {
5067 if (temp3)
5068 delete arg3;
5069 }
5070 return NULL;
5071 }
5072
5073
5074 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5075 PyObject *resultobj;
5076 wxString *arg1 = 0 ;
5077 wxString *arg2 = 0 ;
5078 int arg3 ;
5079 wxString *arg4 = (wxString *) 0 ;
5080 wxWindow *arg5 = (wxWindow *) NULL ;
5081 int arg6 = (int) -1 ;
5082 int arg7 = (int) -1 ;
5083 bool arg8 = (bool) true ;
5084 int arg9 = (int) 150 ;
5085 int arg10 = (int) 200 ;
5086 wxString result;
5087 bool temp1 = false ;
5088 bool temp2 = false ;
5089 PyObject * obj0 = 0 ;
5090 PyObject * obj1 = 0 ;
5091 PyObject * obj2 = 0 ;
5092 PyObject * obj3 = 0 ;
5093 PyObject * obj4 = 0 ;
5094 PyObject * obj5 = 0 ;
5095 PyObject * obj6 = 0 ;
5096 PyObject * obj7 = 0 ;
5097 PyObject * obj8 = 0 ;
5098 char *kwnames[] = {
5099 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5100 };
5101
5102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5103 {
5104 arg1 = wxString_in_helper(obj0);
5105 if (arg1 == NULL) SWIG_fail;
5106 temp1 = true;
5107 }
5108 {
5109 arg2 = wxString_in_helper(obj1);
5110 if (arg2 == NULL) SWIG_fail;
5111 temp2 = true;
5112 }
5113 {
5114 arg3 = PyList_Size(obj2);
5115 arg4 = wxString_LIST_helper(obj2);
5116 if (arg4 == NULL) SWIG_fail;
5117 }
5118 if (obj3) {
5119 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5120 if (SWIG_arg_fail(5)) SWIG_fail;
5121 }
5122 if (obj4) {
5123 {
5124 arg6 = (int)(SWIG_As_int(obj4));
5125 if (SWIG_arg_fail(6)) SWIG_fail;
5126 }
5127 }
5128 if (obj5) {
5129 {
5130 arg7 = (int)(SWIG_As_int(obj5));
5131 if (SWIG_arg_fail(7)) SWIG_fail;
5132 }
5133 }
5134 if (obj6) {
5135 {
5136 arg8 = (bool)(SWIG_As_bool(obj6));
5137 if (SWIG_arg_fail(8)) SWIG_fail;
5138 }
5139 }
5140 if (obj7) {
5141 {
5142 arg9 = (int)(SWIG_As_int(obj7));
5143 if (SWIG_arg_fail(9)) SWIG_fail;
5144 }
5145 }
5146 if (obj8) {
5147 {
5148 arg10 = (int)(SWIG_As_int(obj8));
5149 if (SWIG_arg_fail(10)) SWIG_fail;
5150 }
5151 }
5152 {
5153 if (!wxPyCheckForApp()) SWIG_fail;
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5156
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 {
5161 #if wxUSE_UNICODE
5162 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5163 #else
5164 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5165 #endif
5166 }
5167 {
5168 if (temp1)
5169 delete arg1;
5170 }
5171 {
5172 if (temp2)
5173 delete arg2;
5174 }
5175 {
5176 if (arg4) delete [] arg4;
5177 }
5178 return resultobj;
5179 fail:
5180 {
5181 if (temp1)
5182 delete arg1;
5183 }
5184 {
5185 if (temp2)
5186 delete arg2;
5187 }
5188 {
5189 if (arg4) delete [] arg4;
5190 }
5191 return NULL;
5192 }
5193
5194
5195 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5196 PyObject *resultobj;
5197 wxString *arg1 = 0 ;
5198 wxString *arg2 = 0 ;
5199 int arg3 ;
5200 wxString *arg4 = (wxString *) 0 ;
5201 wxWindow *arg5 = (wxWindow *) NULL ;
5202 int arg6 = (int) -1 ;
5203 int arg7 = (int) -1 ;
5204 bool arg8 = (bool) true ;
5205 int arg9 = (int) 150 ;
5206 int arg10 = (int) 200 ;
5207 int result;
5208 bool temp1 = false ;
5209 bool temp2 = false ;
5210 PyObject * obj0 = 0 ;
5211 PyObject * obj1 = 0 ;
5212 PyObject * obj2 = 0 ;
5213 PyObject * obj3 = 0 ;
5214 PyObject * obj4 = 0 ;
5215 PyObject * obj5 = 0 ;
5216 PyObject * obj6 = 0 ;
5217 PyObject * obj7 = 0 ;
5218 PyObject * obj8 = 0 ;
5219 char *kwnames[] = {
5220 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5221 };
5222
5223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5224 {
5225 arg1 = wxString_in_helper(obj0);
5226 if (arg1 == NULL) SWIG_fail;
5227 temp1 = true;
5228 }
5229 {
5230 arg2 = wxString_in_helper(obj1);
5231 if (arg2 == NULL) SWIG_fail;
5232 temp2 = true;
5233 }
5234 {
5235 arg3 = PyList_Size(obj2);
5236 arg4 = wxString_LIST_helper(obj2);
5237 if (arg4 == NULL) SWIG_fail;
5238 }
5239 if (obj3) {
5240 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5241 if (SWIG_arg_fail(5)) SWIG_fail;
5242 }
5243 if (obj4) {
5244 {
5245 arg6 = (int)(SWIG_As_int(obj4));
5246 if (SWIG_arg_fail(6)) SWIG_fail;
5247 }
5248 }
5249 if (obj5) {
5250 {
5251 arg7 = (int)(SWIG_As_int(obj5));
5252 if (SWIG_arg_fail(7)) SWIG_fail;
5253 }
5254 }
5255 if (obj6) {
5256 {
5257 arg8 = (bool)(SWIG_As_bool(obj6));
5258 if (SWIG_arg_fail(8)) SWIG_fail;
5259 }
5260 }
5261 if (obj7) {
5262 {
5263 arg9 = (int)(SWIG_As_int(obj7));
5264 if (SWIG_arg_fail(9)) SWIG_fail;
5265 }
5266 }
5267 if (obj8) {
5268 {
5269 arg10 = (int)(SWIG_As_int(obj8));
5270 if (SWIG_arg_fail(10)) SWIG_fail;
5271 }
5272 }
5273 {
5274 if (!wxPyCheckForApp()) SWIG_fail;
5275 PyThreadState* __tstate = wxPyBeginAllowThreads();
5276 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5277
5278 wxPyEndAllowThreads(__tstate);
5279 if (PyErr_Occurred()) SWIG_fail;
5280 }
5281 {
5282 resultobj = SWIG_From_int((int)(result));
5283 }
5284 {
5285 if (temp1)
5286 delete arg1;
5287 }
5288 {
5289 if (temp2)
5290 delete arg2;
5291 }
5292 {
5293 if (arg4) delete [] arg4;
5294 }
5295 return resultobj;
5296 fail:
5297 {
5298 if (temp1)
5299 delete arg1;
5300 }
5301 {
5302 if (temp2)
5303 delete arg2;
5304 }
5305 {
5306 if (arg4) delete [] arg4;
5307 }
5308 return NULL;
5309 }
5310
5311
5312 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5313 PyObject *resultobj;
5314 wxString *arg1 = 0 ;
5315 wxString const &arg2_defvalue = wxPyEmptyString ;
5316 wxString *arg2 = (wxString *) &arg2_defvalue ;
5317 int arg3 = (int) wxOK|wxCENTRE ;
5318 wxWindow *arg4 = (wxWindow *) NULL ;
5319 int arg5 = (int) -1 ;
5320 int arg6 = (int) -1 ;
5321 int result;
5322 bool temp1 = false ;
5323 bool temp2 = false ;
5324 PyObject * obj0 = 0 ;
5325 PyObject * obj1 = 0 ;
5326 PyObject * obj2 = 0 ;
5327 PyObject * obj3 = 0 ;
5328 PyObject * obj4 = 0 ;
5329 PyObject * obj5 = 0 ;
5330 char *kwnames[] = {
5331 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5332 };
5333
5334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5335 {
5336 arg1 = wxString_in_helper(obj0);
5337 if (arg1 == NULL) SWIG_fail;
5338 temp1 = true;
5339 }
5340 if (obj1) {
5341 {
5342 arg2 = wxString_in_helper(obj1);
5343 if (arg2 == NULL) SWIG_fail;
5344 temp2 = true;
5345 }
5346 }
5347 if (obj2) {
5348 {
5349 arg3 = (int)(SWIG_As_int(obj2));
5350 if (SWIG_arg_fail(3)) SWIG_fail;
5351 }
5352 }
5353 if (obj3) {
5354 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5355 if (SWIG_arg_fail(4)) SWIG_fail;
5356 }
5357 if (obj4) {
5358 {
5359 arg5 = (int)(SWIG_As_int(obj4));
5360 if (SWIG_arg_fail(5)) SWIG_fail;
5361 }
5362 }
5363 if (obj5) {
5364 {
5365 arg6 = (int)(SWIG_As_int(obj5));
5366 if (SWIG_arg_fail(6)) SWIG_fail;
5367 }
5368 }
5369 {
5370 if (!wxPyCheckForApp()) SWIG_fail;
5371 PyThreadState* __tstate = wxPyBeginAllowThreads();
5372 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5373
5374 wxPyEndAllowThreads(__tstate);
5375 if (PyErr_Occurred()) SWIG_fail;
5376 }
5377 {
5378 resultobj = SWIG_From_int((int)(result));
5379 }
5380 {
5381 if (temp1)
5382 delete arg1;
5383 }
5384 {
5385 if (temp2)
5386 delete arg2;
5387 }
5388 return resultobj;
5389 fail:
5390 {
5391 if (temp1)
5392 delete arg1;
5393 }
5394 {
5395 if (temp2)
5396 delete arg2;
5397 }
5398 return NULL;
5399 }
5400
5401
5402 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5403 PyObject *resultobj;
5404 wxString *arg1 = 0 ;
5405 wxString *arg2 = 0 ;
5406 wxString *arg3 = 0 ;
5407 long arg4 ;
5408 long arg5 = (long) 0 ;
5409 long arg6 = (long) 100 ;
5410 wxWindow *arg7 = (wxWindow *) NULL ;
5411 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5412 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5413 long result;
5414 bool temp1 = false ;
5415 bool temp2 = false ;
5416 bool temp3 = false ;
5417 wxPoint temp8 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 PyObject * obj2 = 0 ;
5421 PyObject * obj3 = 0 ;
5422 PyObject * obj4 = 0 ;
5423 PyObject * obj5 = 0 ;
5424 PyObject * obj6 = 0 ;
5425 PyObject * obj7 = 0 ;
5426 char *kwnames[] = {
5427 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5428 };
5429
5430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5431 {
5432 arg1 = wxString_in_helper(obj0);
5433 if (arg1 == NULL) SWIG_fail;
5434 temp1 = true;
5435 }
5436 {
5437 arg2 = wxString_in_helper(obj1);
5438 if (arg2 == NULL) SWIG_fail;
5439 temp2 = true;
5440 }
5441 {
5442 arg3 = wxString_in_helper(obj2);
5443 if (arg3 == NULL) SWIG_fail;
5444 temp3 = true;
5445 }
5446 {
5447 arg4 = (long)(SWIG_As_long(obj3));
5448 if (SWIG_arg_fail(4)) SWIG_fail;
5449 }
5450 if (obj4) {
5451 {
5452 arg5 = (long)(SWIG_As_long(obj4));
5453 if (SWIG_arg_fail(5)) SWIG_fail;
5454 }
5455 }
5456 if (obj5) {
5457 {
5458 arg6 = (long)(SWIG_As_long(obj5));
5459 if (SWIG_arg_fail(6)) SWIG_fail;
5460 }
5461 }
5462 if (obj6) {
5463 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5464 if (SWIG_arg_fail(7)) SWIG_fail;
5465 }
5466 if (obj7) {
5467 {
5468 arg8 = &temp8;
5469 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5470 }
5471 }
5472 {
5473 if (!wxPyCheckForApp()) SWIG_fail;
5474 PyThreadState* __tstate = wxPyBeginAllowThreads();
5475 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5476
5477 wxPyEndAllowThreads(__tstate);
5478 if (PyErr_Occurred()) SWIG_fail;
5479 }
5480 {
5481 resultobj = SWIG_From_long((long)(result));
5482 }
5483 {
5484 if (temp1)
5485 delete arg1;
5486 }
5487 {
5488 if (temp2)
5489 delete arg2;
5490 }
5491 {
5492 if (temp3)
5493 delete arg3;
5494 }
5495 return resultobj;
5496 fail:
5497 {
5498 if (temp1)
5499 delete arg1;
5500 }
5501 {
5502 if (temp2)
5503 delete arg2;
5504 }
5505 {
5506 if (temp3)
5507 delete arg3;
5508 }
5509 return NULL;
5510 }
5511
5512
5513 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5514 PyObject *resultobj;
5515 bool result;
5516 char *kwnames[] = {
5517 NULL
5518 };
5519
5520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5521 {
5522 if (!wxPyCheckForApp()) SWIG_fail;
5523 PyThreadState* __tstate = wxPyBeginAllowThreads();
5524 result = (bool)wxColourDisplay();
5525
5526 wxPyEndAllowThreads(__tstate);
5527 if (PyErr_Occurred()) SWIG_fail;
5528 }
5529 {
5530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5531 }
5532 return resultobj;
5533 fail:
5534 return NULL;
5535 }
5536
5537
5538 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5539 PyObject *resultobj;
5540 int result;
5541 char *kwnames[] = {
5542 NULL
5543 };
5544
5545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5546 {
5547 if (!wxPyCheckForApp()) SWIG_fail;
5548 PyThreadState* __tstate = wxPyBeginAllowThreads();
5549 result = (int)wxDisplayDepth();
5550
5551 wxPyEndAllowThreads(__tstate);
5552 if (PyErr_Occurred()) SWIG_fail;
5553 }
5554 {
5555 resultobj = SWIG_From_int((int)(result));
5556 }
5557 return resultobj;
5558 fail:
5559 return NULL;
5560 }
5561
5562
5563 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5564 PyObject *resultobj;
5565 int result;
5566 char *kwnames[] = {
5567 NULL
5568 };
5569
5570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5571 {
5572 if (!wxPyCheckForApp()) SWIG_fail;
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = (int)wxGetDisplayDepth();
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = SWIG_From_int((int)(result));
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj;
5590 int *arg1 = (int *) 0 ;
5591 int *arg2 = (int *) 0 ;
5592 int temp1 ;
5593 int res1 = 0 ;
5594 int temp2 ;
5595 int res2 = 0 ;
5596 char *kwnames[] = {
5597 NULL
5598 };
5599
5600 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5601 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5603 {
5604 if (!wxPyCheckForApp()) SWIG_fail;
5605 PyThreadState* __tstate = wxPyBeginAllowThreads();
5606 wxDisplaySize(arg1,arg2);
5607
5608 wxPyEndAllowThreads(__tstate);
5609 if (PyErr_Occurred()) SWIG_fail;
5610 }
5611 Py_INCREF(Py_None); resultobj = Py_None;
5612 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5613 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5614 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5615 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5623 PyObject *resultobj;
5624 wxSize result;
5625 char *kwnames[] = {
5626 NULL
5627 };
5628
5629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5630 {
5631 if (!wxPyCheckForApp()) SWIG_fail;
5632 PyThreadState* __tstate = wxPyBeginAllowThreads();
5633 result = wxGetDisplaySize();
5634
5635 wxPyEndAllowThreads(__tstate);
5636 if (PyErr_Occurred()) SWIG_fail;
5637 }
5638 {
5639 wxSize * resultptr;
5640 resultptr = new wxSize((wxSize &)(result));
5641 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5642 }
5643 return resultobj;
5644 fail:
5645 return NULL;
5646 }
5647
5648
5649 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5650 PyObject *resultobj;
5651 int *arg1 = (int *) 0 ;
5652 int *arg2 = (int *) 0 ;
5653 int temp1 ;
5654 int res1 = 0 ;
5655 int temp2 ;
5656 int res2 = 0 ;
5657 char *kwnames[] = {
5658 NULL
5659 };
5660
5661 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5662 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5664 {
5665 if (!wxPyCheckForApp()) SWIG_fail;
5666 PyThreadState* __tstate = wxPyBeginAllowThreads();
5667 wxDisplaySizeMM(arg1,arg2);
5668
5669 wxPyEndAllowThreads(__tstate);
5670 if (PyErr_Occurred()) SWIG_fail;
5671 }
5672 Py_INCREF(Py_None); resultobj = Py_None;
5673 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5674 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5675 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5676 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5677 return resultobj;
5678 fail:
5679 return NULL;
5680 }
5681
5682
5683 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5684 PyObject *resultobj;
5685 wxSize result;
5686 char *kwnames[] = {
5687 NULL
5688 };
5689
5690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5691 {
5692 if (!wxPyCheckForApp()) SWIG_fail;
5693 PyThreadState* __tstate = wxPyBeginAllowThreads();
5694 result = wxGetDisplaySizeMM();
5695
5696 wxPyEndAllowThreads(__tstate);
5697 if (PyErr_Occurred()) SWIG_fail;
5698 }
5699 {
5700 wxSize * resultptr;
5701 resultptr = new wxSize((wxSize &)(result));
5702 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5703 }
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj;
5712 int *arg1 = (int *) 0 ;
5713 int *arg2 = (int *) 0 ;
5714 int *arg3 = (int *) 0 ;
5715 int *arg4 = (int *) 0 ;
5716 int temp1 ;
5717 int res1 = 0 ;
5718 int temp2 ;
5719 int res2 = 0 ;
5720 int temp3 ;
5721 int res3 = 0 ;
5722 int temp4 ;
5723 int res4 = 0 ;
5724 char *kwnames[] = {
5725 NULL
5726 };
5727
5728 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5729 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5730 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5731 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5733 {
5734 if (!wxPyCheckForApp()) SWIG_fail;
5735 PyThreadState* __tstate = wxPyBeginAllowThreads();
5736 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5737
5738 wxPyEndAllowThreads(__tstate);
5739 if (PyErr_Occurred()) SWIG_fail;
5740 }
5741 Py_INCREF(Py_None); resultobj = Py_None;
5742 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5743 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5744 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5745 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5746 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5747 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5748 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5749 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5750 return resultobj;
5751 fail:
5752 return NULL;
5753 }
5754
5755
5756 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5757 PyObject *resultobj;
5758 wxRect result;
5759 char *kwnames[] = {
5760 NULL
5761 };
5762
5763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5764 {
5765 if (!wxPyCheckForApp()) SWIG_fail;
5766 PyThreadState* __tstate = wxPyBeginAllowThreads();
5767 result = wxGetClientDisplayRect();
5768
5769 wxPyEndAllowThreads(__tstate);
5770 if (PyErr_Occurred()) SWIG_fail;
5771 }
5772 {
5773 wxRect * resultptr;
5774 resultptr = new wxRect((wxRect &)(result));
5775 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5776 }
5777 return resultobj;
5778 fail:
5779 return NULL;
5780 }
5781
5782
5783 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5784 PyObject *resultobj;
5785 wxCursor *arg1 = 0 ;
5786 PyObject * obj0 = 0 ;
5787 char *kwnames[] = {
5788 (char *) "cursor", NULL
5789 };
5790
5791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5792 {
5793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5794 if (SWIG_arg_fail(1)) SWIG_fail;
5795 if (arg1 == NULL) {
5796 SWIG_null_ref("wxCursor");
5797 }
5798 if (SWIG_arg_fail(1)) SWIG_fail;
5799 }
5800 {
5801 if (!wxPyCheckForApp()) SWIG_fail;
5802 PyThreadState* __tstate = wxPyBeginAllowThreads();
5803 wxSetCursor(*arg1);
5804
5805 wxPyEndAllowThreads(__tstate);
5806 if (PyErr_Occurred()) SWIG_fail;
5807 }
5808 Py_INCREF(Py_None); resultobj = Py_None;
5809 return resultobj;
5810 fail:
5811 return NULL;
5812 }
5813
5814
5815 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5816 PyObject *resultobj;
5817 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5818 PyObject * obj0 = 0 ;
5819 char *kwnames[] = {
5820 (char *) "cursor", NULL
5821 };
5822
5823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5824 if (obj0) {
5825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5826 if (SWIG_arg_fail(1)) SWIG_fail;
5827 }
5828 {
5829 if (!wxPyCheckForApp()) SWIG_fail;
5830 PyThreadState* __tstate = wxPyBeginAllowThreads();
5831 wxBeginBusyCursor(arg1);
5832
5833 wxPyEndAllowThreads(__tstate);
5834 if (PyErr_Occurred()) SWIG_fail;
5835 }
5836 Py_INCREF(Py_None); resultobj = Py_None;
5837 return resultobj;
5838 fail:
5839 return NULL;
5840 }
5841
5842
5843 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5844 PyObject *resultobj;
5845 wxWindow *result;
5846 char *kwnames[] = {
5847 NULL
5848 };
5849
5850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5851 {
5852 if (!wxPyCheckForApp()) SWIG_fail;
5853 PyThreadState* __tstate = wxPyBeginAllowThreads();
5854 result = (wxWindow *)wxGetActiveWindow();
5855
5856 wxPyEndAllowThreads(__tstate);
5857 if (PyErr_Occurred()) SWIG_fail;
5858 }
5859 {
5860 resultobj = wxPyMake_wxObject(result, 0);
5861 }
5862 return resultobj;
5863 fail:
5864 return NULL;
5865 }
5866
5867
5868 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5869 PyObject *resultobj;
5870 wxPoint *arg1 = 0 ;
5871 wxWindow *result;
5872 wxPoint temp1 ;
5873 PyObject * obj0 = 0 ;
5874 char *kwnames[] = {
5875 (char *) "pt", NULL
5876 };
5877
5878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5879 {
5880 arg1 = &temp1;
5881 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5882 }
5883 {
5884 if (!wxPyCheckForApp()) SWIG_fail;
5885 PyThreadState* __tstate = wxPyBeginAllowThreads();
5886 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5887
5888 wxPyEndAllowThreads(__tstate);
5889 if (PyErr_Occurred()) SWIG_fail;
5890 }
5891 {
5892 resultobj = wxPyMake_wxObject(result, 0);
5893 }
5894 return resultobj;
5895 fail:
5896 return NULL;
5897 }
5898
5899
5900 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxPoint *arg1 = 0 ;
5903 wxWindow *result;
5904 wxPoint temp1 ;
5905 PyObject * obj0 = 0 ;
5906 char *kwnames[] = {
5907 (char *) "pt", NULL
5908 };
5909
5910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5911 {
5912 arg1 = &temp1;
5913 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5914 }
5915 {
5916 if (!wxPyCheckForApp()) SWIG_fail;
5917 PyThreadState* __tstate = wxPyBeginAllowThreads();
5918 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5919
5920 wxPyEndAllowThreads(__tstate);
5921 if (PyErr_Occurred()) SWIG_fail;
5922 }
5923 {
5924 resultobj = wxPyMake_wxObject(result, 0);
5925 }
5926 return resultobj;
5927 fail:
5928 return NULL;
5929 }
5930
5931
5932 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5933 PyObject *resultobj;
5934 wxWindow *arg1 = (wxWindow *) 0 ;
5935 wxWindow *result;
5936 PyObject * obj0 = 0 ;
5937 char *kwnames[] = {
5938 (char *) "win", NULL
5939 };
5940
5941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5943 if (SWIG_arg_fail(1)) SWIG_fail;
5944 {
5945 if (!wxPyCheckForApp()) SWIG_fail;
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 result = (wxWindow *)wxGetTopLevelParent(arg1);
5948
5949 wxPyEndAllowThreads(__tstate);
5950 if (PyErr_Occurred()) SWIG_fail;
5951 }
5952 {
5953 resultobj = wxPyMake_wxObject(result, 0);
5954 }
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj;
5963 wxKeyCode arg1 ;
5964 bool result;
5965 PyObject * obj0 = 0 ;
5966 char *kwnames[] = {
5967 (char *) "key", NULL
5968 };
5969
5970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5971 {
5972 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5973 if (SWIG_arg_fail(1)) SWIG_fail;
5974 }
5975 {
5976 if (!wxPyCheckForApp()) SWIG_fail;
5977 PyThreadState* __tstate = wxPyBeginAllowThreads();
5978 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5979
5980 wxPyEndAllowThreads(__tstate);
5981 if (PyErr_Occurred()) SWIG_fail;
5982 }
5983 {
5984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5985 }
5986 return resultobj;
5987 fail:
5988 return NULL;
5989 }
5990
5991
5992 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5993 PyObject *resultobj;
5994 char *kwnames[] = {
5995 NULL
5996 };
5997
5998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5999 {
6000 if (!wxPyCheckForApp()) SWIG_fail;
6001 PyThreadState* __tstate = wxPyBeginAllowThreads();
6002 wxWakeUpMainThread();
6003
6004 wxPyEndAllowThreads(__tstate);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 Py_INCREF(Py_None); resultobj = Py_None;
6008 return resultobj;
6009 fail:
6010 return NULL;
6011 }
6012
6013
6014 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6015 PyObject *resultobj;
6016 char *kwnames[] = {
6017 NULL
6018 };
6019
6020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6021 {
6022 if (!wxPyCheckForApp()) SWIG_fail;
6023 PyThreadState* __tstate = wxPyBeginAllowThreads();
6024 wxMutexGuiEnter();
6025
6026 wxPyEndAllowThreads(__tstate);
6027 if (PyErr_Occurred()) SWIG_fail;
6028 }
6029 Py_INCREF(Py_None); resultobj = Py_None;
6030 return resultobj;
6031 fail:
6032 return NULL;
6033 }
6034
6035
6036 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6037 PyObject *resultobj;
6038 char *kwnames[] = {
6039 NULL
6040 };
6041
6042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6043 {
6044 if (!wxPyCheckForApp()) SWIG_fail;
6045 PyThreadState* __tstate = wxPyBeginAllowThreads();
6046 wxMutexGuiLeave();
6047
6048 wxPyEndAllowThreads(__tstate);
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 Py_INCREF(Py_None); resultobj = Py_None;
6052 return resultobj;
6053 fail:
6054 return NULL;
6055 }
6056
6057
6058 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6059 PyObject *resultobj;
6060 wxMutexGuiLocker *result;
6061 char *kwnames[] = {
6062 NULL
6063 };
6064
6065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6066 {
6067 if (!wxPyCheckForApp()) SWIG_fail;
6068 PyThreadState* __tstate = wxPyBeginAllowThreads();
6069 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6070
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6082 PyObject *resultobj;
6083 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6084 PyObject * obj0 = 0 ;
6085 char *kwnames[] = {
6086 (char *) "self", NULL
6087 };
6088
6089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6091 if (SWIG_arg_fail(1)) SWIG_fail;
6092 {
6093 PyThreadState* __tstate = wxPyBeginAllowThreads();
6094 delete arg1;
6095
6096 wxPyEndAllowThreads(__tstate);
6097 if (PyErr_Occurred()) SWIG_fail;
6098 }
6099 Py_INCREF(Py_None); resultobj = Py_None;
6100 return resultobj;
6101 fail:
6102 return NULL;
6103 }
6104
6105
6106 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6107 PyObject *obj;
6108 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6109 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6110 Py_INCREF(obj);
6111 return Py_BuildValue((char *)"");
6112 }
6113 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6114 PyObject *resultobj;
6115 bool result;
6116 char *kwnames[] = {
6117 NULL
6118 };
6119
6120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6121 {
6122 PyThreadState* __tstate = wxPyBeginAllowThreads();
6123 result = (bool)wxThread_IsMain();
6124
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 {
6129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6130 }
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj;
6139 wxString *arg1 = 0 ;
6140 wxToolTip *result;
6141 bool temp1 = false ;
6142 PyObject * obj0 = 0 ;
6143 char *kwnames[] = {
6144 (char *) "tip", NULL
6145 };
6146
6147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6148 {
6149 arg1 = wxString_in_helper(obj0);
6150 if (arg1 == NULL) SWIG_fail;
6151 temp1 = true;
6152 }
6153 {
6154 if (!wxPyCheckForApp()) SWIG_fail;
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6157
6158 wxPyEndAllowThreads(__tstate);
6159 if (PyErr_Occurred()) SWIG_fail;
6160 }
6161 {
6162 resultobj = wxPyMake_wxObject(result, 1);
6163 }
6164 {
6165 if (temp1)
6166 delete arg1;
6167 }
6168 return resultobj;
6169 fail:
6170 {
6171 if (temp1)
6172 delete arg1;
6173 }
6174 return NULL;
6175 }
6176
6177
6178 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6179 PyObject *resultobj;
6180 wxToolTip *arg1 = (wxToolTip *) 0 ;
6181 wxString *arg2 = 0 ;
6182 bool temp2 = false ;
6183 PyObject * obj0 = 0 ;
6184 PyObject * obj1 = 0 ;
6185 char *kwnames[] = {
6186 (char *) "self",(char *) "tip", NULL
6187 };
6188
6189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6191 if (SWIG_arg_fail(1)) SWIG_fail;
6192 {
6193 arg2 = wxString_in_helper(obj1);
6194 if (arg2 == NULL) SWIG_fail;
6195 temp2 = true;
6196 }
6197 {
6198 PyThreadState* __tstate = wxPyBeginAllowThreads();
6199 (arg1)->SetTip((wxString const &)*arg2);
6200
6201 wxPyEndAllowThreads(__tstate);
6202 if (PyErr_Occurred()) SWIG_fail;
6203 }
6204 Py_INCREF(Py_None); resultobj = Py_None;
6205 {
6206 if (temp2)
6207 delete arg2;
6208 }
6209 return resultobj;
6210 fail:
6211 {
6212 if (temp2)
6213 delete arg2;
6214 }
6215 return NULL;
6216 }
6217
6218
6219 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6220 PyObject *resultobj;
6221 wxToolTip *arg1 = (wxToolTip *) 0 ;
6222 wxString result;
6223 PyObject * obj0 = 0 ;
6224 char *kwnames[] = {
6225 (char *) "self", NULL
6226 };
6227
6228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6230 if (SWIG_arg_fail(1)) SWIG_fail;
6231 {
6232 PyThreadState* __tstate = wxPyBeginAllowThreads();
6233 result = (arg1)->GetTip();
6234
6235 wxPyEndAllowThreads(__tstate);
6236 if (PyErr_Occurred()) SWIG_fail;
6237 }
6238 {
6239 #if wxUSE_UNICODE
6240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6241 #else
6242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6243 #endif
6244 }
6245 return resultobj;
6246 fail:
6247 return NULL;
6248 }
6249
6250
6251 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6252 PyObject *resultobj;
6253 wxToolTip *arg1 = (wxToolTip *) 0 ;
6254 wxWindow *result;
6255 PyObject * obj0 = 0 ;
6256 char *kwnames[] = {
6257 (char *) "self", NULL
6258 };
6259
6260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6262 if (SWIG_arg_fail(1)) SWIG_fail;
6263 {
6264 PyThreadState* __tstate = wxPyBeginAllowThreads();
6265 result = (wxWindow *)(arg1)->GetWindow();
6266
6267 wxPyEndAllowThreads(__tstate);
6268 if (PyErr_Occurred()) SWIG_fail;
6269 }
6270 {
6271 resultobj = wxPyMake_wxObject(result, 0);
6272 }
6273 return resultobj;
6274 fail:
6275 return NULL;
6276 }
6277
6278
6279 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6280 PyObject *resultobj;
6281 bool arg1 ;
6282 PyObject * obj0 = 0 ;
6283 char *kwnames[] = {
6284 (char *) "flag", NULL
6285 };
6286
6287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6288 {
6289 arg1 = (bool)(SWIG_As_bool(obj0));
6290 if (SWIG_arg_fail(1)) SWIG_fail;
6291 }
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 wxToolTip::Enable(arg1);
6295
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 Py_INCREF(Py_None); resultobj = Py_None;
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj;
6308 long arg1 ;
6309 PyObject * obj0 = 0 ;
6310 char *kwnames[] = {
6311 (char *) "milliseconds", NULL
6312 };
6313
6314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6315 {
6316 arg1 = (long)(SWIG_As_long(obj0));
6317 if (SWIG_arg_fail(1)) SWIG_fail;
6318 }
6319 {
6320 PyThreadState* __tstate = wxPyBeginAllowThreads();
6321 wxToolTip::SetDelay(arg1);
6322
6323 wxPyEndAllowThreads(__tstate);
6324 if (PyErr_Occurred()) SWIG_fail;
6325 }
6326 Py_INCREF(Py_None); resultobj = Py_None;
6327 return resultobj;
6328 fail:
6329 return NULL;
6330 }
6331
6332
6333 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6334 PyObject *obj;
6335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6336 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6337 Py_INCREF(obj);
6338 return Py_BuildValue((char *)"");
6339 }
6340 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6341 PyObject *resultobj;
6342 wxWindow *arg1 = (wxWindow *) 0 ;
6343 wxSize *arg2 = 0 ;
6344 wxCaret *result;
6345 wxSize temp2 ;
6346 PyObject * obj0 = 0 ;
6347 PyObject * obj1 = 0 ;
6348 char *kwnames[] = {
6349 (char *) "window",(char *) "size", NULL
6350 };
6351
6352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6354 if (SWIG_arg_fail(1)) SWIG_fail;
6355 {
6356 arg2 = &temp2;
6357 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6358 }
6359 {
6360 if (!wxPyCheckForApp()) SWIG_fail;
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6363
6364 wxPyEndAllowThreads(__tstate);
6365 if (PyErr_Occurred()) SWIG_fail;
6366 }
6367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6368 return resultobj;
6369 fail:
6370 return NULL;
6371 }
6372
6373
6374 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6375 PyObject *resultobj;
6376 wxCaret *arg1 = (wxCaret *) 0 ;
6377 PyObject * obj0 = 0 ;
6378 char *kwnames[] = {
6379 (char *) "self", NULL
6380 };
6381
6382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6384 if (SWIG_arg_fail(1)) SWIG_fail;
6385 {
6386 PyThreadState* __tstate = wxPyBeginAllowThreads();
6387 wxCaret_Destroy(arg1);
6388
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 Py_INCREF(Py_None); resultobj = Py_None;
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj;
6401 wxCaret *arg1 = (wxCaret *) 0 ;
6402 bool result;
6403 PyObject * obj0 = 0 ;
6404 char *kwnames[] = {
6405 (char *) "self", NULL
6406 };
6407
6408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6410 if (SWIG_arg_fail(1)) SWIG_fail;
6411 {
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 result = (bool)(arg1)->IsOk();
6414
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 {
6419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6420 }
6421 return resultobj;
6422 fail:
6423 return NULL;
6424 }
6425
6426
6427 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6428 PyObject *resultobj;
6429 wxCaret *arg1 = (wxCaret *) 0 ;
6430 bool result;
6431 PyObject * obj0 = 0 ;
6432 char *kwnames[] = {
6433 (char *) "self", NULL
6434 };
6435
6436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6438 if (SWIG_arg_fail(1)) SWIG_fail;
6439 {
6440 PyThreadState* __tstate = wxPyBeginAllowThreads();
6441 result = (bool)(arg1)->IsVisible();
6442
6443 wxPyEndAllowThreads(__tstate);
6444 if (PyErr_Occurred()) SWIG_fail;
6445 }
6446 {
6447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6448 }
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6456 PyObject *resultobj;
6457 wxCaret *arg1 = (wxCaret *) 0 ;
6458 wxPoint result;
6459 PyObject * obj0 = 0 ;
6460 char *kwnames[] = {
6461 (char *) "self", NULL
6462 };
6463
6464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6466 if (SWIG_arg_fail(1)) SWIG_fail;
6467 {
6468 PyThreadState* __tstate = wxPyBeginAllowThreads();
6469 result = (arg1)->GetPosition();
6470
6471 wxPyEndAllowThreads(__tstate);
6472 if (PyErr_Occurred()) SWIG_fail;
6473 }
6474 {
6475 wxPoint * resultptr;
6476 resultptr = new wxPoint((wxPoint &)(result));
6477 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6478 }
6479 return resultobj;
6480 fail:
6481 return NULL;
6482 }
6483
6484
6485 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6486 PyObject *resultobj;
6487 wxCaret *arg1 = (wxCaret *) 0 ;
6488 int *arg2 = (int *) 0 ;
6489 int *arg3 = (int *) 0 ;
6490 int temp2 ;
6491 int res2 = 0 ;
6492 int temp3 ;
6493 int res3 = 0 ;
6494 PyObject * obj0 = 0 ;
6495 char *kwnames[] = {
6496 (char *) "self", NULL
6497 };
6498
6499 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6500 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6503 if (SWIG_arg_fail(1)) SWIG_fail;
6504 {
6505 PyThreadState* __tstate = wxPyBeginAllowThreads();
6506 (arg1)->GetPosition(arg2,arg3);
6507
6508 wxPyEndAllowThreads(__tstate);
6509 if (PyErr_Occurred()) SWIG_fail;
6510 }
6511 Py_INCREF(Py_None); resultobj = Py_None;
6512 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6513 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6514 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6515 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6516 return resultobj;
6517 fail:
6518 return NULL;
6519 }
6520
6521
6522 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6523 PyObject *resultobj;
6524 wxCaret *arg1 = (wxCaret *) 0 ;
6525 wxSize result;
6526 PyObject * obj0 = 0 ;
6527 char *kwnames[] = {
6528 (char *) "self", NULL
6529 };
6530
6531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6533 if (SWIG_arg_fail(1)) SWIG_fail;
6534 {
6535 PyThreadState* __tstate = wxPyBeginAllowThreads();
6536 result = (arg1)->GetSize();
6537
6538 wxPyEndAllowThreads(__tstate);
6539 if (PyErr_Occurred()) SWIG_fail;
6540 }
6541 {
6542 wxSize * resultptr;
6543 resultptr = new wxSize((wxSize &)(result));
6544 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6545 }
6546 return resultobj;
6547 fail:
6548 return NULL;
6549 }
6550
6551
6552 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6553 PyObject *resultobj;
6554 wxCaret *arg1 = (wxCaret *) 0 ;
6555 int *arg2 = (int *) 0 ;
6556 int *arg3 = (int *) 0 ;
6557 int temp2 ;
6558 int res2 = 0 ;
6559 int temp3 ;
6560 int res3 = 0 ;
6561 PyObject * obj0 = 0 ;
6562 char *kwnames[] = {
6563 (char *) "self", NULL
6564 };
6565
6566 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6567 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6570 if (SWIG_arg_fail(1)) SWIG_fail;
6571 {
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 (arg1)->GetSize(arg2,arg3);
6574
6575 wxPyEndAllowThreads(__tstate);
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 Py_INCREF(Py_None); resultobj = Py_None;
6579 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6580 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6581 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6582 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6583 return resultobj;
6584 fail:
6585 return NULL;
6586 }
6587
6588
6589 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6590 PyObject *resultobj;
6591 wxCaret *arg1 = (wxCaret *) 0 ;
6592 wxWindow *result;
6593 PyObject * obj0 = 0 ;
6594 char *kwnames[] = {
6595 (char *) "self", NULL
6596 };
6597
6598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6600 if (SWIG_arg_fail(1)) SWIG_fail;
6601 {
6602 PyThreadState* __tstate = wxPyBeginAllowThreads();
6603 result = (wxWindow *)(arg1)->GetWindow();
6604
6605 wxPyEndAllowThreads(__tstate);
6606 if (PyErr_Occurred()) SWIG_fail;
6607 }
6608 {
6609 resultobj = wxPyMake_wxObject(result, 0);
6610 }
6611 return resultobj;
6612 fail:
6613 return NULL;
6614 }
6615
6616
6617 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6618 PyObject *resultobj;
6619 wxCaret *arg1 = (wxCaret *) 0 ;
6620 int arg2 ;
6621 int arg3 ;
6622 PyObject * obj0 = 0 ;
6623 PyObject * obj1 = 0 ;
6624 PyObject * obj2 = 0 ;
6625 char *kwnames[] = {
6626 (char *) "self",(char *) "x",(char *) "y", NULL
6627 };
6628
6629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6631 if (SWIG_arg_fail(1)) SWIG_fail;
6632 {
6633 arg2 = (int)(SWIG_As_int(obj1));
6634 if (SWIG_arg_fail(2)) SWIG_fail;
6635 }
6636 {
6637 arg3 = (int)(SWIG_As_int(obj2));
6638 if (SWIG_arg_fail(3)) SWIG_fail;
6639 }
6640 {
6641 PyThreadState* __tstate = wxPyBeginAllowThreads();
6642 (arg1)->Move(arg2,arg3);
6643
6644 wxPyEndAllowThreads(__tstate);
6645 if (PyErr_Occurred()) SWIG_fail;
6646 }
6647 Py_INCREF(Py_None); resultobj = Py_None;
6648 return resultobj;
6649 fail:
6650 return NULL;
6651 }
6652
6653
6654 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6655 PyObject *resultobj;
6656 wxCaret *arg1 = (wxCaret *) 0 ;
6657 wxPoint *arg2 = 0 ;
6658 wxPoint temp2 ;
6659 PyObject * obj0 = 0 ;
6660 PyObject * obj1 = 0 ;
6661 char *kwnames[] = {
6662 (char *) "self",(char *) "pt", NULL
6663 };
6664
6665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6667 if (SWIG_arg_fail(1)) SWIG_fail;
6668 {
6669 arg2 = &temp2;
6670 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6671 }
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 (arg1)->Move((wxPoint const &)*arg2);
6675
6676 wxPyEndAllowThreads(__tstate);
6677 if (PyErr_Occurred()) SWIG_fail;
6678 }
6679 Py_INCREF(Py_None); resultobj = Py_None;
6680 return resultobj;
6681 fail:
6682 return NULL;
6683 }
6684
6685
6686 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6687 PyObject *resultobj;
6688 wxCaret *arg1 = (wxCaret *) 0 ;
6689 int arg2 ;
6690 int arg3 ;
6691 PyObject * obj0 = 0 ;
6692 PyObject * obj1 = 0 ;
6693 PyObject * obj2 = 0 ;
6694 char *kwnames[] = {
6695 (char *) "self",(char *) "width",(char *) "height", NULL
6696 };
6697
6698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6700 if (SWIG_arg_fail(1)) SWIG_fail;
6701 {
6702 arg2 = (int)(SWIG_As_int(obj1));
6703 if (SWIG_arg_fail(2)) SWIG_fail;
6704 }
6705 {
6706 arg3 = (int)(SWIG_As_int(obj2));
6707 if (SWIG_arg_fail(3)) SWIG_fail;
6708 }
6709 {
6710 PyThreadState* __tstate = wxPyBeginAllowThreads();
6711 (arg1)->SetSize(arg2,arg3);
6712
6713 wxPyEndAllowThreads(__tstate);
6714 if (PyErr_Occurred()) SWIG_fail;
6715 }
6716 Py_INCREF(Py_None); resultobj = Py_None;
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 wxCaret *arg1 = (wxCaret *) 0 ;
6726 wxSize *arg2 = 0 ;
6727 wxSize temp2 ;
6728 PyObject * obj0 = 0 ;
6729 PyObject * obj1 = 0 ;
6730 char *kwnames[] = {
6731 (char *) "self",(char *) "size", NULL
6732 };
6733
6734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6736 if (SWIG_arg_fail(1)) SWIG_fail;
6737 {
6738 arg2 = &temp2;
6739 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6740 }
6741 {
6742 PyThreadState* __tstate = wxPyBeginAllowThreads();
6743 (arg1)->SetSize((wxSize const &)*arg2);
6744
6745 wxPyEndAllowThreads(__tstate);
6746 if (PyErr_Occurred()) SWIG_fail;
6747 }
6748 Py_INCREF(Py_None); resultobj = Py_None;
6749 return resultobj;
6750 fail:
6751 return NULL;
6752 }
6753
6754
6755 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6756 PyObject *resultobj;
6757 wxCaret *arg1 = (wxCaret *) 0 ;
6758 int arg2 = (int) true ;
6759 PyObject * obj0 = 0 ;
6760 PyObject * obj1 = 0 ;
6761 char *kwnames[] = {
6762 (char *) "self",(char *) "show", NULL
6763 };
6764
6765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6767 if (SWIG_arg_fail(1)) SWIG_fail;
6768 if (obj1) {
6769 {
6770 arg2 = (int)(SWIG_As_int(obj1));
6771 if (SWIG_arg_fail(2)) SWIG_fail;
6772 }
6773 }
6774 {
6775 PyThreadState* __tstate = wxPyBeginAllowThreads();
6776 (arg1)->Show(arg2);
6777
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 Py_INCREF(Py_None); resultobj = Py_None;
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6789 PyObject *resultobj;
6790 wxCaret *arg1 = (wxCaret *) 0 ;
6791 PyObject * obj0 = 0 ;
6792 char *kwnames[] = {
6793 (char *) "self", NULL
6794 };
6795
6796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6798 if (SWIG_arg_fail(1)) SWIG_fail;
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 (arg1)->Hide();
6802
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 Py_INCREF(Py_None); resultobj = Py_None;
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6814 PyObject *resultobj;
6815 int result;
6816 char *kwnames[] = {
6817 NULL
6818 };
6819
6820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6821 {
6822 PyThreadState* __tstate = wxPyBeginAllowThreads();
6823 result = (int)wxCaret::GetBlinkTime();
6824
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 {
6829 resultobj = SWIG_From_int((int)(result));
6830 }
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6838 PyObject *resultobj;
6839 int arg1 ;
6840 PyObject * obj0 = 0 ;
6841 char *kwnames[] = {
6842 (char *) "milliseconds", NULL
6843 };
6844
6845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6846 {
6847 arg1 = (int)(SWIG_As_int(obj0));
6848 if (SWIG_arg_fail(1)) SWIG_fail;
6849 }
6850 {
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 wxCaret::SetBlinkTime(arg1);
6853
6854 wxPyEndAllowThreads(__tstate);
6855 if (PyErr_Occurred()) SWIG_fail;
6856 }
6857 Py_INCREF(Py_None); resultobj = Py_None;
6858 return resultobj;
6859 fail:
6860 return NULL;
6861 }
6862
6863
6864 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6865 PyObject *obj;
6866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6867 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6868 Py_INCREF(obj);
6869 return Py_BuildValue((char *)"");
6870 }
6871 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6872 PyObject *resultobj;
6873 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6874 wxBusyCursor *result;
6875 PyObject * obj0 = 0 ;
6876 char *kwnames[] = {
6877 (char *) "cursor", NULL
6878 };
6879
6880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6881 if (obj0) {
6882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6883 if (SWIG_arg_fail(1)) SWIG_fail;
6884 }
6885 {
6886 if (!wxPyCheckForApp()) SWIG_fail;
6887 PyThreadState* __tstate = wxPyBeginAllowThreads();
6888 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6889
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6901 PyObject *resultobj;
6902 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6903 PyObject * obj0 = 0 ;
6904 char *kwnames[] = {
6905 (char *) "self", NULL
6906 };
6907
6908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6910 if (SWIG_arg_fail(1)) SWIG_fail;
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 delete arg1;
6914
6915 wxPyEndAllowThreads(__tstate);
6916 if (PyErr_Occurred()) SWIG_fail;
6917 }
6918 Py_INCREF(Py_None); resultobj = Py_None;
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6926 PyObject *obj;
6927 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6928 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6929 Py_INCREF(obj);
6930 return Py_BuildValue((char *)"");
6931 }
6932 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6933 PyObject *resultobj;
6934 wxWindow *arg1 = (wxWindow *) NULL ;
6935 wxWindowDisabler *result;
6936 PyObject * obj0 = 0 ;
6937 char *kwnames[] = {
6938 (char *) "winToSkip", NULL
6939 };
6940
6941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6942 if (obj0) {
6943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6944 if (SWIG_arg_fail(1)) SWIG_fail;
6945 }
6946 {
6947 if (!wxPyCheckForApp()) SWIG_fail;
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6950
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6955 return resultobj;
6956 fail:
6957 return NULL;
6958 }
6959
6960
6961 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6962 PyObject *resultobj;
6963 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6964 PyObject * obj0 = 0 ;
6965 char *kwnames[] = {
6966 (char *) "self", NULL
6967 };
6968
6969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6971 if (SWIG_arg_fail(1)) SWIG_fail;
6972 {
6973 PyThreadState* __tstate = wxPyBeginAllowThreads();
6974 delete arg1;
6975
6976 wxPyEndAllowThreads(__tstate);
6977 if (PyErr_Occurred()) SWIG_fail;
6978 }
6979 Py_INCREF(Py_None); resultobj = Py_None;
6980 return resultobj;
6981 fail:
6982 return NULL;
6983 }
6984
6985
6986 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6987 PyObject *obj;
6988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6989 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6990 Py_INCREF(obj);
6991 return Py_BuildValue((char *)"");
6992 }
6993 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6994 PyObject *resultobj;
6995 wxString *arg1 = 0 ;
6996 wxBusyInfo *result;
6997 bool temp1 = false ;
6998 PyObject * obj0 = 0 ;
6999 char *kwnames[] = {
7000 (char *) "message", NULL
7001 };
7002
7003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7004 {
7005 arg1 = wxString_in_helper(obj0);
7006 if (arg1 == NULL) SWIG_fail;
7007 temp1 = true;
7008 }
7009 {
7010 if (!wxPyCheckForApp()) SWIG_fail;
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7013
7014 wxPyEndAllowThreads(__tstate);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7018 {
7019 if (temp1)
7020 delete arg1;
7021 }
7022 return resultobj;
7023 fail:
7024 {
7025 if (temp1)
7026 delete arg1;
7027 }
7028 return NULL;
7029 }
7030
7031
7032 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7033 PyObject *resultobj;
7034 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7035 PyObject * obj0 = 0 ;
7036 char *kwnames[] = {
7037 (char *) "self", NULL
7038 };
7039
7040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7042 if (SWIG_arg_fail(1)) SWIG_fail;
7043 {
7044 PyThreadState* __tstate = wxPyBeginAllowThreads();
7045 delete arg1;
7046
7047 wxPyEndAllowThreads(__tstate);
7048 if (PyErr_Occurred()) SWIG_fail;
7049 }
7050 Py_INCREF(Py_None); resultobj = Py_None;
7051 return resultobj;
7052 fail:
7053 return NULL;
7054 }
7055
7056
7057 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7058 PyObject *obj;
7059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7060 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7061 Py_INCREF(obj);
7062 return Py_BuildValue((char *)"");
7063 }
7064 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj;
7066 wxStopWatch *result;
7067 char *kwnames[] = {
7068 NULL
7069 };
7070
7071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7072 {
7073 PyThreadState* __tstate = wxPyBeginAllowThreads();
7074 result = (wxStopWatch *)new wxStopWatch();
7075
7076 wxPyEndAllowThreads(__tstate);
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7080 return resultobj;
7081 fail:
7082 return NULL;
7083 }
7084
7085
7086 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7087 PyObject *resultobj;
7088 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7089 long arg2 = (long) 0 ;
7090 PyObject * obj0 = 0 ;
7091 PyObject * obj1 = 0 ;
7092 char *kwnames[] = {
7093 (char *) "self",(char *) "t0", NULL
7094 };
7095
7096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7098 if (SWIG_arg_fail(1)) SWIG_fail;
7099 if (obj1) {
7100 {
7101 arg2 = (long)(SWIG_As_long(obj1));
7102 if (SWIG_arg_fail(2)) SWIG_fail;
7103 }
7104 }
7105 {
7106 PyThreadState* __tstate = wxPyBeginAllowThreads();
7107 (arg1)->Start(arg2);
7108
7109 wxPyEndAllowThreads(__tstate);
7110 if (PyErr_Occurred()) SWIG_fail;
7111 }
7112 Py_INCREF(Py_None); resultobj = Py_None;
7113 return resultobj;
7114 fail:
7115 return NULL;
7116 }
7117
7118
7119 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7120 PyObject *resultobj;
7121 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7122 PyObject * obj0 = 0 ;
7123 char *kwnames[] = {
7124 (char *) "self", NULL
7125 };
7126
7127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7129 if (SWIG_arg_fail(1)) SWIG_fail;
7130 {
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 (arg1)->Pause();
7133
7134 wxPyEndAllowThreads(__tstate);
7135 if (PyErr_Occurred()) SWIG_fail;
7136 }
7137 Py_INCREF(Py_None); resultobj = Py_None;
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj;
7146 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7147 PyObject * obj0 = 0 ;
7148 char *kwnames[] = {
7149 (char *) "self", NULL
7150 };
7151
7152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7154 if (SWIG_arg_fail(1)) SWIG_fail;
7155 {
7156 PyThreadState* __tstate = wxPyBeginAllowThreads();
7157 (arg1)->Resume();
7158
7159 wxPyEndAllowThreads(__tstate);
7160 if (PyErr_Occurred()) SWIG_fail;
7161 }
7162 Py_INCREF(Py_None); resultobj = Py_None;
7163 return resultobj;
7164 fail:
7165 return NULL;
7166 }
7167
7168
7169 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7170 PyObject *resultobj;
7171 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7172 long result;
7173 PyObject * obj0 = 0 ;
7174 char *kwnames[] = {
7175 (char *) "self", NULL
7176 };
7177
7178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7180 if (SWIG_arg_fail(1)) SWIG_fail;
7181 {
7182 PyThreadState* __tstate = wxPyBeginAllowThreads();
7183 result = (long)((wxStopWatch const *)arg1)->Time();
7184
7185 wxPyEndAllowThreads(__tstate);
7186 if (PyErr_Occurred()) SWIG_fail;
7187 }
7188 {
7189 resultobj = SWIG_From_long((long)(result));
7190 }
7191 return resultobj;
7192 fail:
7193 return NULL;
7194 }
7195
7196
7197 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7198 PyObject *obj;
7199 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7200 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7201 Py_INCREF(obj);
7202 return Py_BuildValue((char *)"");
7203 }
7204 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7205 PyObject *resultobj;
7206 int arg1 = (int) 9 ;
7207 int arg2 = (int) wxID_FILE1 ;
7208 wxFileHistory *result;
7209 PyObject * obj0 = 0 ;
7210 PyObject * obj1 = 0 ;
7211 char *kwnames[] = {
7212 (char *) "maxFiles",(char *) "idBase", NULL
7213 };
7214
7215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7216 if (obj0) {
7217 {
7218 arg1 = (int)(SWIG_As_int(obj0));
7219 if (SWIG_arg_fail(1)) SWIG_fail;
7220 }
7221 }
7222 if (obj1) {
7223 {
7224 arg2 = (int)(SWIG_As_int(obj1));
7225 if (SWIG_arg_fail(2)) SWIG_fail;
7226 }
7227 }
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7231
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj;
7244 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7245 PyObject * obj0 = 0 ;
7246 char *kwnames[] = {
7247 (char *) "self", NULL
7248 };
7249
7250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7252 if (SWIG_arg_fail(1)) SWIG_fail;
7253 {
7254 PyThreadState* __tstate = wxPyBeginAllowThreads();
7255 delete arg1;
7256
7257 wxPyEndAllowThreads(__tstate);
7258 if (PyErr_Occurred()) SWIG_fail;
7259 }
7260 Py_INCREF(Py_None); resultobj = Py_None;
7261 return resultobj;
7262 fail:
7263 return NULL;
7264 }
7265
7266
7267 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7268 PyObject *resultobj;
7269 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7270 wxString *arg2 = 0 ;
7271 bool temp2 = false ;
7272 PyObject * obj0 = 0 ;
7273 PyObject * obj1 = 0 ;
7274 char *kwnames[] = {
7275 (char *) "self",(char *) "file", NULL
7276 };
7277
7278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7280 if (SWIG_arg_fail(1)) SWIG_fail;
7281 {
7282 arg2 = wxString_in_helper(obj1);
7283 if (arg2 == NULL) SWIG_fail;
7284 temp2 = true;
7285 }
7286 {
7287 PyThreadState* __tstate = wxPyBeginAllowThreads();
7288 (arg1)->AddFileToHistory((wxString const &)*arg2);
7289
7290 wxPyEndAllowThreads(__tstate);
7291 if (PyErr_Occurred()) SWIG_fail;
7292 }
7293 Py_INCREF(Py_None); resultobj = Py_None;
7294 {
7295 if (temp2)
7296 delete arg2;
7297 }
7298 return resultobj;
7299 fail:
7300 {
7301 if (temp2)
7302 delete arg2;
7303 }
7304 return NULL;
7305 }
7306
7307
7308 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7309 PyObject *resultobj;
7310 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7311 int arg2 ;
7312 PyObject * obj0 = 0 ;
7313 PyObject * obj1 = 0 ;
7314 char *kwnames[] = {
7315 (char *) "self",(char *) "i", NULL
7316 };
7317
7318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7320 if (SWIG_arg_fail(1)) SWIG_fail;
7321 {
7322 arg2 = (int)(SWIG_As_int(obj1));
7323 if (SWIG_arg_fail(2)) SWIG_fail;
7324 }
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 (arg1)->RemoveFileFromHistory(arg2);
7328
7329 wxPyEndAllowThreads(__tstate);
7330 if (PyErr_Occurred()) SWIG_fail;
7331 }
7332 Py_INCREF(Py_None); resultobj = Py_None;
7333 return resultobj;
7334 fail:
7335 return NULL;
7336 }
7337
7338
7339 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7340 PyObject *resultobj;
7341 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7342 int result;
7343 PyObject * obj0 = 0 ;
7344 char *kwnames[] = {
7345 (char *) "self", NULL
7346 };
7347
7348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7350 if (SWIG_arg_fail(1)) SWIG_fail;
7351 {
7352 PyThreadState* __tstate = wxPyBeginAllowThreads();
7353 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7354
7355 wxPyEndAllowThreads(__tstate);
7356 if (PyErr_Occurred()) SWIG_fail;
7357 }
7358 {
7359 resultobj = SWIG_From_int((int)(result));
7360 }
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj;
7369 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7370 wxMenu *arg2 = (wxMenu *) 0 ;
7371 PyObject * obj0 = 0 ;
7372 PyObject * obj1 = 0 ;
7373 char *kwnames[] = {
7374 (char *) "self",(char *) "menu", NULL
7375 };
7376
7377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7379 if (SWIG_arg_fail(1)) SWIG_fail;
7380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7381 if (SWIG_arg_fail(2)) SWIG_fail;
7382 {
7383 PyThreadState* __tstate = wxPyBeginAllowThreads();
7384 (arg1)->UseMenu(arg2);
7385
7386 wxPyEndAllowThreads(__tstate);
7387 if (PyErr_Occurred()) SWIG_fail;
7388 }
7389 Py_INCREF(Py_None); resultobj = Py_None;
7390 return resultobj;
7391 fail:
7392 return NULL;
7393 }
7394
7395
7396 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7397 PyObject *resultobj;
7398 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7399 wxMenu *arg2 = (wxMenu *) 0 ;
7400 PyObject * obj0 = 0 ;
7401 PyObject * obj1 = 0 ;
7402 char *kwnames[] = {
7403 (char *) "self",(char *) "menu", NULL
7404 };
7405
7406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7408 if (SWIG_arg_fail(1)) SWIG_fail;
7409 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7410 if (SWIG_arg_fail(2)) SWIG_fail;
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 (arg1)->RemoveMenu(arg2);
7414
7415 wxPyEndAllowThreads(__tstate);
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 Py_INCREF(Py_None); resultobj = Py_None;
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj;
7427 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7428 wxConfigBase *arg2 = 0 ;
7429 PyObject * obj0 = 0 ;
7430 PyObject * obj1 = 0 ;
7431 char *kwnames[] = {
7432 (char *) "self",(char *) "config", NULL
7433 };
7434
7435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7437 if (SWIG_arg_fail(1)) SWIG_fail;
7438 {
7439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7440 if (SWIG_arg_fail(2)) SWIG_fail;
7441 if (arg2 == NULL) {
7442 SWIG_null_ref("wxConfigBase");
7443 }
7444 if (SWIG_arg_fail(2)) SWIG_fail;
7445 }
7446 {
7447 PyThreadState* __tstate = wxPyBeginAllowThreads();
7448 (arg1)->Load(*arg2);
7449
7450 wxPyEndAllowThreads(__tstate);
7451 if (PyErr_Occurred()) SWIG_fail;
7452 }
7453 Py_INCREF(Py_None); resultobj = Py_None;
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7461 PyObject *resultobj;
7462 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7463 wxConfigBase *arg2 = 0 ;
7464 PyObject * obj0 = 0 ;
7465 PyObject * obj1 = 0 ;
7466 char *kwnames[] = {
7467 (char *) "self",(char *) "config", NULL
7468 };
7469
7470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7472 if (SWIG_arg_fail(1)) SWIG_fail;
7473 {
7474 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7475 if (SWIG_arg_fail(2)) SWIG_fail;
7476 if (arg2 == NULL) {
7477 SWIG_null_ref("wxConfigBase");
7478 }
7479 if (SWIG_arg_fail(2)) SWIG_fail;
7480 }
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 (arg1)->Save(*arg2);
7484
7485 wxPyEndAllowThreads(__tstate);
7486 if (PyErr_Occurred()) SWIG_fail;
7487 }
7488 Py_INCREF(Py_None); resultobj = Py_None;
7489 return resultobj;
7490 fail:
7491 return NULL;
7492 }
7493
7494
7495 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7496 PyObject *resultobj;
7497 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7498 PyObject * obj0 = 0 ;
7499 char *kwnames[] = {
7500 (char *) "self", NULL
7501 };
7502
7503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7505 if (SWIG_arg_fail(1)) SWIG_fail;
7506 {
7507 PyThreadState* __tstate = wxPyBeginAllowThreads();
7508 (arg1)->AddFilesToMenu();
7509
7510 wxPyEndAllowThreads(__tstate);
7511 if (PyErr_Occurred()) SWIG_fail;
7512 }
7513 Py_INCREF(Py_None); resultobj = Py_None;
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7521 PyObject *resultobj;
7522 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7523 wxMenu *arg2 = (wxMenu *) 0 ;
7524 PyObject * obj0 = 0 ;
7525 PyObject * obj1 = 0 ;
7526 char *kwnames[] = {
7527 (char *) "self",(char *) "menu", NULL
7528 };
7529
7530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7532 if (SWIG_arg_fail(1)) SWIG_fail;
7533 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7534 if (SWIG_arg_fail(2)) SWIG_fail;
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 (arg1)->AddFilesToMenu(arg2);
7538
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 Py_INCREF(Py_None); resultobj = Py_None;
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj;
7551 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7552 int arg2 ;
7553 wxString result;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 char *kwnames[] = {
7557 (char *) "self",(char *) "i", NULL
7558 };
7559
7560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7562 if (SWIG_arg_fail(1)) SWIG_fail;
7563 {
7564 arg2 = (int)(SWIG_As_int(obj1));
7565 if (SWIG_arg_fail(2)) SWIG_fail;
7566 }
7567 {
7568 PyThreadState* __tstate = wxPyBeginAllowThreads();
7569 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7570
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 #if wxUSE_UNICODE
7576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7577 #else
7578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7579 #endif
7580 }
7581 return resultobj;
7582 fail:
7583 return NULL;
7584 }
7585
7586
7587 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7588 PyObject *resultobj;
7589 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7590 int result;
7591 PyObject * obj0 = 0 ;
7592 char *kwnames[] = {
7593 (char *) "self", NULL
7594 };
7595
7596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7598 if (SWIG_arg_fail(1)) SWIG_fail;
7599 {
7600 PyThreadState* __tstate = wxPyBeginAllowThreads();
7601 result = (int)((wxFileHistory const *)arg1)->GetCount();
7602
7603 wxPyEndAllowThreads(__tstate);
7604 if (PyErr_Occurred()) SWIG_fail;
7605 }
7606 {
7607 resultobj = SWIG_From_int((int)(result));
7608 }
7609 return resultobj;
7610 fail:
7611 return NULL;
7612 }
7613
7614
7615 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7616 PyObject *obj;
7617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7618 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7619 Py_INCREF(obj);
7620 return Py_BuildValue((char *)"");
7621 }
7622 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj;
7624 wxString *arg1 = 0 ;
7625 wxString const &arg2_defvalue = wxPyEmptyString ;
7626 wxString *arg2 = (wxString *) &arg2_defvalue ;
7627 wxSingleInstanceChecker *result;
7628 bool temp1 = false ;
7629 bool temp2 = false ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char *kwnames[] = {
7633 (char *) "name",(char *) "path", NULL
7634 };
7635
7636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7637 {
7638 arg1 = wxString_in_helper(obj0);
7639 if (arg1 == NULL) SWIG_fail;
7640 temp1 = true;
7641 }
7642 if (obj1) {
7643 {
7644 arg2 = wxString_in_helper(obj1);
7645 if (arg2 == NULL) SWIG_fail;
7646 temp2 = true;
7647 }
7648 }
7649 {
7650 PyThreadState* __tstate = wxPyBeginAllowThreads();
7651 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7652
7653 wxPyEndAllowThreads(__tstate);
7654 if (PyErr_Occurred()) SWIG_fail;
7655 }
7656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7657 {
7658 if (temp1)
7659 delete arg1;
7660 }
7661 {
7662 if (temp2)
7663 delete arg2;
7664 }
7665 return resultobj;
7666 fail:
7667 {
7668 if (temp1)
7669 delete arg1;
7670 }
7671 {
7672 if (temp2)
7673 delete arg2;
7674 }
7675 return NULL;
7676 }
7677
7678
7679 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7680 PyObject *resultobj;
7681 wxSingleInstanceChecker *result;
7682 char *kwnames[] = {
7683 NULL
7684 };
7685
7686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7687 {
7688 PyThreadState* __tstate = wxPyBeginAllowThreads();
7689 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7690
7691 wxPyEndAllowThreads(__tstate);
7692 if (PyErr_Occurred()) SWIG_fail;
7693 }
7694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7695 return resultobj;
7696 fail:
7697 return NULL;
7698 }
7699
7700
7701 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7702 PyObject *resultobj;
7703 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7704 PyObject * obj0 = 0 ;
7705 char *kwnames[] = {
7706 (char *) "self", NULL
7707 };
7708
7709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7711 if (SWIG_arg_fail(1)) SWIG_fail;
7712 {
7713 PyThreadState* __tstate = wxPyBeginAllowThreads();
7714 delete arg1;
7715
7716 wxPyEndAllowThreads(__tstate);
7717 if (PyErr_Occurred()) SWIG_fail;
7718 }
7719 Py_INCREF(Py_None); resultobj = Py_None;
7720 return resultobj;
7721 fail:
7722 return NULL;
7723 }
7724
7725
7726 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7727 PyObject *resultobj;
7728 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7729 wxString *arg2 = 0 ;
7730 wxString const &arg3_defvalue = wxPyEmptyString ;
7731 wxString *arg3 = (wxString *) &arg3_defvalue ;
7732 bool result;
7733 bool temp2 = false ;
7734 bool temp3 = false ;
7735 PyObject * obj0 = 0 ;
7736 PyObject * obj1 = 0 ;
7737 PyObject * obj2 = 0 ;
7738 char *kwnames[] = {
7739 (char *) "self",(char *) "name",(char *) "path", NULL
7740 };
7741
7742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7744 if (SWIG_arg_fail(1)) SWIG_fail;
7745 {
7746 arg2 = wxString_in_helper(obj1);
7747 if (arg2 == NULL) SWIG_fail;
7748 temp2 = true;
7749 }
7750 if (obj2) {
7751 {
7752 arg3 = wxString_in_helper(obj2);
7753 if (arg3 == NULL) SWIG_fail;
7754 temp3 = true;
7755 }
7756 }
7757 {
7758 PyThreadState* __tstate = wxPyBeginAllowThreads();
7759 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7760
7761 wxPyEndAllowThreads(__tstate);
7762 if (PyErr_Occurred()) SWIG_fail;
7763 }
7764 {
7765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7766 }
7767 {
7768 if (temp2)
7769 delete arg2;
7770 }
7771 {
7772 if (temp3)
7773 delete arg3;
7774 }
7775 return resultobj;
7776 fail:
7777 {
7778 if (temp2)
7779 delete arg2;
7780 }
7781 {
7782 if (temp3)
7783 delete arg3;
7784 }
7785 return NULL;
7786 }
7787
7788
7789 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7790 PyObject *resultobj;
7791 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7792 bool result;
7793 PyObject * obj0 = 0 ;
7794 char *kwnames[] = {
7795 (char *) "self", NULL
7796 };
7797
7798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7800 if (SWIG_arg_fail(1)) SWIG_fail;
7801 {
7802 PyThreadState* __tstate = wxPyBeginAllowThreads();
7803 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7804
7805 wxPyEndAllowThreads(__tstate);
7806 if (PyErr_Occurred()) SWIG_fail;
7807 }
7808 {
7809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7810 }
7811 return resultobj;
7812 fail:
7813 return NULL;
7814 }
7815
7816
7817 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7818 PyObject *obj;
7819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7820 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7821 Py_INCREF(obj);
7822 return Py_BuildValue((char *)"");
7823 }
7824 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7825 PyObject *resultobj;
7826 wxWindow *arg1 = (wxWindow *) 0 ;
7827 wxDC *arg2 = 0 ;
7828 bool result;
7829 PyObject * obj0 = 0 ;
7830 PyObject * obj1 = 0 ;
7831 char *kwnames[] = {
7832 (char *) "window",(char *) "dc", NULL
7833 };
7834
7835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7837 if (SWIG_arg_fail(1)) SWIG_fail;
7838 {
7839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7840 if (SWIG_arg_fail(2)) SWIG_fail;
7841 if (arg2 == NULL) {
7842 SWIG_null_ref("wxDC");
7843 }
7844 if (SWIG_arg_fail(2)) SWIG_fail;
7845 }
7846 {
7847 PyThreadState* __tstate = wxPyBeginAllowThreads();
7848 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7849
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 {
7854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7855 }
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7863 PyObject *resultobj;
7864 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7865 PyObject * obj0 = 0 ;
7866 char *kwnames[] = {
7867 (char *) "self", NULL
7868 };
7869
7870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7872 if (SWIG_arg_fail(1)) SWIG_fail;
7873 {
7874 PyThreadState* __tstate = wxPyBeginAllowThreads();
7875 delete arg1;
7876
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 Py_INCREF(Py_None); resultobj = Py_None;
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7888 PyObject *resultobj;
7889 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7890 wxString result;
7891 PyObject * obj0 = 0 ;
7892 char *kwnames[] = {
7893 (char *) "self", NULL
7894 };
7895
7896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7898 if (SWIG_arg_fail(1)) SWIG_fail;
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 result = (arg1)->GetTip();
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 {
7907 #if wxUSE_UNICODE
7908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7909 #else
7910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7911 #endif
7912 }
7913 return resultobj;
7914 fail:
7915 return NULL;
7916 }
7917
7918
7919 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7920 PyObject *resultobj;
7921 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7922 size_t result;
7923 PyObject * obj0 = 0 ;
7924 char *kwnames[] = {
7925 (char *) "self", NULL
7926 };
7927
7928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7930 if (SWIG_arg_fail(1)) SWIG_fail;
7931 {
7932 PyThreadState* __tstate = wxPyBeginAllowThreads();
7933 result = (size_t)(arg1)->GetCurrentTip();
7934
7935 wxPyEndAllowThreads(__tstate);
7936 if (PyErr_Occurred()) SWIG_fail;
7937 }
7938 {
7939 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7940 }
7941 return resultobj;
7942 fail:
7943 return NULL;
7944 }
7945
7946
7947 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7948 PyObject *resultobj;
7949 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7950 wxString *arg2 = 0 ;
7951 wxString result;
7952 bool temp2 = false ;
7953 PyObject * obj0 = 0 ;
7954 PyObject * obj1 = 0 ;
7955 char *kwnames[] = {
7956 (char *) "self",(char *) "tip", NULL
7957 };
7958
7959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7961 if (SWIG_arg_fail(1)) SWIG_fail;
7962 {
7963 arg2 = wxString_in_helper(obj1);
7964 if (arg2 == NULL) SWIG_fail;
7965 temp2 = true;
7966 }
7967 {
7968 PyThreadState* __tstate = wxPyBeginAllowThreads();
7969 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7970
7971 wxPyEndAllowThreads(__tstate);
7972 if (PyErr_Occurred()) SWIG_fail;
7973 }
7974 {
7975 #if wxUSE_UNICODE
7976 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7977 #else
7978 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7979 #endif
7980 }
7981 {
7982 if (temp2)
7983 delete arg2;
7984 }
7985 return resultobj;
7986 fail:
7987 {
7988 if (temp2)
7989 delete arg2;
7990 }
7991 return NULL;
7992 }
7993
7994
7995 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7996 PyObject *obj;
7997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7998 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7999 Py_INCREF(obj);
8000 return Py_BuildValue((char *)"");
8001 }
8002 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8003 PyObject *resultobj;
8004 size_t arg1 ;
8005 wxPyTipProvider *result;
8006 PyObject * obj0 = 0 ;
8007 char *kwnames[] = {
8008 (char *) "currentTip", NULL
8009 };
8010
8011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8012 {
8013 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8014 if (SWIG_arg_fail(1)) SWIG_fail;
8015 }
8016 {
8017 PyThreadState* __tstate = wxPyBeginAllowThreads();
8018 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8019
8020 wxPyEndAllowThreads(__tstate);
8021 if (PyErr_Occurred()) SWIG_fail;
8022 }
8023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8024 return resultobj;
8025 fail:
8026 return NULL;
8027 }
8028
8029
8030 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8031 PyObject *resultobj;
8032 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8033 PyObject *arg2 = (PyObject *) 0 ;
8034 PyObject *arg3 = (PyObject *) 0 ;
8035 PyObject * obj0 = 0 ;
8036 PyObject * obj1 = 0 ;
8037 PyObject * obj2 = 0 ;
8038 char *kwnames[] = {
8039 (char *) "self",(char *) "self",(char *) "_class", NULL
8040 };
8041
8042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8044 if (SWIG_arg_fail(1)) SWIG_fail;
8045 arg2 = obj1;
8046 arg3 = obj2;
8047 {
8048 PyThreadState* __tstate = wxPyBeginAllowThreads();
8049 (arg1)->_setCallbackInfo(arg2,arg3);
8050
8051 wxPyEndAllowThreads(__tstate);
8052 if (PyErr_Occurred()) SWIG_fail;
8053 }
8054 Py_INCREF(Py_None); resultobj = Py_None;
8055 return resultobj;
8056 fail:
8057 return NULL;
8058 }
8059
8060
8061 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8062 PyObject *obj;
8063 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8064 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8065 Py_INCREF(obj);
8066 return Py_BuildValue((char *)"");
8067 }
8068 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8069 PyObject *resultobj;
8070 wxWindow *arg1 = (wxWindow *) 0 ;
8071 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8072 bool arg3 = (bool) true ;
8073 bool result;
8074 PyObject * obj0 = 0 ;
8075 PyObject * obj1 = 0 ;
8076 PyObject * obj2 = 0 ;
8077 char *kwnames[] = {
8078 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8079 };
8080
8081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8083 if (SWIG_arg_fail(1)) SWIG_fail;
8084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8085 if (SWIG_arg_fail(2)) SWIG_fail;
8086 if (obj2) {
8087 {
8088 arg3 = (bool)(SWIG_As_bool(obj2));
8089 if (SWIG_arg_fail(3)) SWIG_fail;
8090 }
8091 }
8092 {
8093 if (!wxPyCheckForApp()) SWIG_fail;
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 result = (bool)wxShowTip(arg1,arg2,arg3);
8096
8097 wxPyEndAllowThreads(__tstate);
8098 if (PyErr_Occurred()) SWIG_fail;
8099 }
8100 {
8101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8102 }
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8110 PyObject *resultobj;
8111 wxString *arg1 = 0 ;
8112 size_t arg2 ;
8113 wxTipProvider *result;
8114 bool temp1 = false ;
8115 PyObject * obj0 = 0 ;
8116 PyObject * obj1 = 0 ;
8117 char *kwnames[] = {
8118 (char *) "filename",(char *) "currentTip", NULL
8119 };
8120
8121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8122 {
8123 arg1 = wxString_in_helper(obj0);
8124 if (arg1 == NULL) SWIG_fail;
8125 temp1 = true;
8126 }
8127 {
8128 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8129 if (SWIG_arg_fail(2)) SWIG_fail;
8130 }
8131 {
8132 if (!wxPyCheckForApp()) SWIG_fail;
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8135
8136 wxPyEndAllowThreads(__tstate);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8140 {
8141 if (temp1)
8142 delete arg1;
8143 }
8144 return resultobj;
8145 fail:
8146 {
8147 if (temp1)
8148 delete arg1;
8149 }
8150 return NULL;
8151 }
8152
8153
8154 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8155 PyObject *resultobj;
8156 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8157 int arg2 = (int) -1 ;
8158 wxPyTimer *result;
8159 PyObject * obj0 = 0 ;
8160 PyObject * obj1 = 0 ;
8161 char *kwnames[] = {
8162 (char *) "owner",(char *) "id", NULL
8163 };
8164
8165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8166 if (obj0) {
8167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8168 if (SWIG_arg_fail(1)) SWIG_fail;
8169 }
8170 if (obj1) {
8171 {
8172 arg2 = (int)(SWIG_As_int(obj1));
8173 if (SWIG_arg_fail(2)) SWIG_fail;
8174 }
8175 }
8176 {
8177 if (!wxPyCheckForApp()) SWIG_fail;
8178 PyThreadState* __tstate = wxPyBeginAllowThreads();
8179 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8180
8181 wxPyEndAllowThreads(__tstate);
8182 if (PyErr_Occurred()) SWIG_fail;
8183 }
8184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8185 return resultobj;
8186 fail:
8187 return NULL;
8188 }
8189
8190
8191 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8192 PyObject *resultobj;
8193 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8194 PyObject * obj0 = 0 ;
8195 char *kwnames[] = {
8196 (char *) "self", NULL
8197 };
8198
8199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8201 if (SWIG_arg_fail(1)) SWIG_fail;
8202 {
8203 PyThreadState* __tstate = wxPyBeginAllowThreads();
8204 delete arg1;
8205
8206 wxPyEndAllowThreads(__tstate);
8207 if (PyErr_Occurred()) SWIG_fail;
8208 }
8209 Py_INCREF(Py_None); resultobj = Py_None;
8210 return resultobj;
8211 fail:
8212 return NULL;
8213 }
8214
8215
8216 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8217 PyObject *resultobj;
8218 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8219 PyObject *arg2 = (PyObject *) 0 ;
8220 PyObject *arg3 = (PyObject *) 0 ;
8221 int arg4 = (int) 1 ;
8222 PyObject * obj0 = 0 ;
8223 PyObject * obj1 = 0 ;
8224 PyObject * obj2 = 0 ;
8225 PyObject * obj3 = 0 ;
8226 char *kwnames[] = {
8227 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8228 };
8229
8230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8232 if (SWIG_arg_fail(1)) SWIG_fail;
8233 arg2 = obj1;
8234 arg3 = obj2;
8235 if (obj3) {
8236 {
8237 arg4 = (int)(SWIG_As_int(obj3));
8238 if (SWIG_arg_fail(4)) SWIG_fail;
8239 }
8240 }
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8244
8245 wxPyEndAllowThreads(__tstate);
8246 if (PyErr_Occurred()) SWIG_fail;
8247 }
8248 Py_INCREF(Py_None); resultobj = Py_None;
8249 return resultobj;
8250 fail:
8251 return NULL;
8252 }
8253
8254
8255 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8256 PyObject *resultobj;
8257 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8258 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8259 int arg3 = (int) -1 ;
8260 PyObject * obj0 = 0 ;
8261 PyObject * obj1 = 0 ;
8262 PyObject * obj2 = 0 ;
8263 char *kwnames[] = {
8264 (char *) "self",(char *) "owner",(char *) "id", NULL
8265 };
8266
8267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8269 if (SWIG_arg_fail(1)) SWIG_fail;
8270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8271 if (SWIG_arg_fail(2)) SWIG_fail;
8272 if (obj2) {
8273 {
8274 arg3 = (int)(SWIG_As_int(obj2));
8275 if (SWIG_arg_fail(3)) SWIG_fail;
8276 }
8277 }
8278 {
8279 PyThreadState* __tstate = wxPyBeginAllowThreads();
8280 (arg1)->SetOwner(arg2,arg3);
8281
8282 wxPyEndAllowThreads(__tstate);
8283 if (PyErr_Occurred()) SWIG_fail;
8284 }
8285 Py_INCREF(Py_None); resultobj = Py_None;
8286 return resultobj;
8287 fail:
8288 return NULL;
8289 }
8290
8291
8292 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8293 PyObject *resultobj;
8294 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8295 wxEvtHandler *result;
8296 PyObject * obj0 = 0 ;
8297 char *kwnames[] = {
8298 (char *) "self", NULL
8299 };
8300
8301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8303 if (SWIG_arg_fail(1)) SWIG_fail;
8304 {
8305 PyThreadState* __tstate = wxPyBeginAllowThreads();
8306 result = (wxEvtHandler *)(arg1)->GetOwner();
8307
8308 wxPyEndAllowThreads(__tstate);
8309 if (PyErr_Occurred()) SWIG_fail;
8310 }
8311 {
8312 resultobj = wxPyMake_wxObject(result, 0);
8313 }
8314 return resultobj;
8315 fail:
8316 return NULL;
8317 }
8318
8319
8320 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8321 PyObject *resultobj;
8322 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8323 int arg2 = (int) -1 ;
8324 bool arg3 = (bool) false ;
8325 bool result;
8326 PyObject * obj0 = 0 ;
8327 PyObject * obj1 = 0 ;
8328 PyObject * obj2 = 0 ;
8329 char *kwnames[] = {
8330 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8331 };
8332
8333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8335 if (SWIG_arg_fail(1)) SWIG_fail;
8336 if (obj1) {
8337 {
8338 arg2 = (int)(SWIG_As_int(obj1));
8339 if (SWIG_arg_fail(2)) SWIG_fail;
8340 }
8341 }
8342 if (obj2) {
8343 {
8344 arg3 = (bool)(SWIG_As_bool(obj2));
8345 if (SWIG_arg_fail(3)) SWIG_fail;
8346 }
8347 }
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 result = (bool)(arg1)->Start(arg2,arg3);
8351
8352 wxPyEndAllowThreads(__tstate);
8353 if (PyErr_Occurred()) SWIG_fail;
8354 }
8355 {
8356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8357 }
8358 return resultobj;
8359 fail:
8360 return NULL;
8361 }
8362
8363
8364 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8365 PyObject *resultobj;
8366 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8367 PyObject * obj0 = 0 ;
8368 char *kwnames[] = {
8369 (char *) "self", NULL
8370 };
8371
8372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8374 if (SWIG_arg_fail(1)) SWIG_fail;
8375 {
8376 PyThreadState* __tstate = wxPyBeginAllowThreads();
8377 (arg1)->Stop();
8378
8379 wxPyEndAllowThreads(__tstate);
8380 if (PyErr_Occurred()) SWIG_fail;
8381 }
8382 Py_INCREF(Py_None); resultobj = Py_None;
8383 return resultobj;
8384 fail:
8385 return NULL;
8386 }
8387
8388
8389 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8390 PyObject *resultobj;
8391 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8392 bool result;
8393 PyObject * obj0 = 0 ;
8394 char *kwnames[] = {
8395 (char *) "self", NULL
8396 };
8397
8398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8400 if (SWIG_arg_fail(1)) SWIG_fail;
8401 {
8402 PyThreadState* __tstate = wxPyBeginAllowThreads();
8403 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8404
8405 wxPyEndAllowThreads(__tstate);
8406 if (PyErr_Occurred()) SWIG_fail;
8407 }
8408 {
8409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8410 }
8411 return resultobj;
8412 fail:
8413 return NULL;
8414 }
8415
8416
8417 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8418 PyObject *resultobj;
8419 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8420 int result;
8421 PyObject * obj0 = 0 ;
8422 char *kwnames[] = {
8423 (char *) "self", NULL
8424 };
8425
8426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8428 if (SWIG_arg_fail(1)) SWIG_fail;
8429 {
8430 PyThreadState* __tstate = wxPyBeginAllowThreads();
8431 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8432
8433 wxPyEndAllowThreads(__tstate);
8434 if (PyErr_Occurred()) SWIG_fail;
8435 }
8436 {
8437 resultobj = SWIG_From_int((int)(result));
8438 }
8439 return resultobj;
8440 fail:
8441 return NULL;
8442 }
8443
8444
8445 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8446 PyObject *resultobj;
8447 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8448 bool result;
8449 PyObject * obj0 = 0 ;
8450 char *kwnames[] = {
8451 (char *) "self", NULL
8452 };
8453
8454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8456 if (SWIG_arg_fail(1)) SWIG_fail;
8457 {
8458 PyThreadState* __tstate = wxPyBeginAllowThreads();
8459 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8460
8461 wxPyEndAllowThreads(__tstate);
8462 if (PyErr_Occurred()) SWIG_fail;
8463 }
8464 {
8465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8466 }
8467 return resultobj;
8468 fail:
8469 return NULL;
8470 }
8471
8472
8473 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8474 PyObject *resultobj;
8475 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8476 int result;
8477 PyObject * obj0 = 0 ;
8478 char *kwnames[] = {
8479 (char *) "self", NULL
8480 };
8481
8482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8484 if (SWIG_arg_fail(1)) SWIG_fail;
8485 {
8486 PyThreadState* __tstate = wxPyBeginAllowThreads();
8487 result = (int)((wxPyTimer const *)arg1)->GetId();
8488
8489 wxPyEndAllowThreads(__tstate);
8490 if (PyErr_Occurred()) SWIG_fail;
8491 }
8492 {
8493 resultobj = SWIG_From_int((int)(result));
8494 }
8495 return resultobj;
8496 fail:
8497 return NULL;
8498 }
8499
8500
8501 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8502 PyObject *obj;
8503 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8504 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8505 Py_INCREF(obj);
8506 return Py_BuildValue((char *)"");
8507 }
8508 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8509 PyObject *resultobj;
8510 int arg1 = (int) 0 ;
8511 int arg2 = (int) 0 ;
8512 wxTimerEvent *result;
8513 PyObject * obj0 = 0 ;
8514 PyObject * obj1 = 0 ;
8515 char *kwnames[] = {
8516 (char *) "timerid",(char *) "interval", NULL
8517 };
8518
8519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8520 if (obj0) {
8521 {
8522 arg1 = (int)(SWIG_As_int(obj0));
8523 if (SWIG_arg_fail(1)) SWIG_fail;
8524 }
8525 }
8526 if (obj1) {
8527 {
8528 arg2 = (int)(SWIG_As_int(obj1));
8529 if (SWIG_arg_fail(2)) SWIG_fail;
8530 }
8531 }
8532 {
8533 PyThreadState* __tstate = wxPyBeginAllowThreads();
8534 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8535
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8547 PyObject *resultobj;
8548 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8549 int result;
8550 PyObject * obj0 = 0 ;
8551 char *kwnames[] = {
8552 (char *) "self", NULL
8553 };
8554
8555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8557 if (SWIG_arg_fail(1)) SWIG_fail;
8558 {
8559 PyThreadState* __tstate = wxPyBeginAllowThreads();
8560 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8561
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 {
8566 resultobj = SWIG_From_int((int)(result));
8567 }
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8575 PyObject *obj;
8576 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8577 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8578 Py_INCREF(obj);
8579 return Py_BuildValue((char *)"");
8580 }
8581 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8582 PyObject *resultobj;
8583 wxTimer *arg1 = 0 ;
8584 wxTimerRunner *result;
8585 PyObject * obj0 = 0 ;
8586
8587 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8588 {
8589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8590 if (SWIG_arg_fail(1)) SWIG_fail;
8591 if (arg1 == NULL) {
8592 SWIG_null_ref("wxTimer");
8593 }
8594 if (SWIG_arg_fail(1)) SWIG_fail;
8595 }
8596 {
8597 if (!wxPyCheckForApp()) SWIG_fail;
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
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__SWIG_1(PyObject *, PyObject *args) {
8612 PyObject *resultobj;
8613 wxTimer *arg1 = 0 ;
8614 int arg2 ;
8615 bool arg3 = (bool) false ;
8616 wxTimerRunner *result;
8617 PyObject * obj0 = 0 ;
8618 PyObject * obj1 = 0 ;
8619 PyObject * obj2 = 0 ;
8620
8621 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8622 {
8623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8624 if (SWIG_arg_fail(1)) SWIG_fail;
8625 if (arg1 == NULL) {
8626 SWIG_null_ref("wxTimer");
8627 }
8628 if (SWIG_arg_fail(1)) SWIG_fail;
8629 }
8630 {
8631 arg2 = (int)(SWIG_As_int(obj1));
8632 if (SWIG_arg_fail(2)) SWIG_fail;
8633 }
8634 if (obj2) {
8635 {
8636 arg3 = (bool)(SWIG_As_bool(obj2));
8637 if (SWIG_arg_fail(3)) SWIG_fail;
8638 }
8639 }
8640 {
8641 if (!wxPyCheckForApp()) SWIG_fail;
8642 PyThreadState* __tstate = wxPyBeginAllowThreads();
8643 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8644
8645 wxPyEndAllowThreads(__tstate);
8646 if (PyErr_Occurred()) SWIG_fail;
8647 }
8648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8649 return resultobj;
8650 fail:
8651 return NULL;
8652 }
8653
8654
8655 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8656 int argc;
8657 PyObject *argv[4];
8658 int ii;
8659
8660 argc = PyObject_Length(args);
8661 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8662 argv[ii] = PyTuple_GetItem(args,ii);
8663 }
8664 if (argc == 1) {
8665 int _v;
8666 {
8667 void *ptr = 0;
8668 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8669 _v = 0;
8670 PyErr_Clear();
8671 } else {
8672 _v = (ptr != 0);
8673 }
8674 }
8675 if (_v) {
8676 return _wrap_new_TimerRunner__SWIG_0(self,args);
8677 }
8678 }
8679 if ((argc >= 2) && (argc <= 3)) {
8680 int _v;
8681 {
8682 void *ptr = 0;
8683 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8684 _v = 0;
8685 PyErr_Clear();
8686 } else {
8687 _v = (ptr != 0);
8688 }
8689 }
8690 if (_v) {
8691 _v = SWIG_Check_int(argv[1]);
8692 if (_v) {
8693 if (argc <= 2) {
8694 return _wrap_new_TimerRunner__SWIG_1(self,args);
8695 }
8696 _v = SWIG_Check_bool(argv[2]);
8697 if (_v) {
8698 return _wrap_new_TimerRunner__SWIG_1(self,args);
8699 }
8700 }
8701 }
8702 }
8703
8704 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8705 return NULL;
8706 }
8707
8708
8709 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8710 PyObject *resultobj;
8711 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8712 PyObject * obj0 = 0 ;
8713 char *kwnames[] = {
8714 (char *) "self", NULL
8715 };
8716
8717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8719 if (SWIG_arg_fail(1)) SWIG_fail;
8720 {
8721 PyThreadState* __tstate = wxPyBeginAllowThreads();
8722 delete arg1;
8723
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 Py_INCREF(Py_None); resultobj = Py_None;
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj;
8736 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8737 int arg2 ;
8738 bool arg3 = (bool) false ;
8739 PyObject * obj0 = 0 ;
8740 PyObject * obj1 = 0 ;
8741 PyObject * obj2 = 0 ;
8742 char *kwnames[] = {
8743 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8744 };
8745
8746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8748 if (SWIG_arg_fail(1)) SWIG_fail;
8749 {
8750 arg2 = (int)(SWIG_As_int(obj1));
8751 if (SWIG_arg_fail(2)) SWIG_fail;
8752 }
8753 if (obj2) {
8754 {
8755 arg3 = (bool)(SWIG_As_bool(obj2));
8756 if (SWIG_arg_fail(3)) SWIG_fail;
8757 }
8758 }
8759 {
8760 PyThreadState* __tstate = wxPyBeginAllowThreads();
8761 (arg1)->Start(arg2,arg3);
8762
8763 wxPyEndAllowThreads(__tstate);
8764 if (PyErr_Occurred()) SWIG_fail;
8765 }
8766 Py_INCREF(Py_None); resultobj = Py_None;
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8774 PyObject *obj;
8775 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8776 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8777 Py_INCREF(obj);
8778 return Py_BuildValue((char *)"");
8779 }
8780 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj;
8782 wxLog *result;
8783 char *kwnames[] = {
8784 NULL
8785 };
8786
8787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 result = (wxLog *)new wxLog();
8791
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8796 return resultobj;
8797 fail:
8798 return NULL;
8799 }
8800
8801
8802 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8803 PyObject *resultobj;
8804 bool result;
8805 char *kwnames[] = {
8806 NULL
8807 };
8808
8809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8810 {
8811 PyThreadState* __tstate = wxPyBeginAllowThreads();
8812 result = (bool)wxLog::IsEnabled();
8813
8814 wxPyEndAllowThreads(__tstate);
8815 if (PyErr_Occurred()) SWIG_fail;
8816 }
8817 {
8818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8819 }
8820 return resultobj;
8821 fail:
8822 return NULL;
8823 }
8824
8825
8826 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8827 PyObject *resultobj;
8828 bool arg1 = (bool) true ;
8829 bool result;
8830 PyObject * obj0 = 0 ;
8831 char *kwnames[] = {
8832 (char *) "doIt", NULL
8833 };
8834
8835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8836 if (obj0) {
8837 {
8838 arg1 = (bool)(SWIG_As_bool(obj0));
8839 if (SWIG_arg_fail(1)) SWIG_fail;
8840 }
8841 }
8842 {
8843 PyThreadState* __tstate = wxPyBeginAllowThreads();
8844 result = (bool)wxLog::EnableLogging(arg1);
8845
8846 wxPyEndAllowThreads(__tstate);
8847 if (PyErr_Occurred()) SWIG_fail;
8848 }
8849 {
8850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8851 }
8852 return resultobj;
8853 fail:
8854 return NULL;
8855 }
8856
8857
8858 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj;
8860 wxLogLevel arg1 ;
8861 wxChar *arg2 = (wxChar *) 0 ;
8862 time_t arg3 ;
8863 PyObject * obj0 = 0 ;
8864 PyObject * obj1 = 0 ;
8865 PyObject * obj2 = 0 ;
8866 char *kwnames[] = {
8867 (char *) "level",(char *) "szString",(char *) "t", NULL
8868 };
8869
8870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8871 {
8872 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8873 if (SWIG_arg_fail(1)) SWIG_fail;
8874 }
8875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8876 if (SWIG_arg_fail(2)) SWIG_fail;
8877 {
8878 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8879 if (SWIG_arg_fail(3)) SWIG_fail;
8880 }
8881 {
8882 PyThreadState* __tstate = wxPyBeginAllowThreads();
8883 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8884
8885 wxPyEndAllowThreads(__tstate);
8886 if (PyErr_Occurred()) SWIG_fail;
8887 }
8888 Py_INCREF(Py_None); resultobj = Py_None;
8889 return resultobj;
8890 fail:
8891 return NULL;
8892 }
8893
8894
8895 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8896 PyObject *resultobj;
8897 wxLog *arg1 = (wxLog *) 0 ;
8898 PyObject * obj0 = 0 ;
8899 char *kwnames[] = {
8900 (char *) "self", NULL
8901 };
8902
8903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8905 if (SWIG_arg_fail(1)) SWIG_fail;
8906 {
8907 PyThreadState* __tstate = wxPyBeginAllowThreads();
8908 (arg1)->Flush();
8909
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 Py_INCREF(Py_None); resultobj = Py_None;
8914 return resultobj;
8915 fail:
8916 return NULL;
8917 }
8918
8919
8920 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8921 PyObject *resultobj;
8922 char *kwnames[] = {
8923 NULL
8924 };
8925
8926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8927 {
8928 PyThreadState* __tstate = wxPyBeginAllowThreads();
8929 wxLog::FlushActive();
8930
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 Py_INCREF(Py_None); resultobj = Py_None;
8935 return resultobj;
8936 fail:
8937 return NULL;
8938 }
8939
8940
8941 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8942 PyObject *resultobj;
8943 wxLog *result;
8944 char *kwnames[] = {
8945 NULL
8946 };
8947
8948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8949 {
8950 PyThreadState* __tstate = wxPyBeginAllowThreads();
8951 result = (wxLog *)wxLog::GetActiveTarget();
8952
8953 wxPyEndAllowThreads(__tstate);
8954 if (PyErr_Occurred()) SWIG_fail;
8955 }
8956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8957 return resultobj;
8958 fail:
8959 return NULL;
8960 }
8961
8962
8963 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8964 PyObject *resultobj;
8965 wxLog *arg1 = (wxLog *) 0 ;
8966 wxLog *result;
8967 PyObject * obj0 = 0 ;
8968 char *kwnames[] = {
8969 (char *) "pLogger", NULL
8970 };
8971
8972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8974 if (SWIG_arg_fail(1)) SWIG_fail;
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8978
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8990 PyObject *resultobj;
8991 char *kwnames[] = {
8992 NULL
8993 };
8994
8995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8996 {
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 wxLog::Suspend();
8999
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 Py_INCREF(Py_None); resultobj = Py_None;
9004 return resultobj;
9005 fail:
9006 return NULL;
9007 }
9008
9009
9010 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9011 PyObject *resultobj;
9012 char *kwnames[] = {
9013 NULL
9014 };
9015
9016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 wxLog::Resume();
9020
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 Py_INCREF(Py_None); resultobj = Py_None;
9025 return resultobj;
9026 fail:
9027 return NULL;
9028 }
9029
9030
9031 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9032 PyObject *resultobj;
9033 bool arg1 = (bool) true ;
9034 PyObject * obj0 = 0 ;
9035 char *kwnames[] = {
9036 (char *) "bVerbose", NULL
9037 };
9038
9039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9040 if (obj0) {
9041 {
9042 arg1 = (bool)(SWIG_As_bool(obj0));
9043 if (SWIG_arg_fail(1)) SWIG_fail;
9044 }
9045 }
9046 {
9047 PyThreadState* __tstate = wxPyBeginAllowThreads();
9048 wxLog::SetVerbose(arg1);
9049
9050 wxPyEndAllowThreads(__tstate);
9051 if (PyErr_Occurred()) SWIG_fail;
9052 }
9053 Py_INCREF(Py_None); resultobj = Py_None;
9054 return resultobj;
9055 fail:
9056 return NULL;
9057 }
9058
9059
9060 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9061 PyObject *resultobj;
9062 wxLogLevel arg1 ;
9063 PyObject * obj0 = 0 ;
9064 char *kwnames[] = {
9065 (char *) "logLevel", NULL
9066 };
9067
9068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9069 {
9070 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9071 if (SWIG_arg_fail(1)) SWIG_fail;
9072 }
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 wxLog::SetLogLevel(arg1);
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 Py_INCREF(Py_None); resultobj = Py_None;
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9088 PyObject *resultobj;
9089 char *kwnames[] = {
9090 NULL
9091 };
9092
9093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9094 {
9095 PyThreadState* __tstate = wxPyBeginAllowThreads();
9096 wxLog::DontCreateOnDemand();
9097
9098 wxPyEndAllowThreads(__tstate);
9099 if (PyErr_Occurred()) SWIG_fail;
9100 }
9101 Py_INCREF(Py_None); resultobj = Py_None;
9102 return resultobj;
9103 fail:
9104 return NULL;
9105 }
9106
9107
9108 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9109 PyObject *resultobj;
9110 wxTraceMask arg1 ;
9111 PyObject * obj0 = 0 ;
9112 char *kwnames[] = {
9113 (char *) "ulMask", NULL
9114 };
9115
9116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9117 {
9118 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9119 if (SWIG_arg_fail(1)) SWIG_fail;
9120 }
9121 {
9122 PyThreadState* __tstate = wxPyBeginAllowThreads();
9123 wxLog::SetTraceMask(arg1);
9124
9125 wxPyEndAllowThreads(__tstate);
9126 if (PyErr_Occurred()) SWIG_fail;
9127 }
9128 Py_INCREF(Py_None); resultobj = Py_None;
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj;
9137 wxString *arg1 = 0 ;
9138 bool temp1 = false ;
9139 PyObject * obj0 = 0 ;
9140 char *kwnames[] = {
9141 (char *) "str", NULL
9142 };
9143
9144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9145 {
9146 arg1 = wxString_in_helper(obj0);
9147 if (arg1 == NULL) SWIG_fail;
9148 temp1 = true;
9149 }
9150 {
9151 PyThreadState* __tstate = wxPyBeginAllowThreads();
9152 wxLog::AddTraceMask((wxString const &)*arg1);
9153
9154 wxPyEndAllowThreads(__tstate);
9155 if (PyErr_Occurred()) SWIG_fail;
9156 }
9157 Py_INCREF(Py_None); resultobj = Py_None;
9158 {
9159 if (temp1)
9160 delete arg1;
9161 }
9162 return resultobj;
9163 fail:
9164 {
9165 if (temp1)
9166 delete arg1;
9167 }
9168 return NULL;
9169 }
9170
9171
9172 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9173 PyObject *resultobj;
9174 wxString *arg1 = 0 ;
9175 bool temp1 = false ;
9176 PyObject * obj0 = 0 ;
9177 char *kwnames[] = {
9178 (char *) "str", NULL
9179 };
9180
9181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9182 {
9183 arg1 = wxString_in_helper(obj0);
9184 if (arg1 == NULL) SWIG_fail;
9185 temp1 = true;
9186 }
9187 {
9188 PyThreadState* __tstate = wxPyBeginAllowThreads();
9189 wxLog::RemoveTraceMask((wxString const &)*arg1);
9190
9191 wxPyEndAllowThreads(__tstate);
9192 if (PyErr_Occurred()) SWIG_fail;
9193 }
9194 Py_INCREF(Py_None); resultobj = Py_None;
9195 {
9196 if (temp1)
9197 delete arg1;
9198 }
9199 return resultobj;
9200 fail:
9201 {
9202 if (temp1)
9203 delete arg1;
9204 }
9205 return NULL;
9206 }
9207
9208
9209 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9210 PyObject *resultobj;
9211 char *kwnames[] = {
9212 NULL
9213 };
9214
9215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9216 {
9217 PyThreadState* __tstate = wxPyBeginAllowThreads();
9218 wxLog::ClearTraceMasks();
9219
9220 wxPyEndAllowThreads(__tstate);
9221 if (PyErr_Occurred()) SWIG_fail;
9222 }
9223 Py_INCREF(Py_None); resultobj = Py_None;
9224 return resultobj;
9225 fail:
9226 return NULL;
9227 }
9228
9229
9230 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9231 PyObject *resultobj;
9232 wxArrayString *result;
9233 char *kwnames[] = {
9234 NULL
9235 };
9236
9237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9238 {
9239 PyThreadState* __tstate = wxPyBeginAllowThreads();
9240 {
9241 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9242 result = (wxArrayString *) &_result_ref;
9243 }
9244
9245 wxPyEndAllowThreads(__tstate);
9246 if (PyErr_Occurred()) SWIG_fail;
9247 }
9248 {
9249 resultobj = wxArrayString2PyList_helper(*result);
9250 }
9251 return resultobj;
9252 fail:
9253 return NULL;
9254 }
9255
9256
9257 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9258 PyObject *resultobj;
9259 wxChar *arg1 = (wxChar *) 0 ;
9260 PyObject * obj0 = 0 ;
9261 char *kwnames[] = {
9262 (char *) "ts", NULL
9263 };
9264
9265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9267 if (SWIG_arg_fail(1)) SWIG_fail;
9268 {
9269 PyThreadState* __tstate = wxPyBeginAllowThreads();
9270 wxLog::SetTimestamp((wxChar const *)arg1);
9271
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 Py_INCREF(Py_None); resultobj = Py_None;
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9283 PyObject *resultobj;
9284 bool result;
9285 char *kwnames[] = {
9286 NULL
9287 };
9288
9289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9290 {
9291 PyThreadState* __tstate = wxPyBeginAllowThreads();
9292 result = (bool)wxLog::GetVerbose();
9293
9294 wxPyEndAllowThreads(__tstate);
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 {
9298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9299 }
9300 return resultobj;
9301 fail:
9302 return NULL;
9303 }
9304
9305
9306 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9307 PyObject *resultobj;
9308 wxTraceMask result;
9309 char *kwnames[] = {
9310 NULL
9311 };
9312
9313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9314 {
9315 PyThreadState* __tstate = wxPyBeginAllowThreads();
9316 result = (wxTraceMask)wxLog::GetTraceMask();
9317
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 {
9322 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9323 }
9324 return resultobj;
9325 fail:
9326 return NULL;
9327 }
9328
9329
9330 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9331 PyObject *resultobj;
9332 wxChar *arg1 = (wxChar *) 0 ;
9333 bool result;
9334 PyObject * obj0 = 0 ;
9335 char *kwnames[] = {
9336 (char *) "mask", NULL
9337 };
9338
9339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9341 if (SWIG_arg_fail(1)) SWIG_fail;
9342 {
9343 PyThreadState* __tstate = wxPyBeginAllowThreads();
9344 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9345
9346 wxPyEndAllowThreads(__tstate);
9347 if (PyErr_Occurred()) SWIG_fail;
9348 }
9349 {
9350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9351 }
9352 return resultobj;
9353 fail:
9354 return NULL;
9355 }
9356
9357
9358 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9359 PyObject *resultobj;
9360 wxLogLevel result;
9361 char *kwnames[] = {
9362 NULL
9363 };
9364
9365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9366 {
9367 PyThreadState* __tstate = wxPyBeginAllowThreads();
9368 result = (wxLogLevel)wxLog::GetLogLevel();
9369
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 {
9374 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9375 }
9376 return resultobj;
9377 fail:
9378 return NULL;
9379 }
9380
9381
9382 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9383 PyObject *resultobj;
9384 wxChar *result;
9385 char *kwnames[] = {
9386 NULL
9387 };
9388
9389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9390 {
9391 PyThreadState* __tstate = wxPyBeginAllowThreads();
9392 result = (wxChar *)wxLog::GetTimestamp();
9393
9394 wxPyEndAllowThreads(__tstate);
9395 if (PyErr_Occurred()) SWIG_fail;
9396 }
9397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9398 return resultobj;
9399 fail:
9400 return NULL;
9401 }
9402
9403
9404 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9405 PyObject *resultobj;
9406 wxString result;
9407 char *kwnames[] = {
9408 NULL
9409 };
9410
9411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 result = Log_TimeStamp();
9415
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 {
9420 #if wxUSE_UNICODE
9421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9422 #else
9423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9424 #endif
9425 }
9426 return resultobj;
9427 fail:
9428 return NULL;
9429 }
9430
9431
9432 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9433 PyObject *resultobj;
9434 wxLog *arg1 = (wxLog *) 0 ;
9435 PyObject * obj0 = 0 ;
9436 char *kwnames[] = {
9437 (char *) "self", NULL
9438 };
9439
9440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9442 if (SWIG_arg_fail(1)) SWIG_fail;
9443 {
9444 PyThreadState* __tstate = wxPyBeginAllowThreads();
9445 wxLog_Destroy(arg1);
9446
9447 wxPyEndAllowThreads(__tstate);
9448 if (PyErr_Occurred()) SWIG_fail;
9449 }
9450 Py_INCREF(Py_None); resultobj = Py_None;
9451 return resultobj;
9452 fail:
9453 return NULL;
9454 }
9455
9456
9457 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9458 PyObject *obj;
9459 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9460 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9461 Py_INCREF(obj);
9462 return Py_BuildValue((char *)"");
9463 }
9464 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9465 PyObject *resultobj;
9466 wxLogStderr *result;
9467 char *kwnames[] = {
9468 NULL
9469 };
9470
9471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (wxLogStderr *)new wxLogStderr();
9475
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9480 return resultobj;
9481 fail:
9482 return NULL;
9483 }
9484
9485
9486 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9487 PyObject *obj;
9488 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9489 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9490 Py_INCREF(obj);
9491 return Py_BuildValue((char *)"");
9492 }
9493 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9494 PyObject *resultobj;
9495 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9496 wxLogTextCtrl *result;
9497 PyObject * obj0 = 0 ;
9498 char *kwnames[] = {
9499 (char *) "pTextCtrl", NULL
9500 };
9501
9502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9504 if (SWIG_arg_fail(1)) SWIG_fail;
9505 {
9506 PyThreadState* __tstate = wxPyBeginAllowThreads();
9507 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9508
9509 wxPyEndAllowThreads(__tstate);
9510 if (PyErr_Occurred()) SWIG_fail;
9511 }
9512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9513 return resultobj;
9514 fail:
9515 return NULL;
9516 }
9517
9518
9519 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9520 PyObject *obj;
9521 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9522 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9523 Py_INCREF(obj);
9524 return Py_BuildValue((char *)"");
9525 }
9526 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9527 PyObject *resultobj;
9528 wxLogGui *result;
9529 char *kwnames[] = {
9530 NULL
9531 };
9532
9533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9534 {
9535 PyThreadState* __tstate = wxPyBeginAllowThreads();
9536 result = (wxLogGui *)new wxLogGui();
9537
9538 wxPyEndAllowThreads(__tstate);
9539 if (PyErr_Occurred()) SWIG_fail;
9540 }
9541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9542 return resultobj;
9543 fail:
9544 return NULL;
9545 }
9546
9547
9548 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9549 PyObject *obj;
9550 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9551 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9552 Py_INCREF(obj);
9553 return Py_BuildValue((char *)"");
9554 }
9555 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9556 PyObject *resultobj;
9557 wxFrame *arg1 = (wxFrame *) 0 ;
9558 wxString *arg2 = 0 ;
9559 bool arg3 = (bool) true ;
9560 bool arg4 = (bool) true ;
9561 wxLogWindow *result;
9562 bool temp2 = false ;
9563 PyObject * obj0 = 0 ;
9564 PyObject * obj1 = 0 ;
9565 PyObject * obj2 = 0 ;
9566 PyObject * obj3 = 0 ;
9567 char *kwnames[] = {
9568 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9569 };
9570
9571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9573 if (SWIG_arg_fail(1)) SWIG_fail;
9574 {
9575 arg2 = wxString_in_helper(obj1);
9576 if (arg2 == NULL) SWIG_fail;
9577 temp2 = true;
9578 }
9579 if (obj2) {
9580 {
9581 arg3 = (bool)(SWIG_As_bool(obj2));
9582 if (SWIG_arg_fail(3)) SWIG_fail;
9583 }
9584 }
9585 if (obj3) {
9586 {
9587 arg4 = (bool)(SWIG_As_bool(obj3));
9588 if (SWIG_arg_fail(4)) SWIG_fail;
9589 }
9590 }
9591 {
9592 PyThreadState* __tstate = wxPyBeginAllowThreads();
9593 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9594
9595 wxPyEndAllowThreads(__tstate);
9596 if (PyErr_Occurred()) SWIG_fail;
9597 }
9598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9599 {
9600 if (temp2)
9601 delete arg2;
9602 }
9603 return resultobj;
9604 fail:
9605 {
9606 if (temp2)
9607 delete arg2;
9608 }
9609 return NULL;
9610 }
9611
9612
9613 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9614 PyObject *resultobj;
9615 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9616 bool arg2 = (bool) true ;
9617 PyObject * obj0 = 0 ;
9618 PyObject * obj1 = 0 ;
9619 char *kwnames[] = {
9620 (char *) "self",(char *) "bShow", NULL
9621 };
9622
9623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9625 if (SWIG_arg_fail(1)) SWIG_fail;
9626 if (obj1) {
9627 {
9628 arg2 = (bool)(SWIG_As_bool(obj1));
9629 if (SWIG_arg_fail(2)) SWIG_fail;
9630 }
9631 }
9632 {
9633 PyThreadState* __tstate = wxPyBeginAllowThreads();
9634 (arg1)->Show(arg2);
9635
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 Py_INCREF(Py_None); resultobj = Py_None;
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9647 PyObject *resultobj;
9648 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9649 wxFrame *result;
9650 PyObject * obj0 = 0 ;
9651 char *kwnames[] = {
9652 (char *) "self", NULL
9653 };
9654
9655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9657 if (SWIG_arg_fail(1)) SWIG_fail;
9658 {
9659 PyThreadState* __tstate = wxPyBeginAllowThreads();
9660 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9661
9662 wxPyEndAllowThreads(__tstate);
9663 if (PyErr_Occurred()) SWIG_fail;
9664 }
9665 {
9666 resultobj = wxPyMake_wxObject(result, 0);
9667 }
9668 return resultobj;
9669 fail:
9670 return NULL;
9671 }
9672
9673
9674 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9675 PyObject *resultobj;
9676 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9677 wxLog *result;
9678 PyObject * obj0 = 0 ;
9679 char *kwnames[] = {
9680 (char *) "self", NULL
9681 };
9682
9683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9685 if (SWIG_arg_fail(1)) SWIG_fail;
9686 {
9687 PyThreadState* __tstate = wxPyBeginAllowThreads();
9688 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9689
9690 wxPyEndAllowThreads(__tstate);
9691 if (PyErr_Occurred()) SWIG_fail;
9692 }
9693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9694 return resultobj;
9695 fail:
9696 return NULL;
9697 }
9698
9699
9700 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9701 PyObject *resultobj;
9702 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9703 bool result;
9704 PyObject * obj0 = 0 ;
9705 char *kwnames[] = {
9706 (char *) "self", NULL
9707 };
9708
9709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9711 if (SWIG_arg_fail(1)) SWIG_fail;
9712 {
9713 PyThreadState* __tstate = wxPyBeginAllowThreads();
9714 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9715
9716 wxPyEndAllowThreads(__tstate);
9717 if (PyErr_Occurred()) SWIG_fail;
9718 }
9719 {
9720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9721 }
9722 return resultobj;
9723 fail:
9724 return NULL;
9725 }
9726
9727
9728 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9729 PyObject *resultobj;
9730 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9731 bool arg2 ;
9732 PyObject * obj0 = 0 ;
9733 PyObject * obj1 = 0 ;
9734 char *kwnames[] = {
9735 (char *) "self",(char *) "bDoPass", NULL
9736 };
9737
9738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9740 if (SWIG_arg_fail(1)) SWIG_fail;
9741 {
9742 arg2 = (bool)(SWIG_As_bool(obj1));
9743 if (SWIG_arg_fail(2)) SWIG_fail;
9744 }
9745 {
9746 PyThreadState* __tstate = wxPyBeginAllowThreads();
9747 (arg1)->PassMessages(arg2);
9748
9749 wxPyEndAllowThreads(__tstate);
9750 if (PyErr_Occurred()) SWIG_fail;
9751 }
9752 Py_INCREF(Py_None); resultobj = Py_None;
9753 return resultobj;
9754 fail:
9755 return NULL;
9756 }
9757
9758
9759 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9760 PyObject *obj;
9761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9762 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9763 Py_INCREF(obj);
9764 return Py_BuildValue((char *)"");
9765 }
9766 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9767 PyObject *resultobj;
9768 wxLog *arg1 = (wxLog *) 0 ;
9769 wxLogChain *result;
9770 PyObject * obj0 = 0 ;
9771 char *kwnames[] = {
9772 (char *) "logger", NULL
9773 };
9774
9775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9777 if (SWIG_arg_fail(1)) SWIG_fail;
9778 {
9779 PyThreadState* __tstate = wxPyBeginAllowThreads();
9780 result = (wxLogChain *)new wxLogChain(arg1);
9781
9782 wxPyEndAllowThreads(__tstate);
9783 if (PyErr_Occurred()) SWIG_fail;
9784 }
9785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9786 return resultobj;
9787 fail:
9788 return NULL;
9789 }
9790
9791
9792 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9793 PyObject *resultobj;
9794 wxLogChain *arg1 = (wxLogChain *) 0 ;
9795 wxLog *arg2 = (wxLog *) 0 ;
9796 PyObject * obj0 = 0 ;
9797 PyObject * obj1 = 0 ;
9798 char *kwnames[] = {
9799 (char *) "self",(char *) "logger", NULL
9800 };
9801
9802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9804 if (SWIG_arg_fail(1)) SWIG_fail;
9805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9806 if (SWIG_arg_fail(2)) SWIG_fail;
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 (arg1)->SetLog(arg2);
9810
9811 wxPyEndAllowThreads(__tstate);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 Py_INCREF(Py_None); resultobj = Py_None;
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9822 PyObject *resultobj;
9823 wxLogChain *arg1 = (wxLogChain *) 0 ;
9824 bool arg2 ;
9825 PyObject * obj0 = 0 ;
9826 PyObject * obj1 = 0 ;
9827 char *kwnames[] = {
9828 (char *) "self",(char *) "bDoPass", NULL
9829 };
9830
9831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9833 if (SWIG_arg_fail(1)) SWIG_fail;
9834 {
9835 arg2 = (bool)(SWIG_As_bool(obj1));
9836 if (SWIG_arg_fail(2)) SWIG_fail;
9837 }
9838 {
9839 PyThreadState* __tstate = wxPyBeginAllowThreads();
9840 (arg1)->PassMessages(arg2);
9841
9842 wxPyEndAllowThreads(__tstate);
9843 if (PyErr_Occurred()) SWIG_fail;
9844 }
9845 Py_INCREF(Py_None); resultobj = Py_None;
9846 return resultobj;
9847 fail:
9848 return NULL;
9849 }
9850
9851
9852 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9853 PyObject *resultobj;
9854 wxLogChain *arg1 = (wxLogChain *) 0 ;
9855 bool result;
9856 PyObject * obj0 = 0 ;
9857 char *kwnames[] = {
9858 (char *) "self", NULL
9859 };
9860
9861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9863 if (SWIG_arg_fail(1)) SWIG_fail;
9864 {
9865 PyThreadState* __tstate = wxPyBeginAllowThreads();
9866 result = (bool)(arg1)->IsPassingMessages();
9867
9868 wxPyEndAllowThreads(__tstate);
9869 if (PyErr_Occurred()) SWIG_fail;
9870 }
9871 {
9872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9873 }
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj;
9882 wxLogChain *arg1 = (wxLogChain *) 0 ;
9883 wxLog *result;
9884 PyObject * obj0 = 0 ;
9885 char *kwnames[] = {
9886 (char *) "self", NULL
9887 };
9888
9889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9891 if (SWIG_arg_fail(1)) SWIG_fail;
9892 {
9893 PyThreadState* __tstate = wxPyBeginAllowThreads();
9894 result = (wxLog *)(arg1)->GetOldLog();
9895
9896 wxPyEndAllowThreads(__tstate);
9897 if (PyErr_Occurred()) SWIG_fail;
9898 }
9899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9900 return resultobj;
9901 fail:
9902 return NULL;
9903 }
9904
9905
9906 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9907 PyObject *obj;
9908 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9909 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9910 Py_INCREF(obj);
9911 return Py_BuildValue((char *)"");
9912 }
9913 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9914 PyObject *resultobj;
9915 unsigned long result;
9916 char *kwnames[] = {
9917 NULL
9918 };
9919
9920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9921 {
9922 PyThreadState* __tstate = wxPyBeginAllowThreads();
9923 result = (unsigned long)wxSysErrorCode();
9924
9925 wxPyEndAllowThreads(__tstate);
9926 if (PyErr_Occurred()) SWIG_fail;
9927 }
9928 {
9929 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9930 }
9931 return resultobj;
9932 fail:
9933 return NULL;
9934 }
9935
9936
9937 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj;
9939 unsigned long arg1 = (unsigned long) 0 ;
9940 wxString result;
9941 PyObject * obj0 = 0 ;
9942 char *kwnames[] = {
9943 (char *) "nErrCode", NULL
9944 };
9945
9946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9947 if (obj0) {
9948 {
9949 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9950 if (SWIG_arg_fail(1)) SWIG_fail;
9951 }
9952 }
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 result = wxSysErrorMsg(arg1);
9956
9957 wxPyEndAllowThreads(__tstate);
9958 if (PyErr_Occurred()) SWIG_fail;
9959 }
9960 {
9961 #if wxUSE_UNICODE
9962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9963 #else
9964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9965 #endif
9966 }
9967 return resultobj;
9968 fail:
9969 return NULL;
9970 }
9971
9972
9973 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9974 PyObject *resultobj;
9975 wxString *arg1 = 0 ;
9976 bool temp1 = false ;
9977 PyObject * obj0 = 0 ;
9978 char *kwnames[] = {
9979 (char *) "msg", NULL
9980 };
9981
9982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9983 {
9984 arg1 = wxString_in_helper(obj0);
9985 if (arg1 == NULL) SWIG_fail;
9986 temp1 = true;
9987 }
9988 {
9989 PyThreadState* __tstate = wxPyBeginAllowThreads();
9990 wxPyLogFatalError((wxString const &)*arg1);
9991
9992 wxPyEndAllowThreads(__tstate);
9993 if (PyErr_Occurred()) SWIG_fail;
9994 }
9995 Py_INCREF(Py_None); resultobj = Py_None;
9996 {
9997 if (temp1)
9998 delete arg1;
9999 }
10000 return resultobj;
10001 fail:
10002 {
10003 if (temp1)
10004 delete arg1;
10005 }
10006 return NULL;
10007 }
10008
10009
10010 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10011 PyObject *resultobj;
10012 wxString *arg1 = 0 ;
10013 bool temp1 = false ;
10014 PyObject * obj0 = 0 ;
10015 char *kwnames[] = {
10016 (char *) "msg", NULL
10017 };
10018
10019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10020 {
10021 arg1 = wxString_in_helper(obj0);
10022 if (arg1 == NULL) SWIG_fail;
10023 temp1 = true;
10024 }
10025 {
10026 PyThreadState* __tstate = wxPyBeginAllowThreads();
10027 wxPyLogError((wxString const &)*arg1);
10028
10029 wxPyEndAllowThreads(__tstate);
10030 if (PyErr_Occurred()) SWIG_fail;
10031 }
10032 Py_INCREF(Py_None); resultobj = Py_None;
10033 {
10034 if (temp1)
10035 delete arg1;
10036 }
10037 return resultobj;
10038 fail:
10039 {
10040 if (temp1)
10041 delete arg1;
10042 }
10043 return NULL;
10044 }
10045
10046
10047 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10048 PyObject *resultobj;
10049 wxString *arg1 = 0 ;
10050 bool temp1 = false ;
10051 PyObject * obj0 = 0 ;
10052 char *kwnames[] = {
10053 (char *) "msg", NULL
10054 };
10055
10056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10057 {
10058 arg1 = wxString_in_helper(obj0);
10059 if (arg1 == NULL) SWIG_fail;
10060 temp1 = true;
10061 }
10062 {
10063 PyThreadState* __tstate = wxPyBeginAllowThreads();
10064 wxPyLogWarning((wxString const &)*arg1);
10065
10066 wxPyEndAllowThreads(__tstate);
10067 if (PyErr_Occurred()) SWIG_fail;
10068 }
10069 Py_INCREF(Py_None); resultobj = Py_None;
10070 {
10071 if (temp1)
10072 delete arg1;
10073 }
10074 return resultobj;
10075 fail:
10076 {
10077 if (temp1)
10078 delete arg1;
10079 }
10080 return NULL;
10081 }
10082
10083
10084 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10085 PyObject *resultobj;
10086 wxString *arg1 = 0 ;
10087 bool temp1 = false ;
10088 PyObject * obj0 = 0 ;
10089 char *kwnames[] = {
10090 (char *) "msg", NULL
10091 };
10092
10093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10094 {
10095 arg1 = wxString_in_helper(obj0);
10096 if (arg1 == NULL) SWIG_fail;
10097 temp1 = true;
10098 }
10099 {
10100 PyThreadState* __tstate = wxPyBeginAllowThreads();
10101 wxPyLogMessage((wxString const &)*arg1);
10102
10103 wxPyEndAllowThreads(__tstate);
10104 if (PyErr_Occurred()) SWIG_fail;
10105 }
10106 Py_INCREF(Py_None); resultobj = Py_None;
10107 {
10108 if (temp1)
10109 delete arg1;
10110 }
10111 return resultobj;
10112 fail:
10113 {
10114 if (temp1)
10115 delete arg1;
10116 }
10117 return NULL;
10118 }
10119
10120
10121 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10122 PyObject *resultobj;
10123 wxString *arg1 = 0 ;
10124 bool temp1 = false ;
10125 PyObject * obj0 = 0 ;
10126 char *kwnames[] = {
10127 (char *) "msg", NULL
10128 };
10129
10130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10131 {
10132 arg1 = wxString_in_helper(obj0);
10133 if (arg1 == NULL) SWIG_fail;
10134 temp1 = true;
10135 }
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 wxPyLogInfo((wxString const &)*arg1);
10139
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 Py_INCREF(Py_None); resultobj = Py_None;
10144 {
10145 if (temp1)
10146 delete arg1;
10147 }
10148 return resultobj;
10149 fail:
10150 {
10151 if (temp1)
10152 delete arg1;
10153 }
10154 return NULL;
10155 }
10156
10157
10158 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj;
10160 wxString *arg1 = 0 ;
10161 bool temp1 = false ;
10162 PyObject * obj0 = 0 ;
10163 char *kwnames[] = {
10164 (char *) "msg", NULL
10165 };
10166
10167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10168 {
10169 arg1 = wxString_in_helper(obj0);
10170 if (arg1 == NULL) SWIG_fail;
10171 temp1 = true;
10172 }
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 wxPyLogDebug((wxString const &)*arg1);
10176
10177 wxPyEndAllowThreads(__tstate);
10178 if (PyErr_Occurred()) SWIG_fail;
10179 }
10180 Py_INCREF(Py_None); resultobj = Py_None;
10181 {
10182 if (temp1)
10183 delete arg1;
10184 }
10185 return resultobj;
10186 fail:
10187 {
10188 if (temp1)
10189 delete arg1;
10190 }
10191 return NULL;
10192 }
10193
10194
10195 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10196 PyObject *resultobj;
10197 wxString *arg1 = 0 ;
10198 bool temp1 = false ;
10199 PyObject * obj0 = 0 ;
10200 char *kwnames[] = {
10201 (char *) "msg", NULL
10202 };
10203
10204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10205 {
10206 arg1 = wxString_in_helper(obj0);
10207 if (arg1 == NULL) SWIG_fail;
10208 temp1 = true;
10209 }
10210 {
10211 PyThreadState* __tstate = wxPyBeginAllowThreads();
10212 wxPyLogVerbose((wxString const &)*arg1);
10213
10214 wxPyEndAllowThreads(__tstate);
10215 if (PyErr_Occurred()) SWIG_fail;
10216 }
10217 Py_INCREF(Py_None); resultobj = Py_None;
10218 {
10219 if (temp1)
10220 delete arg1;
10221 }
10222 return resultobj;
10223 fail:
10224 {
10225 if (temp1)
10226 delete arg1;
10227 }
10228 return NULL;
10229 }
10230
10231
10232 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10233 PyObject *resultobj;
10234 wxString *arg1 = 0 ;
10235 bool temp1 = false ;
10236 PyObject * obj0 = 0 ;
10237 char *kwnames[] = {
10238 (char *) "msg", NULL
10239 };
10240
10241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10242 {
10243 arg1 = wxString_in_helper(obj0);
10244 if (arg1 == NULL) SWIG_fail;
10245 temp1 = true;
10246 }
10247 {
10248 PyThreadState* __tstate = wxPyBeginAllowThreads();
10249 wxPyLogStatus((wxString const &)*arg1);
10250
10251 wxPyEndAllowThreads(__tstate);
10252 if (PyErr_Occurred()) SWIG_fail;
10253 }
10254 Py_INCREF(Py_None); resultobj = Py_None;
10255 {
10256 if (temp1)
10257 delete arg1;
10258 }
10259 return resultobj;
10260 fail:
10261 {
10262 if (temp1)
10263 delete arg1;
10264 }
10265 return NULL;
10266 }
10267
10268
10269 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10270 PyObject *resultobj;
10271 wxFrame *arg1 = (wxFrame *) 0 ;
10272 wxString *arg2 = 0 ;
10273 bool temp2 = false ;
10274 PyObject * obj0 = 0 ;
10275 PyObject * obj1 = 0 ;
10276 char *kwnames[] = {
10277 (char *) "pFrame",(char *) "msg", NULL
10278 };
10279
10280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10282 if (SWIG_arg_fail(1)) SWIG_fail;
10283 {
10284 arg2 = wxString_in_helper(obj1);
10285 if (arg2 == NULL) SWIG_fail;
10286 temp2 = true;
10287 }
10288 {
10289 PyThreadState* __tstate = wxPyBeginAllowThreads();
10290 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10291
10292 wxPyEndAllowThreads(__tstate);
10293 if (PyErr_Occurred()) SWIG_fail;
10294 }
10295 Py_INCREF(Py_None); resultobj = Py_None;
10296 {
10297 if (temp2)
10298 delete arg2;
10299 }
10300 return resultobj;
10301 fail:
10302 {
10303 if (temp2)
10304 delete arg2;
10305 }
10306 return NULL;
10307 }
10308
10309
10310 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10311 PyObject *resultobj;
10312 wxString *arg1 = 0 ;
10313 bool temp1 = false ;
10314 PyObject * obj0 = 0 ;
10315 char *kwnames[] = {
10316 (char *) "msg", NULL
10317 };
10318
10319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10320 {
10321 arg1 = wxString_in_helper(obj0);
10322 if (arg1 == NULL) SWIG_fail;
10323 temp1 = true;
10324 }
10325 {
10326 PyThreadState* __tstate = wxPyBeginAllowThreads();
10327 wxPyLogSysError((wxString const &)*arg1);
10328
10329 wxPyEndAllowThreads(__tstate);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 Py_INCREF(Py_None); resultobj = Py_None;
10333 {
10334 if (temp1)
10335 delete arg1;
10336 }
10337 return resultobj;
10338 fail:
10339 {
10340 if (temp1)
10341 delete arg1;
10342 }
10343 return NULL;
10344 }
10345
10346
10347 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10348 PyObject *resultobj;
10349 unsigned long arg1 ;
10350 wxString *arg2 = 0 ;
10351 bool temp2 = false ;
10352 PyObject * obj0 = 0 ;
10353 PyObject * obj1 = 0 ;
10354 char *kwnames[] = {
10355 (char *) "level",(char *) "msg", NULL
10356 };
10357
10358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10359 {
10360 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10361 if (SWIG_arg_fail(1)) SWIG_fail;
10362 }
10363 {
10364 arg2 = wxString_in_helper(obj1);
10365 if (arg2 == NULL) SWIG_fail;
10366 temp2 = true;
10367 }
10368 {
10369 PyThreadState* __tstate = wxPyBeginAllowThreads();
10370 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10371
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 Py_INCREF(Py_None); resultobj = Py_None;
10376 {
10377 if (temp2)
10378 delete arg2;
10379 }
10380 return resultobj;
10381 fail:
10382 {
10383 if (temp2)
10384 delete arg2;
10385 }
10386 return NULL;
10387 }
10388
10389
10390 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10391 PyObject *resultobj;
10392 unsigned long arg1 ;
10393 wxString *arg2 = 0 ;
10394 bool temp2 = false ;
10395 PyObject * obj0 = 0 ;
10396 PyObject * obj1 = 0 ;
10397
10398 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10399 {
10400 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10401 if (SWIG_arg_fail(1)) SWIG_fail;
10402 }
10403 {
10404 arg2 = wxString_in_helper(obj1);
10405 if (arg2 == NULL) SWIG_fail;
10406 temp2 = true;
10407 }
10408 {
10409 PyThreadState* __tstate = wxPyBeginAllowThreads();
10410 wxPyLogTrace(arg1,(wxString const &)*arg2);
10411
10412 wxPyEndAllowThreads(__tstate);
10413 if (PyErr_Occurred()) SWIG_fail;
10414 }
10415 Py_INCREF(Py_None); resultobj = Py_None;
10416 {
10417 if (temp2)
10418 delete arg2;
10419 }
10420 return resultobj;
10421 fail:
10422 {
10423 if (temp2)
10424 delete arg2;
10425 }
10426 return NULL;
10427 }
10428
10429
10430 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10431 PyObject *resultobj;
10432 wxString *arg1 = 0 ;
10433 wxString *arg2 = 0 ;
10434 bool temp1 = false ;
10435 bool temp2 = false ;
10436 PyObject * obj0 = 0 ;
10437 PyObject * obj1 = 0 ;
10438
10439 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10440 {
10441 arg1 = wxString_in_helper(obj0);
10442 if (arg1 == NULL) SWIG_fail;
10443 temp1 = true;
10444 }
10445 {
10446 arg2 = wxString_in_helper(obj1);
10447 if (arg2 == NULL) SWIG_fail;
10448 temp2 = true;
10449 }
10450 {
10451 PyThreadState* __tstate = wxPyBeginAllowThreads();
10452 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10453
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 Py_INCREF(Py_None); resultobj = Py_None;
10458 {
10459 if (temp1)
10460 delete arg1;
10461 }
10462 {
10463 if (temp2)
10464 delete arg2;
10465 }
10466 return resultobj;
10467 fail:
10468 {
10469 if (temp1)
10470 delete arg1;
10471 }
10472 {
10473 if (temp2)
10474 delete arg2;
10475 }
10476 return NULL;
10477 }
10478
10479
10480 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10481 int argc;
10482 PyObject *argv[3];
10483 int ii;
10484
10485 argc = PyObject_Length(args);
10486 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10487 argv[ii] = PyTuple_GetItem(args,ii);
10488 }
10489 if (argc == 2) {
10490 int _v;
10491 {
10492 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10493 }
10494 if (_v) {
10495 {
10496 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10497 }
10498 if (_v) {
10499 return _wrap_LogTrace__SWIG_1(self,args);
10500 }
10501 }
10502 }
10503 if (argc == 2) {
10504 int _v;
10505 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10506 if (_v) {
10507 {
10508 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10509 }
10510 if (_v) {
10511 return _wrap_LogTrace__SWIG_0(self,args);
10512 }
10513 }
10514 }
10515
10516 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10517 return NULL;
10518 }
10519
10520
10521 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10522 PyObject *resultobj;
10523 wxString *arg1 = 0 ;
10524 wxString *arg2 = 0 ;
10525 bool temp1 = false ;
10526 bool temp2 = false ;
10527 PyObject * obj0 = 0 ;
10528 PyObject * obj1 = 0 ;
10529 char *kwnames[] = {
10530 (char *) "title",(char *) "text", NULL
10531 };
10532
10533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10534 {
10535 arg1 = wxString_in_helper(obj0);
10536 if (arg1 == NULL) SWIG_fail;
10537 temp1 = true;
10538 }
10539 {
10540 arg2 = wxString_in_helper(obj1);
10541 if (arg2 == NULL) SWIG_fail;
10542 temp2 = true;
10543 }
10544 {
10545 PyThreadState* __tstate = wxPyBeginAllowThreads();
10546 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10547
10548 wxPyEndAllowThreads(__tstate);
10549 if (PyErr_Occurred()) SWIG_fail;
10550 }
10551 Py_INCREF(Py_None); resultobj = Py_None;
10552 {
10553 if (temp1)
10554 delete arg1;
10555 }
10556 {
10557 if (temp2)
10558 delete arg2;
10559 }
10560 return resultobj;
10561 fail:
10562 {
10563 if (temp1)
10564 delete arg1;
10565 }
10566 {
10567 if (temp2)
10568 delete arg2;
10569 }
10570 return NULL;
10571 }
10572
10573
10574 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10575 PyObject *resultobj;
10576 wxLogNull *result;
10577 char *kwnames[] = {
10578 NULL
10579 };
10580
10581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10582 {
10583 PyThreadState* __tstate = wxPyBeginAllowThreads();
10584 result = (wxLogNull *)new wxLogNull();
10585
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10590 return resultobj;
10591 fail:
10592 return NULL;
10593 }
10594
10595
10596 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10597 PyObject *resultobj;
10598 wxLogNull *arg1 = (wxLogNull *) 0 ;
10599 PyObject * obj0 = 0 ;
10600 char *kwnames[] = {
10601 (char *) "self", NULL
10602 };
10603
10604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10606 if (SWIG_arg_fail(1)) SWIG_fail;
10607 {
10608 PyThreadState* __tstate = wxPyBeginAllowThreads();
10609 delete arg1;
10610
10611 wxPyEndAllowThreads(__tstate);
10612 if (PyErr_Occurred()) SWIG_fail;
10613 }
10614 Py_INCREF(Py_None); resultobj = Py_None;
10615 return resultobj;
10616 fail:
10617 return NULL;
10618 }
10619
10620
10621 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10622 PyObject *obj;
10623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10624 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10625 Py_INCREF(obj);
10626 return Py_BuildValue((char *)"");
10627 }
10628 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10629 PyObject *resultobj;
10630 wxPyLog *result;
10631 char *kwnames[] = {
10632 NULL
10633 };
10634
10635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10636 {
10637 PyThreadState* __tstate = wxPyBeginAllowThreads();
10638 result = (wxPyLog *)new wxPyLog();
10639
10640 wxPyEndAllowThreads(__tstate);
10641 if (PyErr_Occurred()) SWIG_fail;
10642 }
10643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj;
10652 wxPyLog *arg1 = (wxPyLog *) 0 ;
10653 PyObject *arg2 = (PyObject *) 0 ;
10654 PyObject *arg3 = (PyObject *) 0 ;
10655 PyObject * obj0 = 0 ;
10656 PyObject * obj1 = 0 ;
10657 PyObject * obj2 = 0 ;
10658 char *kwnames[] = {
10659 (char *) "self",(char *) "self",(char *) "_class", NULL
10660 };
10661
10662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10664 if (SWIG_arg_fail(1)) SWIG_fail;
10665 arg2 = obj1;
10666 arg3 = obj2;
10667 {
10668 PyThreadState* __tstate = wxPyBeginAllowThreads();
10669 (arg1)->_setCallbackInfo(arg2,arg3);
10670
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 Py_INCREF(Py_None); resultobj = Py_None;
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10682 PyObject *obj;
10683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10684 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10685 Py_INCREF(obj);
10686 return Py_BuildValue((char *)"");
10687 }
10688 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10689 PyObject *resultobj;
10690 int arg1 ;
10691 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10692 int arg3 = (int) wxKILL_NOCHILDREN ;
10693 wxKillError result;
10694 PyObject * obj0 = 0 ;
10695 PyObject * obj1 = 0 ;
10696 PyObject * obj2 = 0 ;
10697 char *kwnames[] = {
10698 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10699 };
10700
10701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10702 {
10703 arg1 = (int)(SWIG_As_int(obj0));
10704 if (SWIG_arg_fail(1)) SWIG_fail;
10705 }
10706 if (obj1) {
10707 {
10708 arg2 = (wxSignal)(SWIG_As_int(obj1));
10709 if (SWIG_arg_fail(2)) SWIG_fail;
10710 }
10711 }
10712 if (obj2) {
10713 {
10714 arg3 = (int)(SWIG_As_int(obj2));
10715 if (SWIG_arg_fail(3)) SWIG_fail;
10716 }
10717 }
10718 {
10719 PyThreadState* __tstate = wxPyBeginAllowThreads();
10720 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10721
10722 wxPyEndAllowThreads(__tstate);
10723 if (PyErr_Occurred()) SWIG_fail;
10724 }
10725 resultobj = SWIG_From_int((result));
10726 return resultobj;
10727 fail:
10728 return NULL;
10729 }
10730
10731
10732 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10733 PyObject *resultobj;
10734 int arg1 ;
10735 bool result;
10736 PyObject * obj0 = 0 ;
10737 char *kwnames[] = {
10738 (char *) "pid", NULL
10739 };
10740
10741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10742 {
10743 arg1 = (int)(SWIG_As_int(obj0));
10744 if (SWIG_arg_fail(1)) SWIG_fail;
10745 }
10746 {
10747 PyThreadState* __tstate = wxPyBeginAllowThreads();
10748 result = (bool)wxPyProcess::Exists(arg1);
10749
10750 wxPyEndAllowThreads(__tstate);
10751 if (PyErr_Occurred()) SWIG_fail;
10752 }
10753 {
10754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10755 }
10756 return resultobj;
10757 fail:
10758 return NULL;
10759 }
10760
10761
10762 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10763 PyObject *resultobj;
10764 wxString *arg1 = 0 ;
10765 int arg2 = (int) wxEXEC_ASYNC ;
10766 wxPyProcess *result;
10767 bool temp1 = false ;
10768 PyObject * obj0 = 0 ;
10769 PyObject * obj1 = 0 ;
10770 char *kwnames[] = {
10771 (char *) "cmd",(char *) "flags", NULL
10772 };
10773
10774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10775 {
10776 arg1 = wxString_in_helper(obj0);
10777 if (arg1 == NULL) SWIG_fail;
10778 temp1 = true;
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 *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10789
10790 wxPyEndAllowThreads(__tstate);
10791 if (PyErr_Occurred()) SWIG_fail;
10792 }
10793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10794 {
10795 if (temp1)
10796 delete arg1;
10797 }
10798 return resultobj;
10799 fail:
10800 {
10801 if (temp1)
10802 delete arg1;
10803 }
10804 return NULL;
10805 }
10806
10807
10808 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10809 PyObject *resultobj;
10810 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10811 int arg2 = (int) -1 ;
10812 wxPyProcess *result;
10813 PyObject * obj0 = 0 ;
10814 PyObject * obj1 = 0 ;
10815 char *kwnames[] = {
10816 (char *) "parent",(char *) "id", NULL
10817 };
10818
10819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10820 if (obj0) {
10821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10822 if (SWIG_arg_fail(1)) SWIG_fail;
10823 }
10824 if (obj1) {
10825 {
10826 arg2 = (int)(SWIG_As_int(obj1));
10827 if (SWIG_arg_fail(2)) SWIG_fail;
10828 }
10829 }
10830 {
10831 PyThreadState* __tstate = wxPyBeginAllowThreads();
10832 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10833
10834 wxPyEndAllowThreads(__tstate);
10835 if (PyErr_Occurred()) SWIG_fail;
10836 }
10837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10838 return resultobj;
10839 fail:
10840 return NULL;
10841 }
10842
10843
10844 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10845 PyObject *resultobj;
10846 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10847 PyObject *arg2 = (PyObject *) 0 ;
10848 PyObject *arg3 = (PyObject *) 0 ;
10849 PyObject * obj0 = 0 ;
10850 PyObject * obj1 = 0 ;
10851 PyObject * obj2 = 0 ;
10852 char *kwnames[] = {
10853 (char *) "self",(char *) "self",(char *) "_class", NULL
10854 };
10855
10856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10858 if (SWIG_arg_fail(1)) SWIG_fail;
10859 arg2 = obj1;
10860 arg3 = obj2;
10861 {
10862 PyThreadState* __tstate = wxPyBeginAllowThreads();
10863 (arg1)->_setCallbackInfo(arg2,arg3);
10864
10865 wxPyEndAllowThreads(__tstate);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 Py_INCREF(Py_None); resultobj = Py_None;
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj;
10877 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10878 int arg2 ;
10879 int arg3 ;
10880 PyObject * obj0 = 0 ;
10881 PyObject * obj1 = 0 ;
10882 PyObject * obj2 = 0 ;
10883 char *kwnames[] = {
10884 (char *) "self",(char *) "pid",(char *) "status", NULL
10885 };
10886
10887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10889 if (SWIG_arg_fail(1)) SWIG_fail;
10890 {
10891 arg2 = (int)(SWIG_As_int(obj1));
10892 if (SWIG_arg_fail(2)) SWIG_fail;
10893 }
10894 {
10895 arg3 = (int)(SWIG_As_int(obj2));
10896 if (SWIG_arg_fail(3)) SWIG_fail;
10897 }
10898 {
10899 PyThreadState* __tstate = wxPyBeginAllowThreads();
10900 (arg1)->base_OnTerminate(arg2,arg3);
10901
10902 wxPyEndAllowThreads(__tstate);
10903 if (PyErr_Occurred()) SWIG_fail;
10904 }
10905 Py_INCREF(Py_None); resultobj = Py_None;
10906 return resultobj;
10907 fail:
10908 return NULL;
10909 }
10910
10911
10912 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10913 PyObject *resultobj;
10914 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10915 PyObject * obj0 = 0 ;
10916 char *kwnames[] = {
10917 (char *) "self", NULL
10918 };
10919
10920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10922 if (SWIG_arg_fail(1)) SWIG_fail;
10923 {
10924 PyThreadState* __tstate = wxPyBeginAllowThreads();
10925 (arg1)->Redirect();
10926
10927 wxPyEndAllowThreads(__tstate);
10928 if (PyErr_Occurred()) SWIG_fail;
10929 }
10930 Py_INCREF(Py_None); resultobj = Py_None;
10931 return resultobj;
10932 fail:
10933 return NULL;
10934 }
10935
10936
10937 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10938 PyObject *resultobj;
10939 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10940 bool result;
10941 PyObject * obj0 = 0 ;
10942 char *kwnames[] = {
10943 (char *) "self", NULL
10944 };
10945
10946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10948 if (SWIG_arg_fail(1)) SWIG_fail;
10949 {
10950 PyThreadState* __tstate = wxPyBeginAllowThreads();
10951 result = (bool)(arg1)->IsRedirected();
10952
10953 wxPyEndAllowThreads(__tstate);
10954 if (PyErr_Occurred()) SWIG_fail;
10955 }
10956 {
10957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10958 }
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10966 PyObject *resultobj;
10967 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10968 PyObject * obj0 = 0 ;
10969 char *kwnames[] = {
10970 (char *) "self", NULL
10971 };
10972
10973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10975 if (SWIG_arg_fail(1)) SWIG_fail;
10976 {
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 (arg1)->Detach();
10979
10980 wxPyEndAllowThreads(__tstate);
10981 if (PyErr_Occurred()) SWIG_fail;
10982 }
10983 Py_INCREF(Py_None); resultobj = Py_None;
10984 return resultobj;
10985 fail:
10986 return NULL;
10987 }
10988
10989
10990 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj;
10992 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10993 wxInputStream *result;
10994 PyObject * obj0 = 0 ;
10995 char *kwnames[] = {
10996 (char *) "self", NULL
10997 };
10998
10999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11001 if (SWIG_arg_fail(1)) SWIG_fail;
11002 {
11003 PyThreadState* __tstate = wxPyBeginAllowThreads();
11004 result = (wxInputStream *)(arg1)->GetInputStream();
11005
11006 wxPyEndAllowThreads(__tstate);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 {
11010 wxPyInputStream * _ptr = NULL;
11011
11012 if (result) {
11013 _ptr = new wxPyInputStream(result);
11014 }
11015 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11016 }
11017 return resultobj;
11018 fail:
11019 return NULL;
11020 }
11021
11022
11023 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11024 PyObject *resultobj;
11025 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11026 wxInputStream *result;
11027 PyObject * obj0 = 0 ;
11028 char *kwnames[] = {
11029 (char *) "self", NULL
11030 };
11031
11032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11034 if (SWIG_arg_fail(1)) SWIG_fail;
11035 {
11036 PyThreadState* __tstate = wxPyBeginAllowThreads();
11037 result = (wxInputStream *)(arg1)->GetErrorStream();
11038
11039 wxPyEndAllowThreads(__tstate);
11040 if (PyErr_Occurred()) SWIG_fail;
11041 }
11042 {
11043 wxPyInputStream * _ptr = NULL;
11044
11045 if (result) {
11046 _ptr = new wxPyInputStream(result);
11047 }
11048 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11049 }
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj;
11058 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11059 wxOutputStream *result;
11060 PyObject * obj0 = 0 ;
11061 char *kwnames[] = {
11062 (char *) "self", NULL
11063 };
11064
11065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11067 if (SWIG_arg_fail(1)) SWIG_fail;
11068 {
11069 PyThreadState* __tstate = wxPyBeginAllowThreads();
11070 result = (wxOutputStream *)(arg1)->GetOutputStream();
11071
11072 wxPyEndAllowThreads(__tstate);
11073 if (PyErr_Occurred()) SWIG_fail;
11074 }
11075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11076 return resultobj;
11077 fail:
11078 return NULL;
11079 }
11080
11081
11082 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11083 PyObject *resultobj;
11084 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11085 PyObject * obj0 = 0 ;
11086 char *kwnames[] = {
11087 (char *) "self", NULL
11088 };
11089
11090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11092 if (SWIG_arg_fail(1)) SWIG_fail;
11093 {
11094 PyThreadState* __tstate = wxPyBeginAllowThreads();
11095 (arg1)->CloseOutput();
11096
11097 wxPyEndAllowThreads(__tstate);
11098 if (PyErr_Occurred()) SWIG_fail;
11099 }
11100 Py_INCREF(Py_None); resultobj = Py_None;
11101 return resultobj;
11102 fail:
11103 return NULL;
11104 }
11105
11106
11107 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11108 PyObject *resultobj;
11109 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11110 bool result;
11111 PyObject * obj0 = 0 ;
11112 char *kwnames[] = {
11113 (char *) "self", NULL
11114 };
11115
11116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11118 if (SWIG_arg_fail(1)) SWIG_fail;
11119 {
11120 PyThreadState* __tstate = wxPyBeginAllowThreads();
11121 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11122
11123 wxPyEndAllowThreads(__tstate);
11124 if (PyErr_Occurred()) SWIG_fail;
11125 }
11126 {
11127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11128 }
11129 return resultobj;
11130 fail:
11131 return NULL;
11132 }
11133
11134
11135 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11136 PyObject *resultobj;
11137 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11138 bool result;
11139 PyObject * obj0 = 0 ;
11140 char *kwnames[] = {
11141 (char *) "self", NULL
11142 };
11143
11144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11146 if (SWIG_arg_fail(1)) SWIG_fail;
11147 {
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11150
11151 wxPyEndAllowThreads(__tstate);
11152 if (PyErr_Occurred()) SWIG_fail;
11153 }
11154 {
11155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11156 }
11157 return resultobj;
11158 fail:
11159 return NULL;
11160 }
11161
11162
11163 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11164 PyObject *resultobj;
11165 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11166 bool result;
11167 PyObject * obj0 = 0 ;
11168 char *kwnames[] = {
11169 (char *) "self", NULL
11170 };
11171
11172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11174 if (SWIG_arg_fail(1)) SWIG_fail;
11175 {
11176 PyThreadState* __tstate = wxPyBeginAllowThreads();
11177 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11178
11179 wxPyEndAllowThreads(__tstate);
11180 if (PyErr_Occurred()) SWIG_fail;
11181 }
11182 {
11183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11184 }
11185 return resultobj;
11186 fail:
11187 return NULL;
11188 }
11189
11190
11191 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11192 PyObject *obj;
11193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11194 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11195 Py_INCREF(obj);
11196 return Py_BuildValue((char *)"");
11197 }
11198 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11199 PyObject *resultobj;
11200 int arg1 = (int) 0 ;
11201 int arg2 = (int) 0 ;
11202 int arg3 = (int) 0 ;
11203 wxProcessEvent *result;
11204 PyObject * obj0 = 0 ;
11205 PyObject * obj1 = 0 ;
11206 PyObject * obj2 = 0 ;
11207 char *kwnames[] = {
11208 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11209 };
11210
11211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11212 if (obj0) {
11213 {
11214 arg1 = (int)(SWIG_As_int(obj0));
11215 if (SWIG_arg_fail(1)) SWIG_fail;
11216 }
11217 }
11218 if (obj1) {
11219 {
11220 arg2 = (int)(SWIG_As_int(obj1));
11221 if (SWIG_arg_fail(2)) SWIG_fail;
11222 }
11223 }
11224 if (obj2) {
11225 {
11226 arg3 = (int)(SWIG_As_int(obj2));
11227 if (SWIG_arg_fail(3)) SWIG_fail;
11228 }
11229 }
11230 {
11231 PyThreadState* __tstate = wxPyBeginAllowThreads();
11232 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11233
11234 wxPyEndAllowThreads(__tstate);
11235 if (PyErr_Occurred()) SWIG_fail;
11236 }
11237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11238 return resultobj;
11239 fail:
11240 return NULL;
11241 }
11242
11243
11244 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11245 PyObject *resultobj;
11246 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11247 int result;
11248 PyObject * obj0 = 0 ;
11249 char *kwnames[] = {
11250 (char *) "self", NULL
11251 };
11252
11253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11255 if (SWIG_arg_fail(1)) SWIG_fail;
11256 {
11257 PyThreadState* __tstate = wxPyBeginAllowThreads();
11258 result = (int)(arg1)->GetPid();
11259
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 {
11264 resultobj = SWIG_From_int((int)(result));
11265 }
11266 return resultobj;
11267 fail:
11268 return NULL;
11269 }
11270
11271
11272 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11273 PyObject *resultobj;
11274 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11275 int result;
11276 PyObject * obj0 = 0 ;
11277 char *kwnames[] = {
11278 (char *) "self", NULL
11279 };
11280
11281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11283 if (SWIG_arg_fail(1)) SWIG_fail;
11284 {
11285 PyThreadState* __tstate = wxPyBeginAllowThreads();
11286 result = (int)(arg1)->GetExitCode();
11287
11288 wxPyEndAllowThreads(__tstate);
11289 if (PyErr_Occurred()) SWIG_fail;
11290 }
11291 {
11292 resultobj = SWIG_From_int((int)(result));
11293 }
11294 return resultobj;
11295 fail:
11296 return NULL;
11297 }
11298
11299
11300 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11301 PyObject *resultobj;
11302 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11303 int arg2 ;
11304 PyObject * obj0 = 0 ;
11305 PyObject * obj1 = 0 ;
11306 char *kwnames[] = {
11307 (char *) "self",(char *) "m_pid", NULL
11308 };
11309
11310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11312 if (SWIG_arg_fail(1)) SWIG_fail;
11313 {
11314 arg2 = (int)(SWIG_As_int(obj1));
11315 if (SWIG_arg_fail(2)) SWIG_fail;
11316 }
11317 if (arg1) (arg1)->m_pid = arg2;
11318
11319 Py_INCREF(Py_None); resultobj = Py_None;
11320 return resultobj;
11321 fail:
11322 return NULL;
11323 }
11324
11325
11326 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11327 PyObject *resultobj;
11328 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11329 int result;
11330 PyObject * obj0 = 0 ;
11331 char *kwnames[] = {
11332 (char *) "self", NULL
11333 };
11334
11335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11337 if (SWIG_arg_fail(1)) SWIG_fail;
11338 result = (int) ((arg1)->m_pid);
11339
11340 {
11341 resultobj = SWIG_From_int((int)(result));
11342 }
11343 return resultobj;
11344 fail:
11345 return NULL;
11346 }
11347
11348
11349 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11350 PyObject *resultobj;
11351 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11352 int arg2 ;
11353 PyObject * obj0 = 0 ;
11354 PyObject * obj1 = 0 ;
11355 char *kwnames[] = {
11356 (char *) "self",(char *) "m_exitcode", NULL
11357 };
11358
11359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11361 if (SWIG_arg_fail(1)) SWIG_fail;
11362 {
11363 arg2 = (int)(SWIG_As_int(obj1));
11364 if (SWIG_arg_fail(2)) SWIG_fail;
11365 }
11366 if (arg1) (arg1)->m_exitcode = arg2;
11367
11368 Py_INCREF(Py_None); resultobj = Py_None;
11369 return resultobj;
11370 fail:
11371 return NULL;
11372 }
11373
11374
11375 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11376 PyObject *resultobj;
11377 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11378 int result;
11379 PyObject * obj0 = 0 ;
11380 char *kwnames[] = {
11381 (char *) "self", NULL
11382 };
11383
11384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11386 if (SWIG_arg_fail(1)) SWIG_fail;
11387 result = (int) ((arg1)->m_exitcode);
11388
11389 {
11390 resultobj = SWIG_From_int((int)(result));
11391 }
11392 return resultobj;
11393 fail:
11394 return NULL;
11395 }
11396
11397
11398 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11399 PyObject *obj;
11400 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11401 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11402 Py_INCREF(obj);
11403 return Py_BuildValue((char *)"");
11404 }
11405 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11406 PyObject *resultobj;
11407 wxString *arg1 = 0 ;
11408 int arg2 = (int) wxEXEC_ASYNC ;
11409 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11410 long result;
11411 bool temp1 = false ;
11412 PyObject * obj0 = 0 ;
11413 PyObject * obj1 = 0 ;
11414 PyObject * obj2 = 0 ;
11415 char *kwnames[] = {
11416 (char *) "command",(char *) "flags",(char *) "process", NULL
11417 };
11418
11419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11420 {
11421 arg1 = wxString_in_helper(obj0);
11422 if (arg1 == NULL) SWIG_fail;
11423 temp1 = true;
11424 }
11425 if (obj1) {
11426 {
11427 arg2 = (int)(SWIG_As_int(obj1));
11428 if (SWIG_arg_fail(2)) SWIG_fail;
11429 }
11430 }
11431 if (obj2) {
11432 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11433 if (SWIG_arg_fail(3)) SWIG_fail;
11434 }
11435 {
11436 if (!wxPyCheckForApp()) SWIG_fail;
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11439
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 {
11444 resultobj = SWIG_From_long((long)(result));
11445 }
11446 {
11447 if (temp1)
11448 delete arg1;
11449 }
11450 return resultobj;
11451 fail:
11452 {
11453 if (temp1)
11454 delete arg1;
11455 }
11456 return NULL;
11457 }
11458
11459
11460 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11461 PyObject *resultobj;
11462 long arg1 ;
11463 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11464 wxKillError *arg3 = (wxKillError *) 0 ;
11465 int arg4 = (int) wxKILL_NOCHILDREN ;
11466 int result;
11467 wxKillError temp3 ;
11468 PyObject * obj0 = 0 ;
11469 PyObject * obj1 = 0 ;
11470 PyObject * obj2 = 0 ;
11471 char *kwnames[] = {
11472 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11473 };
11474
11475 {
11476 arg3 = &temp3;
11477 }
11478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11479 {
11480 arg1 = (long)(SWIG_As_long(obj0));
11481 if (SWIG_arg_fail(1)) SWIG_fail;
11482 }
11483 if (obj1) {
11484 {
11485 arg2 = (wxSignal)(SWIG_As_int(obj1));
11486 if (SWIG_arg_fail(2)) SWIG_fail;
11487 }
11488 }
11489 if (obj2) {
11490 {
11491 arg4 = (int)(SWIG_As_int(obj2));
11492 if (SWIG_arg_fail(4)) SWIG_fail;
11493 }
11494 }
11495 {
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11498
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 {
11503 resultobj = SWIG_From_int((int)(result));
11504 }
11505 {
11506 PyObject* o;
11507 o = PyInt_FromLong((long) (*arg3));
11508 resultobj = t_output_helper(resultobj, o);
11509 }
11510 return resultobj;
11511 fail:
11512 return NULL;
11513 }
11514
11515
11516 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11517 PyObject *resultobj;
11518 int arg1 = (int) wxJOYSTICK1 ;
11519 wxJoystick *result;
11520 PyObject * obj0 = 0 ;
11521 char *kwnames[] = {
11522 (char *) "joystick", NULL
11523 };
11524
11525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11526 if (obj0) {
11527 {
11528 arg1 = (int)(SWIG_As_int(obj0));
11529 if (SWIG_arg_fail(1)) SWIG_fail;
11530 }
11531 }
11532 {
11533 if (!wxPyCheckForApp()) SWIG_fail;
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 result = (wxJoystick *)new wxJoystick(arg1);
11536
11537 wxPyEndAllowThreads(__tstate);
11538 if (PyErr_Occurred()) SWIG_fail;
11539 }
11540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11541 return resultobj;
11542 fail:
11543 return NULL;
11544 }
11545
11546
11547 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11548 PyObject *resultobj;
11549 wxJoystick *arg1 = (wxJoystick *) 0 ;
11550 PyObject * obj0 = 0 ;
11551 char *kwnames[] = {
11552 (char *) "self", NULL
11553 };
11554
11555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11557 if (SWIG_arg_fail(1)) SWIG_fail;
11558 {
11559 PyThreadState* __tstate = wxPyBeginAllowThreads();
11560 delete arg1;
11561
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 Py_INCREF(Py_None); resultobj = Py_None;
11566 return resultobj;
11567 fail:
11568 return NULL;
11569 }
11570
11571
11572 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11573 PyObject *resultobj;
11574 wxJoystick *arg1 = (wxJoystick *) 0 ;
11575 wxPoint result;
11576 PyObject * obj0 = 0 ;
11577 char *kwnames[] = {
11578 (char *) "self", NULL
11579 };
11580
11581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11583 if (SWIG_arg_fail(1)) SWIG_fail;
11584 {
11585 PyThreadState* __tstate = wxPyBeginAllowThreads();
11586 result = (arg1)->GetPosition();
11587
11588 wxPyEndAllowThreads(__tstate);
11589 if (PyErr_Occurred()) SWIG_fail;
11590 }
11591 {
11592 wxPoint * resultptr;
11593 resultptr = new wxPoint((wxPoint &)(result));
11594 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11595 }
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11603 PyObject *resultobj;
11604 wxJoystick *arg1 = (wxJoystick *) 0 ;
11605 int result;
11606 PyObject * obj0 = 0 ;
11607 char *kwnames[] = {
11608 (char *) "self", NULL
11609 };
11610
11611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11613 if (SWIG_arg_fail(1)) SWIG_fail;
11614 {
11615 PyThreadState* __tstate = wxPyBeginAllowThreads();
11616 result = (int)(arg1)->GetZPosition();
11617
11618 wxPyEndAllowThreads(__tstate);
11619 if (PyErr_Occurred()) SWIG_fail;
11620 }
11621 {
11622 resultobj = SWIG_From_int((int)(result));
11623 }
11624 return resultobj;
11625 fail:
11626 return NULL;
11627 }
11628
11629
11630 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11631 PyObject *resultobj;
11632 wxJoystick *arg1 = (wxJoystick *) 0 ;
11633 int result;
11634 PyObject * obj0 = 0 ;
11635 char *kwnames[] = {
11636 (char *) "self", NULL
11637 };
11638
11639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11641 if (SWIG_arg_fail(1)) SWIG_fail;
11642 {
11643 PyThreadState* __tstate = wxPyBeginAllowThreads();
11644 result = (int)(arg1)->GetButtonState();
11645
11646 wxPyEndAllowThreads(__tstate);
11647 if (PyErr_Occurred()) SWIG_fail;
11648 }
11649 {
11650 resultobj = SWIG_From_int((int)(result));
11651 }
11652 return resultobj;
11653 fail:
11654 return NULL;
11655 }
11656
11657
11658 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11659 PyObject *resultobj;
11660 wxJoystick *arg1 = (wxJoystick *) 0 ;
11661 int result;
11662 PyObject * obj0 = 0 ;
11663 char *kwnames[] = {
11664 (char *) "self", NULL
11665 };
11666
11667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11669 if (SWIG_arg_fail(1)) SWIG_fail;
11670 {
11671 PyThreadState* __tstate = wxPyBeginAllowThreads();
11672 result = (int)(arg1)->GetPOVPosition();
11673
11674 wxPyEndAllowThreads(__tstate);
11675 if (PyErr_Occurred()) SWIG_fail;
11676 }
11677 {
11678 resultobj = SWIG_From_int((int)(result));
11679 }
11680 return resultobj;
11681 fail:
11682 return NULL;
11683 }
11684
11685
11686 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11687 PyObject *resultobj;
11688 wxJoystick *arg1 = (wxJoystick *) 0 ;
11689 int result;
11690 PyObject * obj0 = 0 ;
11691 char *kwnames[] = {
11692 (char *) "self", NULL
11693 };
11694
11695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11697 if (SWIG_arg_fail(1)) SWIG_fail;
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 result = (int)(arg1)->GetPOVCTSPosition();
11701
11702 wxPyEndAllowThreads(__tstate);
11703 if (PyErr_Occurred()) SWIG_fail;
11704 }
11705 {
11706 resultobj = SWIG_From_int((int)(result));
11707 }
11708 return resultobj;
11709 fail:
11710 return NULL;
11711 }
11712
11713
11714 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11715 PyObject *resultobj;
11716 wxJoystick *arg1 = (wxJoystick *) 0 ;
11717 int result;
11718 PyObject * obj0 = 0 ;
11719 char *kwnames[] = {
11720 (char *) "self", NULL
11721 };
11722
11723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11725 if (SWIG_arg_fail(1)) SWIG_fail;
11726 {
11727 PyThreadState* __tstate = wxPyBeginAllowThreads();
11728 result = (int)(arg1)->GetRudderPosition();
11729
11730 wxPyEndAllowThreads(__tstate);
11731 if (PyErr_Occurred()) SWIG_fail;
11732 }
11733 {
11734 resultobj = SWIG_From_int((int)(result));
11735 }
11736 return resultobj;
11737 fail:
11738 return NULL;
11739 }
11740
11741
11742 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11743 PyObject *resultobj;
11744 wxJoystick *arg1 = (wxJoystick *) 0 ;
11745 int result;
11746 PyObject * obj0 = 0 ;
11747 char *kwnames[] = {
11748 (char *) "self", NULL
11749 };
11750
11751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11753 if (SWIG_arg_fail(1)) SWIG_fail;
11754 {
11755 PyThreadState* __tstate = wxPyBeginAllowThreads();
11756 result = (int)(arg1)->GetUPosition();
11757
11758 wxPyEndAllowThreads(__tstate);
11759 if (PyErr_Occurred()) SWIG_fail;
11760 }
11761 {
11762 resultobj = SWIG_From_int((int)(result));
11763 }
11764 return resultobj;
11765 fail:
11766 return NULL;
11767 }
11768
11769
11770 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11771 PyObject *resultobj;
11772 wxJoystick *arg1 = (wxJoystick *) 0 ;
11773 int result;
11774 PyObject * obj0 = 0 ;
11775 char *kwnames[] = {
11776 (char *) "self", NULL
11777 };
11778
11779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11781 if (SWIG_arg_fail(1)) SWIG_fail;
11782 {
11783 PyThreadState* __tstate = wxPyBeginAllowThreads();
11784 result = (int)(arg1)->GetVPosition();
11785
11786 wxPyEndAllowThreads(__tstate);
11787 if (PyErr_Occurred()) SWIG_fail;
11788 }
11789 {
11790 resultobj = SWIG_From_int((int)(result));
11791 }
11792 return resultobj;
11793 fail:
11794 return NULL;
11795 }
11796
11797
11798 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11799 PyObject *resultobj;
11800 wxJoystick *arg1 = (wxJoystick *) 0 ;
11801 int result;
11802 PyObject * obj0 = 0 ;
11803 char *kwnames[] = {
11804 (char *) "self", NULL
11805 };
11806
11807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11809 if (SWIG_arg_fail(1)) SWIG_fail;
11810 {
11811 PyThreadState* __tstate = wxPyBeginAllowThreads();
11812 result = (int)(arg1)->GetMovementThreshold();
11813
11814 wxPyEndAllowThreads(__tstate);
11815 if (PyErr_Occurred()) SWIG_fail;
11816 }
11817 {
11818 resultobj = SWIG_From_int((int)(result));
11819 }
11820 return resultobj;
11821 fail:
11822 return NULL;
11823 }
11824
11825
11826 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11827 PyObject *resultobj;
11828 wxJoystick *arg1 = (wxJoystick *) 0 ;
11829 int arg2 ;
11830 PyObject * obj0 = 0 ;
11831 PyObject * obj1 = 0 ;
11832 char *kwnames[] = {
11833 (char *) "self",(char *) "threshold", NULL
11834 };
11835
11836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11838 if (SWIG_arg_fail(1)) SWIG_fail;
11839 {
11840 arg2 = (int)(SWIG_As_int(obj1));
11841 if (SWIG_arg_fail(2)) SWIG_fail;
11842 }
11843 {
11844 PyThreadState* __tstate = wxPyBeginAllowThreads();
11845 (arg1)->SetMovementThreshold(arg2);
11846
11847 wxPyEndAllowThreads(__tstate);
11848 if (PyErr_Occurred()) SWIG_fail;
11849 }
11850 Py_INCREF(Py_None); resultobj = Py_None;
11851 return resultobj;
11852 fail:
11853 return NULL;
11854 }
11855
11856
11857 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11858 PyObject *resultobj;
11859 wxJoystick *arg1 = (wxJoystick *) 0 ;
11860 bool result;
11861 PyObject * obj0 = 0 ;
11862 char *kwnames[] = {
11863 (char *) "self", NULL
11864 };
11865
11866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11868 if (SWIG_arg_fail(1)) SWIG_fail;
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 result = (bool)(arg1)->IsOk();
11872
11873 wxPyEndAllowThreads(__tstate);
11874 if (PyErr_Occurred()) SWIG_fail;
11875 }
11876 {
11877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11878 }
11879 return resultobj;
11880 fail:
11881 return NULL;
11882 }
11883
11884
11885 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11886 PyObject *resultobj;
11887 wxJoystick *arg1 = (wxJoystick *) 0 ;
11888 int result;
11889 PyObject * obj0 = 0 ;
11890 char *kwnames[] = {
11891 (char *) "self", NULL
11892 };
11893
11894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11896 if (SWIG_arg_fail(1)) SWIG_fail;
11897 {
11898 PyThreadState* __tstate = wxPyBeginAllowThreads();
11899 result = (int)(arg1)->GetNumberJoysticks();
11900
11901 wxPyEndAllowThreads(__tstate);
11902 if (PyErr_Occurred()) SWIG_fail;
11903 }
11904 {
11905 resultobj = SWIG_From_int((int)(result));
11906 }
11907 return resultobj;
11908 fail:
11909 return NULL;
11910 }
11911
11912
11913 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11914 PyObject *resultobj;
11915 wxJoystick *arg1 = (wxJoystick *) 0 ;
11916 int result;
11917 PyObject * obj0 = 0 ;
11918 char *kwnames[] = {
11919 (char *) "self", NULL
11920 };
11921
11922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11924 if (SWIG_arg_fail(1)) SWIG_fail;
11925 {
11926 PyThreadState* __tstate = wxPyBeginAllowThreads();
11927 result = (int)(arg1)->GetManufacturerId();
11928
11929 wxPyEndAllowThreads(__tstate);
11930 if (PyErr_Occurred()) SWIG_fail;
11931 }
11932 {
11933 resultobj = SWIG_From_int((int)(result));
11934 }
11935 return resultobj;
11936 fail:
11937 return NULL;
11938 }
11939
11940
11941 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11942 PyObject *resultobj;
11943 wxJoystick *arg1 = (wxJoystick *) 0 ;
11944 int result;
11945 PyObject * obj0 = 0 ;
11946 char *kwnames[] = {
11947 (char *) "self", NULL
11948 };
11949
11950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11952 if (SWIG_arg_fail(1)) SWIG_fail;
11953 {
11954 PyThreadState* __tstate = wxPyBeginAllowThreads();
11955 result = (int)(arg1)->GetProductId();
11956
11957 wxPyEndAllowThreads(__tstate);
11958 if (PyErr_Occurred()) SWIG_fail;
11959 }
11960 {
11961 resultobj = SWIG_From_int((int)(result));
11962 }
11963 return resultobj;
11964 fail:
11965 return NULL;
11966 }
11967
11968
11969 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11970 PyObject *resultobj;
11971 wxJoystick *arg1 = (wxJoystick *) 0 ;
11972 wxString result;
11973 PyObject * obj0 = 0 ;
11974 char *kwnames[] = {
11975 (char *) "self", NULL
11976 };
11977
11978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11980 if (SWIG_arg_fail(1)) SWIG_fail;
11981 {
11982 PyThreadState* __tstate = wxPyBeginAllowThreads();
11983 result = (arg1)->GetProductName();
11984
11985 wxPyEndAllowThreads(__tstate);
11986 if (PyErr_Occurred()) SWIG_fail;
11987 }
11988 {
11989 #if wxUSE_UNICODE
11990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11991 #else
11992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11993 #endif
11994 }
11995 return resultobj;
11996 fail:
11997 return NULL;
11998 }
11999
12000
12001 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12002 PyObject *resultobj;
12003 wxJoystick *arg1 = (wxJoystick *) 0 ;
12004 int result;
12005 PyObject * obj0 = 0 ;
12006 char *kwnames[] = {
12007 (char *) "self", NULL
12008 };
12009
12010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12012 if (SWIG_arg_fail(1)) SWIG_fail;
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 result = (int)(arg1)->GetXMin();
12016
12017 wxPyEndAllowThreads(__tstate);
12018 if (PyErr_Occurred()) SWIG_fail;
12019 }
12020 {
12021 resultobj = SWIG_From_int((int)(result));
12022 }
12023 return resultobj;
12024 fail:
12025 return NULL;
12026 }
12027
12028
12029 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12030 PyObject *resultobj;
12031 wxJoystick *arg1 = (wxJoystick *) 0 ;
12032 int result;
12033 PyObject * obj0 = 0 ;
12034 char *kwnames[] = {
12035 (char *) "self", NULL
12036 };
12037
12038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12040 if (SWIG_arg_fail(1)) SWIG_fail;
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 result = (int)(arg1)->GetYMin();
12044
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 {
12049 resultobj = SWIG_From_int((int)(result));
12050 }
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj;
12059 wxJoystick *arg1 = (wxJoystick *) 0 ;
12060 int result;
12061 PyObject * obj0 = 0 ;
12062 char *kwnames[] = {
12063 (char *) "self", NULL
12064 };
12065
12066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12068 if (SWIG_arg_fail(1)) SWIG_fail;
12069 {
12070 PyThreadState* __tstate = wxPyBeginAllowThreads();
12071 result = (int)(arg1)->GetZMin();
12072
12073 wxPyEndAllowThreads(__tstate);
12074 if (PyErr_Occurred()) SWIG_fail;
12075 }
12076 {
12077 resultobj = SWIG_From_int((int)(result));
12078 }
12079 return resultobj;
12080 fail:
12081 return NULL;
12082 }
12083
12084
12085 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12086 PyObject *resultobj;
12087 wxJoystick *arg1 = (wxJoystick *) 0 ;
12088 int result;
12089 PyObject * obj0 = 0 ;
12090 char *kwnames[] = {
12091 (char *) "self", NULL
12092 };
12093
12094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12096 if (SWIG_arg_fail(1)) SWIG_fail;
12097 {
12098 PyThreadState* __tstate = wxPyBeginAllowThreads();
12099 result = (int)(arg1)->GetXMax();
12100
12101 wxPyEndAllowThreads(__tstate);
12102 if (PyErr_Occurred()) SWIG_fail;
12103 }
12104 {
12105 resultobj = SWIG_From_int((int)(result));
12106 }
12107 return resultobj;
12108 fail:
12109 return NULL;
12110 }
12111
12112
12113 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12114 PyObject *resultobj;
12115 wxJoystick *arg1 = (wxJoystick *) 0 ;
12116 int result;
12117 PyObject * obj0 = 0 ;
12118 char *kwnames[] = {
12119 (char *) "self", NULL
12120 };
12121
12122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12124 if (SWIG_arg_fail(1)) SWIG_fail;
12125 {
12126 PyThreadState* __tstate = wxPyBeginAllowThreads();
12127 result = (int)(arg1)->GetYMax();
12128
12129 wxPyEndAllowThreads(__tstate);
12130 if (PyErr_Occurred()) SWIG_fail;
12131 }
12132 {
12133 resultobj = SWIG_From_int((int)(result));
12134 }
12135 return resultobj;
12136 fail:
12137 return NULL;
12138 }
12139
12140
12141 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12142 PyObject *resultobj;
12143 wxJoystick *arg1 = (wxJoystick *) 0 ;
12144 int result;
12145 PyObject * obj0 = 0 ;
12146 char *kwnames[] = {
12147 (char *) "self", NULL
12148 };
12149
12150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12152 if (SWIG_arg_fail(1)) SWIG_fail;
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 result = (int)(arg1)->GetZMax();
12156
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 {
12161 resultobj = SWIG_From_int((int)(result));
12162 }
12163 return resultobj;
12164 fail:
12165 return NULL;
12166 }
12167
12168
12169 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12170 PyObject *resultobj;
12171 wxJoystick *arg1 = (wxJoystick *) 0 ;
12172 int result;
12173 PyObject * obj0 = 0 ;
12174 char *kwnames[] = {
12175 (char *) "self", NULL
12176 };
12177
12178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12180 if (SWIG_arg_fail(1)) SWIG_fail;
12181 {
12182 PyThreadState* __tstate = wxPyBeginAllowThreads();
12183 result = (int)(arg1)->GetNumberButtons();
12184
12185 wxPyEndAllowThreads(__tstate);
12186 if (PyErr_Occurred()) SWIG_fail;
12187 }
12188 {
12189 resultobj = SWIG_From_int((int)(result));
12190 }
12191 return resultobj;
12192 fail:
12193 return NULL;
12194 }
12195
12196
12197 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12198 PyObject *resultobj;
12199 wxJoystick *arg1 = (wxJoystick *) 0 ;
12200 int result;
12201 PyObject * obj0 = 0 ;
12202 char *kwnames[] = {
12203 (char *) "self", NULL
12204 };
12205
12206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12208 if (SWIG_arg_fail(1)) SWIG_fail;
12209 {
12210 PyThreadState* __tstate = wxPyBeginAllowThreads();
12211 result = (int)(arg1)->GetNumberAxes();
12212
12213 wxPyEndAllowThreads(__tstate);
12214 if (PyErr_Occurred()) SWIG_fail;
12215 }
12216 {
12217 resultobj = SWIG_From_int((int)(result));
12218 }
12219 return resultobj;
12220 fail:
12221 return NULL;
12222 }
12223
12224
12225 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12226 PyObject *resultobj;
12227 wxJoystick *arg1 = (wxJoystick *) 0 ;
12228 int result;
12229 PyObject * obj0 = 0 ;
12230 char *kwnames[] = {
12231 (char *) "self", NULL
12232 };
12233
12234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12236 if (SWIG_arg_fail(1)) SWIG_fail;
12237 {
12238 PyThreadState* __tstate = wxPyBeginAllowThreads();
12239 result = (int)(arg1)->GetMaxButtons();
12240
12241 wxPyEndAllowThreads(__tstate);
12242 if (PyErr_Occurred()) SWIG_fail;
12243 }
12244 {
12245 resultobj = SWIG_From_int((int)(result));
12246 }
12247 return resultobj;
12248 fail:
12249 return NULL;
12250 }
12251
12252
12253 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12254 PyObject *resultobj;
12255 wxJoystick *arg1 = (wxJoystick *) 0 ;
12256 int result;
12257 PyObject * obj0 = 0 ;
12258 char *kwnames[] = {
12259 (char *) "self", NULL
12260 };
12261
12262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12264 if (SWIG_arg_fail(1)) SWIG_fail;
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 result = (int)(arg1)->GetMaxAxes();
12268
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 {
12273 resultobj = SWIG_From_int((int)(result));
12274 }
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj;
12283 wxJoystick *arg1 = (wxJoystick *) 0 ;
12284 int result;
12285 PyObject * obj0 = 0 ;
12286 char *kwnames[] = {
12287 (char *) "self", NULL
12288 };
12289
12290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12292 if (SWIG_arg_fail(1)) SWIG_fail;
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 result = (int)(arg1)->GetPollingMin();
12296
12297 wxPyEndAllowThreads(__tstate);
12298 if (PyErr_Occurred()) SWIG_fail;
12299 }
12300 {
12301 resultobj = SWIG_From_int((int)(result));
12302 }
12303 return resultobj;
12304 fail:
12305 return NULL;
12306 }
12307
12308
12309 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12310 PyObject *resultobj;
12311 wxJoystick *arg1 = (wxJoystick *) 0 ;
12312 int result;
12313 PyObject * obj0 = 0 ;
12314 char *kwnames[] = {
12315 (char *) "self", NULL
12316 };
12317
12318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12320 if (SWIG_arg_fail(1)) SWIG_fail;
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 result = (int)(arg1)->GetPollingMax();
12324
12325 wxPyEndAllowThreads(__tstate);
12326 if (PyErr_Occurred()) SWIG_fail;
12327 }
12328 {
12329 resultobj = SWIG_From_int((int)(result));
12330 }
12331 return resultobj;
12332 fail:
12333 return NULL;
12334 }
12335
12336
12337 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj;
12339 wxJoystick *arg1 = (wxJoystick *) 0 ;
12340 int result;
12341 PyObject * obj0 = 0 ;
12342 char *kwnames[] = {
12343 (char *) "self", NULL
12344 };
12345
12346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12348 if (SWIG_arg_fail(1)) SWIG_fail;
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 result = (int)(arg1)->GetRudderMin();
12352
12353 wxPyEndAllowThreads(__tstate);
12354 if (PyErr_Occurred()) SWIG_fail;
12355 }
12356 {
12357 resultobj = SWIG_From_int((int)(result));
12358 }
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12366 PyObject *resultobj;
12367 wxJoystick *arg1 = (wxJoystick *) 0 ;
12368 int result;
12369 PyObject * obj0 = 0 ;
12370 char *kwnames[] = {
12371 (char *) "self", NULL
12372 };
12373
12374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12376 if (SWIG_arg_fail(1)) SWIG_fail;
12377 {
12378 PyThreadState* __tstate = wxPyBeginAllowThreads();
12379 result = (int)(arg1)->GetRudderMax();
12380
12381 wxPyEndAllowThreads(__tstate);
12382 if (PyErr_Occurred()) SWIG_fail;
12383 }
12384 {
12385 resultobj = SWIG_From_int((int)(result));
12386 }
12387 return resultobj;
12388 fail:
12389 return NULL;
12390 }
12391
12392
12393 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12394 PyObject *resultobj;
12395 wxJoystick *arg1 = (wxJoystick *) 0 ;
12396 int result;
12397 PyObject * obj0 = 0 ;
12398 char *kwnames[] = {
12399 (char *) "self", NULL
12400 };
12401
12402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12404 if (SWIG_arg_fail(1)) SWIG_fail;
12405 {
12406 PyThreadState* __tstate = wxPyBeginAllowThreads();
12407 result = (int)(arg1)->GetUMin();
12408
12409 wxPyEndAllowThreads(__tstate);
12410 if (PyErr_Occurred()) SWIG_fail;
12411 }
12412 {
12413 resultobj = SWIG_From_int((int)(result));
12414 }
12415 return resultobj;
12416 fail:
12417 return NULL;
12418 }
12419
12420
12421 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12422 PyObject *resultobj;
12423 wxJoystick *arg1 = (wxJoystick *) 0 ;
12424 int result;
12425 PyObject * obj0 = 0 ;
12426 char *kwnames[] = {
12427 (char *) "self", NULL
12428 };
12429
12430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12432 if (SWIG_arg_fail(1)) SWIG_fail;
12433 {
12434 PyThreadState* __tstate = wxPyBeginAllowThreads();
12435 result = (int)(arg1)->GetUMax();
12436
12437 wxPyEndAllowThreads(__tstate);
12438 if (PyErr_Occurred()) SWIG_fail;
12439 }
12440 {
12441 resultobj = SWIG_From_int((int)(result));
12442 }
12443 return resultobj;
12444 fail:
12445 return NULL;
12446 }
12447
12448
12449 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12450 PyObject *resultobj;
12451 wxJoystick *arg1 = (wxJoystick *) 0 ;
12452 int result;
12453 PyObject * obj0 = 0 ;
12454 char *kwnames[] = {
12455 (char *) "self", NULL
12456 };
12457
12458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12460 if (SWIG_arg_fail(1)) SWIG_fail;
12461 {
12462 PyThreadState* __tstate = wxPyBeginAllowThreads();
12463 result = (int)(arg1)->GetVMin();
12464
12465 wxPyEndAllowThreads(__tstate);
12466 if (PyErr_Occurred()) SWIG_fail;
12467 }
12468 {
12469 resultobj = SWIG_From_int((int)(result));
12470 }
12471 return resultobj;
12472 fail:
12473 return NULL;
12474 }
12475
12476
12477 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12478 PyObject *resultobj;
12479 wxJoystick *arg1 = (wxJoystick *) 0 ;
12480 int result;
12481 PyObject * obj0 = 0 ;
12482 char *kwnames[] = {
12483 (char *) "self", NULL
12484 };
12485
12486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12488 if (SWIG_arg_fail(1)) SWIG_fail;
12489 {
12490 PyThreadState* __tstate = wxPyBeginAllowThreads();
12491 result = (int)(arg1)->GetVMax();
12492
12493 wxPyEndAllowThreads(__tstate);
12494 if (PyErr_Occurred()) SWIG_fail;
12495 }
12496 {
12497 resultobj = SWIG_From_int((int)(result));
12498 }
12499 return resultobj;
12500 fail:
12501 return NULL;
12502 }
12503
12504
12505 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12506 PyObject *resultobj;
12507 wxJoystick *arg1 = (wxJoystick *) 0 ;
12508 bool result;
12509 PyObject * obj0 = 0 ;
12510 char *kwnames[] = {
12511 (char *) "self", NULL
12512 };
12513
12514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12516 if (SWIG_arg_fail(1)) SWIG_fail;
12517 {
12518 PyThreadState* __tstate = wxPyBeginAllowThreads();
12519 result = (bool)(arg1)->HasRudder();
12520
12521 wxPyEndAllowThreads(__tstate);
12522 if (PyErr_Occurred()) SWIG_fail;
12523 }
12524 {
12525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12526 }
12527 return resultobj;
12528 fail:
12529 return NULL;
12530 }
12531
12532
12533 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12534 PyObject *resultobj;
12535 wxJoystick *arg1 = (wxJoystick *) 0 ;
12536 bool result;
12537 PyObject * obj0 = 0 ;
12538 char *kwnames[] = {
12539 (char *) "self", NULL
12540 };
12541
12542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12544 if (SWIG_arg_fail(1)) SWIG_fail;
12545 {
12546 PyThreadState* __tstate = wxPyBeginAllowThreads();
12547 result = (bool)(arg1)->HasZ();
12548
12549 wxPyEndAllowThreads(__tstate);
12550 if (PyErr_Occurred()) SWIG_fail;
12551 }
12552 {
12553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12554 }
12555 return resultobj;
12556 fail:
12557 return NULL;
12558 }
12559
12560
12561 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12562 PyObject *resultobj;
12563 wxJoystick *arg1 = (wxJoystick *) 0 ;
12564 bool result;
12565 PyObject * obj0 = 0 ;
12566 char *kwnames[] = {
12567 (char *) "self", NULL
12568 };
12569
12570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12572 if (SWIG_arg_fail(1)) SWIG_fail;
12573 {
12574 PyThreadState* __tstate = wxPyBeginAllowThreads();
12575 result = (bool)(arg1)->HasU();
12576
12577 wxPyEndAllowThreads(__tstate);
12578 if (PyErr_Occurred()) SWIG_fail;
12579 }
12580 {
12581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12582 }
12583 return resultobj;
12584 fail:
12585 return NULL;
12586 }
12587
12588
12589 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12590 PyObject *resultobj;
12591 wxJoystick *arg1 = (wxJoystick *) 0 ;
12592 bool result;
12593 PyObject * obj0 = 0 ;
12594 char *kwnames[] = {
12595 (char *) "self", NULL
12596 };
12597
12598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12600 if (SWIG_arg_fail(1)) SWIG_fail;
12601 {
12602 PyThreadState* __tstate = wxPyBeginAllowThreads();
12603 result = (bool)(arg1)->HasV();
12604
12605 wxPyEndAllowThreads(__tstate);
12606 if (PyErr_Occurred()) SWIG_fail;
12607 }
12608 {
12609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12610 }
12611 return resultobj;
12612 fail:
12613 return NULL;
12614 }
12615
12616
12617 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12618 PyObject *resultobj;
12619 wxJoystick *arg1 = (wxJoystick *) 0 ;
12620 bool result;
12621 PyObject * obj0 = 0 ;
12622 char *kwnames[] = {
12623 (char *) "self", NULL
12624 };
12625
12626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12628 if (SWIG_arg_fail(1)) SWIG_fail;
12629 {
12630 PyThreadState* __tstate = wxPyBeginAllowThreads();
12631 result = (bool)(arg1)->HasPOV();
12632
12633 wxPyEndAllowThreads(__tstate);
12634 if (PyErr_Occurred()) SWIG_fail;
12635 }
12636 {
12637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12638 }
12639 return resultobj;
12640 fail:
12641 return NULL;
12642 }
12643
12644
12645 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12646 PyObject *resultobj;
12647 wxJoystick *arg1 = (wxJoystick *) 0 ;
12648 bool result;
12649 PyObject * obj0 = 0 ;
12650 char *kwnames[] = {
12651 (char *) "self", NULL
12652 };
12653
12654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12656 if (SWIG_arg_fail(1)) SWIG_fail;
12657 {
12658 PyThreadState* __tstate = wxPyBeginAllowThreads();
12659 result = (bool)(arg1)->HasPOV4Dir();
12660
12661 wxPyEndAllowThreads(__tstate);
12662 if (PyErr_Occurred()) SWIG_fail;
12663 }
12664 {
12665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12666 }
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12674 PyObject *resultobj;
12675 wxJoystick *arg1 = (wxJoystick *) 0 ;
12676 bool result;
12677 PyObject * obj0 = 0 ;
12678 char *kwnames[] = {
12679 (char *) "self", NULL
12680 };
12681
12682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12684 if (SWIG_arg_fail(1)) SWIG_fail;
12685 {
12686 PyThreadState* __tstate = wxPyBeginAllowThreads();
12687 result = (bool)(arg1)->HasPOVCTS();
12688
12689 wxPyEndAllowThreads(__tstate);
12690 if (PyErr_Occurred()) SWIG_fail;
12691 }
12692 {
12693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12694 }
12695 return resultobj;
12696 fail:
12697 return NULL;
12698 }
12699
12700
12701 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12702 PyObject *resultobj;
12703 wxJoystick *arg1 = (wxJoystick *) 0 ;
12704 wxWindow *arg2 = (wxWindow *) 0 ;
12705 int arg3 = (int) 0 ;
12706 bool result;
12707 PyObject * obj0 = 0 ;
12708 PyObject * obj1 = 0 ;
12709 PyObject * obj2 = 0 ;
12710 char *kwnames[] = {
12711 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12712 };
12713
12714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12716 if (SWIG_arg_fail(1)) SWIG_fail;
12717 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12718 if (SWIG_arg_fail(2)) SWIG_fail;
12719 if (obj2) {
12720 {
12721 arg3 = (int)(SWIG_As_int(obj2));
12722 if (SWIG_arg_fail(3)) SWIG_fail;
12723 }
12724 }
12725 {
12726 PyThreadState* __tstate = wxPyBeginAllowThreads();
12727 result = (bool)(arg1)->SetCapture(arg2,arg3);
12728
12729 wxPyEndAllowThreads(__tstate);
12730 if (PyErr_Occurred()) SWIG_fail;
12731 }
12732 {
12733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12734 }
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj;
12743 wxJoystick *arg1 = (wxJoystick *) 0 ;
12744 bool result;
12745 PyObject * obj0 = 0 ;
12746 char *kwnames[] = {
12747 (char *) "self", NULL
12748 };
12749
12750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12752 if (SWIG_arg_fail(1)) SWIG_fail;
12753 {
12754 PyThreadState* __tstate = wxPyBeginAllowThreads();
12755 result = (bool)(arg1)->ReleaseCapture();
12756
12757 wxPyEndAllowThreads(__tstate);
12758 if (PyErr_Occurred()) SWIG_fail;
12759 }
12760 {
12761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12762 }
12763 return resultobj;
12764 fail:
12765 return NULL;
12766 }
12767
12768
12769 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12770 PyObject *obj;
12771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12772 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12773 Py_INCREF(obj);
12774 return Py_BuildValue((char *)"");
12775 }
12776 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12777 PyObject *resultobj;
12778 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12779 int arg2 = (int) 0 ;
12780 int arg3 = (int) wxJOYSTICK1 ;
12781 int arg4 = (int) 0 ;
12782 wxJoystickEvent *result;
12783 PyObject * obj0 = 0 ;
12784 PyObject * obj1 = 0 ;
12785 PyObject * obj2 = 0 ;
12786 PyObject * obj3 = 0 ;
12787 char *kwnames[] = {
12788 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12789 };
12790
12791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12792 if (obj0) {
12793 {
12794 arg1 = (wxEventType)(SWIG_As_int(obj0));
12795 if (SWIG_arg_fail(1)) SWIG_fail;
12796 }
12797 }
12798 if (obj1) {
12799 {
12800 arg2 = (int)(SWIG_As_int(obj1));
12801 if (SWIG_arg_fail(2)) SWIG_fail;
12802 }
12803 }
12804 if (obj2) {
12805 {
12806 arg3 = (int)(SWIG_As_int(obj2));
12807 if (SWIG_arg_fail(3)) SWIG_fail;
12808 }
12809 }
12810 if (obj3) {
12811 {
12812 arg4 = (int)(SWIG_As_int(obj3));
12813 if (SWIG_arg_fail(4)) SWIG_fail;
12814 }
12815 }
12816 {
12817 PyThreadState* __tstate = wxPyBeginAllowThreads();
12818 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12819
12820 wxPyEndAllowThreads(__tstate);
12821 if (PyErr_Occurred()) SWIG_fail;
12822 }
12823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12824 return resultobj;
12825 fail:
12826 return NULL;
12827 }
12828
12829
12830 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12831 PyObject *resultobj;
12832 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12833 wxPoint result;
12834 PyObject * obj0 = 0 ;
12835 char *kwnames[] = {
12836 (char *) "self", NULL
12837 };
12838
12839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12841 if (SWIG_arg_fail(1)) SWIG_fail;
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12845
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 wxPoint * resultptr;
12851 resultptr = new wxPoint((wxPoint &)(result));
12852 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12853 }
12854 return resultobj;
12855 fail:
12856 return NULL;
12857 }
12858
12859
12860 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12861 PyObject *resultobj;
12862 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12863 int result;
12864 PyObject * obj0 = 0 ;
12865 char *kwnames[] = {
12866 (char *) "self", NULL
12867 };
12868
12869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12871 if (SWIG_arg_fail(1)) SWIG_fail;
12872 {
12873 PyThreadState* __tstate = wxPyBeginAllowThreads();
12874 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12875
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 {
12880 resultobj = SWIG_From_int((int)(result));
12881 }
12882 return resultobj;
12883 fail:
12884 return NULL;
12885 }
12886
12887
12888 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12889 PyObject *resultobj;
12890 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12891 int result;
12892 PyObject * obj0 = 0 ;
12893 char *kwnames[] = {
12894 (char *) "self", NULL
12895 };
12896
12897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12899 if (SWIG_arg_fail(1)) SWIG_fail;
12900 {
12901 PyThreadState* __tstate = wxPyBeginAllowThreads();
12902 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12903
12904 wxPyEndAllowThreads(__tstate);
12905 if (PyErr_Occurred()) SWIG_fail;
12906 }
12907 {
12908 resultobj = SWIG_From_int((int)(result));
12909 }
12910 return resultobj;
12911 fail:
12912 return NULL;
12913 }
12914
12915
12916 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12917 PyObject *resultobj;
12918 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12919 int result;
12920 PyObject * obj0 = 0 ;
12921 char *kwnames[] = {
12922 (char *) "self", NULL
12923 };
12924
12925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12927 if (SWIG_arg_fail(1)) SWIG_fail;
12928 {
12929 PyThreadState* __tstate = wxPyBeginAllowThreads();
12930 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12931
12932 wxPyEndAllowThreads(__tstate);
12933 if (PyErr_Occurred()) SWIG_fail;
12934 }
12935 {
12936 resultobj = SWIG_From_int((int)(result));
12937 }
12938 return resultobj;
12939 fail:
12940 return NULL;
12941 }
12942
12943
12944 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12945 PyObject *resultobj;
12946 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12947 int result;
12948 PyObject * obj0 = 0 ;
12949 char *kwnames[] = {
12950 (char *) "self", NULL
12951 };
12952
12953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12955 if (SWIG_arg_fail(1)) SWIG_fail;
12956 {
12957 PyThreadState* __tstate = wxPyBeginAllowThreads();
12958 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12959
12960 wxPyEndAllowThreads(__tstate);
12961 if (PyErr_Occurred()) SWIG_fail;
12962 }
12963 {
12964 resultobj = SWIG_From_int((int)(result));
12965 }
12966 return resultobj;
12967 fail:
12968 return NULL;
12969 }
12970
12971
12972 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12973 PyObject *resultobj;
12974 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12975 int arg2 ;
12976 PyObject * obj0 = 0 ;
12977 PyObject * obj1 = 0 ;
12978 char *kwnames[] = {
12979 (char *) "self",(char *) "stick", NULL
12980 };
12981
12982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12984 if (SWIG_arg_fail(1)) SWIG_fail;
12985 {
12986 arg2 = (int)(SWIG_As_int(obj1));
12987 if (SWIG_arg_fail(2)) SWIG_fail;
12988 }
12989 {
12990 PyThreadState* __tstate = wxPyBeginAllowThreads();
12991 (arg1)->SetJoystick(arg2);
12992
12993 wxPyEndAllowThreads(__tstate);
12994 if (PyErr_Occurred()) SWIG_fail;
12995 }
12996 Py_INCREF(Py_None); resultobj = Py_None;
12997 return resultobj;
12998 fail:
12999 return NULL;
13000 }
13001
13002
13003 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13004 PyObject *resultobj;
13005 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13006 int arg2 ;
13007 PyObject * obj0 = 0 ;
13008 PyObject * obj1 = 0 ;
13009 char *kwnames[] = {
13010 (char *) "self",(char *) "state", NULL
13011 };
13012
13013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13015 if (SWIG_arg_fail(1)) SWIG_fail;
13016 {
13017 arg2 = (int)(SWIG_As_int(obj1));
13018 if (SWIG_arg_fail(2)) SWIG_fail;
13019 }
13020 {
13021 PyThreadState* __tstate = wxPyBeginAllowThreads();
13022 (arg1)->SetButtonState(arg2);
13023
13024 wxPyEndAllowThreads(__tstate);
13025 if (PyErr_Occurred()) SWIG_fail;
13026 }
13027 Py_INCREF(Py_None); resultobj = Py_None;
13028 return resultobj;
13029 fail:
13030 return NULL;
13031 }
13032
13033
13034 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13035 PyObject *resultobj;
13036 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13037 int arg2 ;
13038 PyObject * obj0 = 0 ;
13039 PyObject * obj1 = 0 ;
13040 char *kwnames[] = {
13041 (char *) "self",(char *) "change", NULL
13042 };
13043
13044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13046 if (SWIG_arg_fail(1)) SWIG_fail;
13047 {
13048 arg2 = (int)(SWIG_As_int(obj1));
13049 if (SWIG_arg_fail(2)) SWIG_fail;
13050 }
13051 {
13052 PyThreadState* __tstate = wxPyBeginAllowThreads();
13053 (arg1)->SetButtonChange(arg2);
13054
13055 wxPyEndAllowThreads(__tstate);
13056 if (PyErr_Occurred()) SWIG_fail;
13057 }
13058 Py_INCREF(Py_None); resultobj = Py_None;
13059 return resultobj;
13060 fail:
13061 return NULL;
13062 }
13063
13064
13065 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13066 PyObject *resultobj;
13067 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13068 wxPoint *arg2 = 0 ;
13069 wxPoint temp2 ;
13070 PyObject * obj0 = 0 ;
13071 PyObject * obj1 = 0 ;
13072 char *kwnames[] = {
13073 (char *) "self",(char *) "pos", NULL
13074 };
13075
13076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13078 if (SWIG_arg_fail(1)) SWIG_fail;
13079 {
13080 arg2 = &temp2;
13081 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13082 }
13083 {
13084 PyThreadState* __tstate = wxPyBeginAllowThreads();
13085 (arg1)->SetPosition((wxPoint const &)*arg2);
13086
13087 wxPyEndAllowThreads(__tstate);
13088 if (PyErr_Occurred()) SWIG_fail;
13089 }
13090 Py_INCREF(Py_None); resultobj = Py_None;
13091 return resultobj;
13092 fail:
13093 return NULL;
13094 }
13095
13096
13097 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13098 PyObject *resultobj;
13099 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13100 int arg2 ;
13101 PyObject * obj0 = 0 ;
13102 PyObject * obj1 = 0 ;
13103 char *kwnames[] = {
13104 (char *) "self",(char *) "zPos", NULL
13105 };
13106
13107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13109 if (SWIG_arg_fail(1)) SWIG_fail;
13110 {
13111 arg2 = (int)(SWIG_As_int(obj1));
13112 if (SWIG_arg_fail(2)) SWIG_fail;
13113 }
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 (arg1)->SetZPosition(arg2);
13117
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 Py_INCREF(Py_None); resultobj = Py_None;
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj;
13130 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13131 bool result;
13132 PyObject * obj0 = 0 ;
13133 char *kwnames[] = {
13134 (char *) "self", NULL
13135 };
13136
13137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13139 if (SWIG_arg_fail(1)) SWIG_fail;
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13143
13144 wxPyEndAllowThreads(__tstate);
13145 if (PyErr_Occurred()) SWIG_fail;
13146 }
13147 {
13148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13149 }
13150 return resultobj;
13151 fail:
13152 return NULL;
13153 }
13154
13155
13156 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13157 PyObject *resultobj;
13158 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13159 bool result;
13160 PyObject * obj0 = 0 ;
13161 char *kwnames[] = {
13162 (char *) "self", NULL
13163 };
13164
13165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13167 if (SWIG_arg_fail(1)) SWIG_fail;
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13171
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 {
13176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13177 }
13178 return resultobj;
13179 fail:
13180 return NULL;
13181 }
13182
13183
13184 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13185 PyObject *resultobj;
13186 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13187 bool result;
13188 PyObject * obj0 = 0 ;
13189 char *kwnames[] = {
13190 (char *) "self", NULL
13191 };
13192
13193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13195 if (SWIG_arg_fail(1)) SWIG_fail;
13196 {
13197 PyThreadState* __tstate = wxPyBeginAllowThreads();
13198 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13199
13200 wxPyEndAllowThreads(__tstate);
13201 if (PyErr_Occurred()) SWIG_fail;
13202 }
13203 {
13204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13205 }
13206 return resultobj;
13207 fail:
13208 return NULL;
13209 }
13210
13211
13212 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13213 PyObject *resultobj;
13214 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13215 int arg2 = (int) wxJOY_BUTTON_ANY ;
13216 bool result;
13217 PyObject * obj0 = 0 ;
13218 PyObject * obj1 = 0 ;
13219 char *kwnames[] = {
13220 (char *) "self",(char *) "but", NULL
13221 };
13222
13223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13225 if (SWIG_arg_fail(1)) SWIG_fail;
13226 if (obj1) {
13227 {
13228 arg2 = (int)(SWIG_As_int(obj1));
13229 if (SWIG_arg_fail(2)) SWIG_fail;
13230 }
13231 }
13232 {
13233 PyThreadState* __tstate = wxPyBeginAllowThreads();
13234 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13235
13236 wxPyEndAllowThreads(__tstate);
13237 if (PyErr_Occurred()) SWIG_fail;
13238 }
13239 {
13240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13241 }
13242 return resultobj;
13243 fail:
13244 return NULL;
13245 }
13246
13247
13248 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13249 PyObject *resultobj;
13250 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13251 int arg2 = (int) wxJOY_BUTTON_ANY ;
13252 bool result;
13253 PyObject * obj0 = 0 ;
13254 PyObject * obj1 = 0 ;
13255 char *kwnames[] = {
13256 (char *) "self",(char *) "but", NULL
13257 };
13258
13259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13261 if (SWIG_arg_fail(1)) SWIG_fail;
13262 if (obj1) {
13263 {
13264 arg2 = (int)(SWIG_As_int(obj1));
13265 if (SWIG_arg_fail(2)) SWIG_fail;
13266 }
13267 }
13268 {
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13271
13272 wxPyEndAllowThreads(__tstate);
13273 if (PyErr_Occurred()) SWIG_fail;
13274 }
13275 {
13276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13277 }
13278 return resultobj;
13279 fail:
13280 return NULL;
13281 }
13282
13283
13284 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13285 PyObject *resultobj;
13286 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13287 int arg2 = (int) wxJOY_BUTTON_ANY ;
13288 bool result;
13289 PyObject * obj0 = 0 ;
13290 PyObject * obj1 = 0 ;
13291 char *kwnames[] = {
13292 (char *) "self",(char *) "but", NULL
13293 };
13294
13295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13297 if (SWIG_arg_fail(1)) SWIG_fail;
13298 if (obj1) {
13299 {
13300 arg2 = (int)(SWIG_As_int(obj1));
13301 if (SWIG_arg_fail(2)) SWIG_fail;
13302 }
13303 }
13304 {
13305 PyThreadState* __tstate = wxPyBeginAllowThreads();
13306 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13307
13308 wxPyEndAllowThreads(__tstate);
13309 if (PyErr_Occurred()) SWIG_fail;
13310 }
13311 {
13312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13313 }
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13321 PyObject *obj;
13322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13323 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13324 Py_INCREF(obj);
13325 return Py_BuildValue((char *)"");
13326 }
13327 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13328 PyObject *resultobj;
13329 wxString const &arg1_defvalue = wxPyEmptyString ;
13330 wxString *arg1 = (wxString *) &arg1_defvalue ;
13331 wxSound *result;
13332 bool temp1 = false ;
13333 PyObject * obj0 = 0 ;
13334 char *kwnames[] = {
13335 (char *) "fileName", NULL
13336 };
13337
13338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13339 if (obj0) {
13340 {
13341 arg1 = wxString_in_helper(obj0);
13342 if (arg1 == NULL) SWIG_fail;
13343 temp1 = true;
13344 }
13345 }
13346 {
13347 if (!wxPyCheckForApp()) SWIG_fail;
13348 PyThreadState* __tstate = wxPyBeginAllowThreads();
13349 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13350
13351 wxPyEndAllowThreads(__tstate);
13352 if (PyErr_Occurred()) SWIG_fail;
13353 }
13354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13355 {
13356 if (temp1)
13357 delete arg1;
13358 }
13359 return resultobj;
13360 fail:
13361 {
13362 if (temp1)
13363 delete arg1;
13364 }
13365 return NULL;
13366 }
13367
13368
13369 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj;
13371 PyObject *arg1 = (PyObject *) 0 ;
13372 wxSound *result;
13373 PyObject * obj0 = 0 ;
13374 char *kwnames[] = {
13375 (char *) "data", NULL
13376 };
13377
13378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13379 arg1 = obj0;
13380 {
13381 if (!wxPyCheckForApp()) SWIG_fail;
13382 PyThreadState* __tstate = wxPyBeginAllowThreads();
13383 result = (wxSound *)new_wxSound(arg1);
13384
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13389 return resultobj;
13390 fail:
13391 return NULL;
13392 }
13393
13394
13395 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13396 PyObject *resultobj;
13397 wxSound *arg1 = (wxSound *) 0 ;
13398 PyObject * obj0 = 0 ;
13399 char *kwnames[] = {
13400 (char *) "self", NULL
13401 };
13402
13403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13405 if (SWIG_arg_fail(1)) SWIG_fail;
13406 {
13407 PyThreadState* __tstate = wxPyBeginAllowThreads();
13408 delete arg1;
13409
13410 wxPyEndAllowThreads(__tstate);
13411 if (PyErr_Occurred()) SWIG_fail;
13412 }
13413 Py_INCREF(Py_None); resultobj = Py_None;
13414 return resultobj;
13415 fail:
13416 return NULL;
13417 }
13418
13419
13420 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13421 PyObject *resultobj;
13422 wxSound *arg1 = (wxSound *) 0 ;
13423 wxString *arg2 = 0 ;
13424 bool result;
13425 bool temp2 = false ;
13426 PyObject * obj0 = 0 ;
13427 PyObject * obj1 = 0 ;
13428 char *kwnames[] = {
13429 (char *) "self",(char *) "fileName", NULL
13430 };
13431
13432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13434 if (SWIG_arg_fail(1)) SWIG_fail;
13435 {
13436 arg2 = wxString_in_helper(obj1);
13437 if (arg2 == NULL) SWIG_fail;
13438 temp2 = true;
13439 }
13440 {
13441 PyThreadState* __tstate = wxPyBeginAllowThreads();
13442 result = (bool)(arg1)->Create((wxString const &)*arg2);
13443
13444 wxPyEndAllowThreads(__tstate);
13445 if (PyErr_Occurred()) SWIG_fail;
13446 }
13447 {
13448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13449 }
13450 {
13451 if (temp2)
13452 delete arg2;
13453 }
13454 return resultobj;
13455 fail:
13456 {
13457 if (temp2)
13458 delete arg2;
13459 }
13460 return NULL;
13461 }
13462
13463
13464 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13465 PyObject *resultobj;
13466 wxSound *arg1 = (wxSound *) 0 ;
13467 PyObject *arg2 = (PyObject *) 0 ;
13468 bool result;
13469 PyObject * obj0 = 0 ;
13470 PyObject * obj1 = 0 ;
13471 char *kwnames[] = {
13472 (char *) "self",(char *) "data", NULL
13473 };
13474
13475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13477 if (SWIG_arg_fail(1)) SWIG_fail;
13478 arg2 = obj1;
13479 {
13480 PyThreadState* __tstate = wxPyBeginAllowThreads();
13481 result = (bool)wxSound_CreateFromData(arg1,arg2);
13482
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 {
13487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13488 }
13489 return resultobj;
13490 fail:
13491 return NULL;
13492 }
13493
13494
13495 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13496 PyObject *resultobj;
13497 wxSound *arg1 = (wxSound *) 0 ;
13498 bool result;
13499 PyObject * obj0 = 0 ;
13500 char *kwnames[] = {
13501 (char *) "self", NULL
13502 };
13503
13504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13506 if (SWIG_arg_fail(1)) SWIG_fail;
13507 {
13508 PyThreadState* __tstate = wxPyBeginAllowThreads();
13509 result = (bool)(arg1)->IsOk();
13510
13511 wxPyEndAllowThreads(__tstate);
13512 if (PyErr_Occurred()) SWIG_fail;
13513 }
13514 {
13515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13516 }
13517 return resultobj;
13518 fail:
13519 return NULL;
13520 }
13521
13522
13523 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13524 PyObject *resultobj;
13525 wxSound *arg1 = (wxSound *) 0 ;
13526 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13527 bool result;
13528 PyObject * obj0 = 0 ;
13529 PyObject * obj1 = 0 ;
13530 char *kwnames[] = {
13531 (char *) "self",(char *) "flags", NULL
13532 };
13533
13534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13536 if (SWIG_arg_fail(1)) SWIG_fail;
13537 if (obj1) {
13538 {
13539 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13540 if (SWIG_arg_fail(2)) SWIG_fail;
13541 }
13542 }
13543 {
13544 if (!wxPyCheckForApp()) SWIG_fail;
13545 PyThreadState* __tstate = wxPyBeginAllowThreads();
13546 result = (bool)((wxSound const *)arg1)->Play(arg2);
13547
13548 wxPyEndAllowThreads(__tstate);
13549 if (PyErr_Occurred()) SWIG_fail;
13550 }
13551 {
13552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13553 }
13554 return resultobj;
13555 fail:
13556 return NULL;
13557 }
13558
13559
13560 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13561 PyObject *resultobj;
13562 wxString *arg1 = 0 ;
13563 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13564 bool result;
13565 bool temp1 = false ;
13566 PyObject * obj0 = 0 ;
13567 PyObject * obj1 = 0 ;
13568 char *kwnames[] = {
13569 (char *) "filename",(char *) "flags", NULL
13570 };
13571
13572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13573 {
13574 arg1 = wxString_in_helper(obj0);
13575 if (arg1 == NULL) SWIG_fail;
13576 temp1 = true;
13577 }
13578 if (obj1) {
13579 {
13580 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13581 if (SWIG_arg_fail(2)) SWIG_fail;
13582 }
13583 }
13584 {
13585 if (!wxPyCheckForApp()) SWIG_fail;
13586 PyThreadState* __tstate = wxPyBeginAllowThreads();
13587 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13588
13589 wxPyEndAllowThreads(__tstate);
13590 if (PyErr_Occurred()) SWIG_fail;
13591 }
13592 {
13593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13594 }
13595 {
13596 if (temp1)
13597 delete arg1;
13598 }
13599 return resultobj;
13600 fail:
13601 {
13602 if (temp1)
13603 delete arg1;
13604 }
13605 return NULL;
13606 }
13607
13608
13609 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13610 PyObject *resultobj;
13611 char *kwnames[] = {
13612 NULL
13613 };
13614
13615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13616 {
13617 if (!wxPyCheckForApp()) SWIG_fail;
13618 PyThreadState* __tstate = wxPyBeginAllowThreads();
13619 wxSound::Stop();
13620
13621 wxPyEndAllowThreads(__tstate);
13622 if (PyErr_Occurred()) SWIG_fail;
13623 }
13624 Py_INCREF(Py_None); resultobj = Py_None;
13625 return resultobj;
13626 fail:
13627 return NULL;
13628 }
13629
13630
13631 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13632 PyObject *obj;
13633 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13634 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13635 Py_INCREF(obj);
13636 return Py_BuildValue((char *)"");
13637 }
13638 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13639 PyObject *resultobj;
13640 wxString *arg1 = 0 ;
13641 wxString *arg2 = 0 ;
13642 wxString *arg3 = 0 ;
13643 wxString *arg4 = 0 ;
13644 wxFileTypeInfo *result;
13645 bool temp1 = false ;
13646 bool temp2 = false ;
13647 bool temp3 = false ;
13648 bool temp4 = false ;
13649 PyObject * obj0 = 0 ;
13650 PyObject * obj1 = 0 ;
13651 PyObject * obj2 = 0 ;
13652 PyObject * obj3 = 0 ;
13653 char *kwnames[] = {
13654 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13655 };
13656
13657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13658 {
13659 arg1 = wxString_in_helper(obj0);
13660 if (arg1 == NULL) SWIG_fail;
13661 temp1 = true;
13662 }
13663 {
13664 arg2 = wxString_in_helper(obj1);
13665 if (arg2 == NULL) SWIG_fail;
13666 temp2 = true;
13667 }
13668 {
13669 arg3 = wxString_in_helper(obj2);
13670 if (arg3 == NULL) SWIG_fail;
13671 temp3 = true;
13672 }
13673 {
13674 arg4 = wxString_in_helper(obj3);
13675 if (arg4 == NULL) SWIG_fail;
13676 temp4 = true;
13677 }
13678 {
13679 PyThreadState* __tstate = wxPyBeginAllowThreads();
13680 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13681
13682 wxPyEndAllowThreads(__tstate);
13683 if (PyErr_Occurred()) SWIG_fail;
13684 }
13685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13686 {
13687 if (temp1)
13688 delete arg1;
13689 }
13690 {
13691 if (temp2)
13692 delete arg2;
13693 }
13694 {
13695 if (temp3)
13696 delete arg3;
13697 }
13698 {
13699 if (temp4)
13700 delete arg4;
13701 }
13702 return resultobj;
13703 fail:
13704 {
13705 if (temp1)
13706 delete arg1;
13707 }
13708 {
13709 if (temp2)
13710 delete arg2;
13711 }
13712 {
13713 if (temp3)
13714 delete arg3;
13715 }
13716 {
13717 if (temp4)
13718 delete arg4;
13719 }
13720 return NULL;
13721 }
13722
13723
13724 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13725 PyObject *resultobj;
13726 wxArrayString *arg1 = 0 ;
13727 wxFileTypeInfo *result;
13728 bool temp1 = false ;
13729 PyObject * obj0 = 0 ;
13730 char *kwnames[] = {
13731 (char *) "sArray", NULL
13732 };
13733
13734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13735 {
13736 if (! PySequence_Check(obj0)) {
13737 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13738 SWIG_fail;
13739 }
13740 arg1 = new wxArrayString;
13741 temp1 = true;
13742 int i, len=PySequence_Length(obj0);
13743 for (i=0; i<len; i++) {
13744 PyObject* item = PySequence_GetItem(obj0, i);
13745 #if wxUSE_UNICODE
13746 PyObject* str = PyObject_Unicode(item);
13747 #else
13748 PyObject* str = PyObject_Str(item);
13749 #endif
13750 if (PyErr_Occurred()) SWIG_fail;
13751 arg1->Add(Py2wxString(str));
13752 Py_DECREF(item);
13753 Py_DECREF(str);
13754 }
13755 }
13756 {
13757 PyThreadState* __tstate = wxPyBeginAllowThreads();
13758 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13759
13760 wxPyEndAllowThreads(__tstate);
13761 if (PyErr_Occurred()) SWIG_fail;
13762 }
13763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13764 {
13765 if (temp1) delete arg1;
13766 }
13767 return resultobj;
13768 fail:
13769 {
13770 if (temp1) delete arg1;
13771 }
13772 return NULL;
13773 }
13774
13775
13776 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13777 PyObject *resultobj;
13778 wxFileTypeInfo *result;
13779 char *kwnames[] = {
13780 NULL
13781 };
13782
13783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13784 {
13785 PyThreadState* __tstate = wxPyBeginAllowThreads();
13786 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13787
13788 wxPyEndAllowThreads(__tstate);
13789 if (PyErr_Occurred()) SWIG_fail;
13790 }
13791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13792 return resultobj;
13793 fail:
13794 return NULL;
13795 }
13796
13797
13798 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13799 PyObject *resultobj;
13800 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13801 bool result;
13802 PyObject * obj0 = 0 ;
13803 char *kwnames[] = {
13804 (char *) "self", NULL
13805 };
13806
13807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13809 if (SWIG_arg_fail(1)) SWIG_fail;
13810 {
13811 PyThreadState* __tstate = wxPyBeginAllowThreads();
13812 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13813
13814 wxPyEndAllowThreads(__tstate);
13815 if (PyErr_Occurred()) SWIG_fail;
13816 }
13817 {
13818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13819 }
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj;
13828 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13829 wxString *arg2 = 0 ;
13830 int arg3 = (int) 0 ;
13831 bool temp2 = false ;
13832 PyObject * obj0 = 0 ;
13833 PyObject * obj1 = 0 ;
13834 PyObject * obj2 = 0 ;
13835 char *kwnames[] = {
13836 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13837 };
13838
13839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13841 if (SWIG_arg_fail(1)) SWIG_fail;
13842 {
13843 arg2 = wxString_in_helper(obj1);
13844 if (arg2 == NULL) SWIG_fail;
13845 temp2 = true;
13846 }
13847 if (obj2) {
13848 {
13849 arg3 = (int)(SWIG_As_int(obj2));
13850 if (SWIG_arg_fail(3)) SWIG_fail;
13851 }
13852 }
13853 {
13854 PyThreadState* __tstate = wxPyBeginAllowThreads();
13855 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13856
13857 wxPyEndAllowThreads(__tstate);
13858 if (PyErr_Occurred()) SWIG_fail;
13859 }
13860 Py_INCREF(Py_None); resultobj = Py_None;
13861 {
13862 if (temp2)
13863 delete arg2;
13864 }
13865 return resultobj;
13866 fail:
13867 {
13868 if (temp2)
13869 delete arg2;
13870 }
13871 return NULL;
13872 }
13873
13874
13875 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13876 PyObject *resultobj;
13877 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13878 wxString *arg2 = 0 ;
13879 bool temp2 = false ;
13880 PyObject * obj0 = 0 ;
13881 PyObject * obj1 = 0 ;
13882 char *kwnames[] = {
13883 (char *) "self",(char *) "shortDesc", NULL
13884 };
13885
13886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13888 if (SWIG_arg_fail(1)) SWIG_fail;
13889 {
13890 arg2 = wxString_in_helper(obj1);
13891 if (arg2 == NULL) SWIG_fail;
13892 temp2 = true;
13893 }
13894 {
13895 PyThreadState* __tstate = wxPyBeginAllowThreads();
13896 (arg1)->SetShortDesc((wxString const &)*arg2);
13897
13898 wxPyEndAllowThreads(__tstate);
13899 if (PyErr_Occurred()) SWIG_fail;
13900 }
13901 Py_INCREF(Py_None); resultobj = Py_None;
13902 {
13903 if (temp2)
13904 delete arg2;
13905 }
13906 return resultobj;
13907 fail:
13908 {
13909 if (temp2)
13910 delete arg2;
13911 }
13912 return NULL;
13913 }
13914
13915
13916 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13917 PyObject *resultobj;
13918 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13919 wxString *result;
13920 PyObject * obj0 = 0 ;
13921 char *kwnames[] = {
13922 (char *) "self", NULL
13923 };
13924
13925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13927 if (SWIG_arg_fail(1)) SWIG_fail;
13928 {
13929 PyThreadState* __tstate = wxPyBeginAllowThreads();
13930 {
13931 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13932 result = (wxString *) &_result_ref;
13933 }
13934
13935 wxPyEndAllowThreads(__tstate);
13936 if (PyErr_Occurred()) SWIG_fail;
13937 }
13938 {
13939 #if wxUSE_UNICODE
13940 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13941 #else
13942 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13943 #endif
13944 }
13945 return resultobj;
13946 fail:
13947 return NULL;
13948 }
13949
13950
13951 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13952 PyObject *resultobj;
13953 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13954 wxString *result;
13955 PyObject * obj0 = 0 ;
13956 char *kwnames[] = {
13957 (char *) "self", NULL
13958 };
13959
13960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13962 if (SWIG_arg_fail(1)) SWIG_fail;
13963 {
13964 PyThreadState* __tstate = wxPyBeginAllowThreads();
13965 {
13966 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13967 result = (wxString *) &_result_ref;
13968 }
13969
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 {
13974 #if wxUSE_UNICODE
13975 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13976 #else
13977 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13978 #endif
13979 }
13980 return resultobj;
13981 fail:
13982 return NULL;
13983 }
13984
13985
13986 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13987 PyObject *resultobj;
13988 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13989 wxString *result;
13990 PyObject * obj0 = 0 ;
13991 char *kwnames[] = {
13992 (char *) "self", NULL
13993 };
13994
13995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13997 if (SWIG_arg_fail(1)) SWIG_fail;
13998 {
13999 PyThreadState* __tstate = wxPyBeginAllowThreads();
14000 {
14001 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14002 result = (wxString *) &_result_ref;
14003 }
14004
14005 wxPyEndAllowThreads(__tstate);
14006 if (PyErr_Occurred()) SWIG_fail;
14007 }
14008 {
14009 #if wxUSE_UNICODE
14010 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14011 #else
14012 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14013 #endif
14014 }
14015 return resultobj;
14016 fail:
14017 return NULL;
14018 }
14019
14020
14021 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14022 PyObject *resultobj;
14023 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14024 wxString *result;
14025 PyObject * obj0 = 0 ;
14026 char *kwnames[] = {
14027 (char *) "self", NULL
14028 };
14029
14030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14032 if (SWIG_arg_fail(1)) SWIG_fail;
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 {
14036 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14037 result = (wxString *) &_result_ref;
14038 }
14039
14040 wxPyEndAllowThreads(__tstate);
14041 if (PyErr_Occurred()) SWIG_fail;
14042 }
14043 {
14044 #if wxUSE_UNICODE
14045 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14046 #else
14047 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14048 #endif
14049 }
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14057 PyObject *resultobj;
14058 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14059 wxString *result;
14060 PyObject * obj0 = 0 ;
14061 char *kwnames[] = {
14062 (char *) "self", NULL
14063 };
14064
14065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14067 if (SWIG_arg_fail(1)) SWIG_fail;
14068 {
14069 PyThreadState* __tstate = wxPyBeginAllowThreads();
14070 {
14071 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14072 result = (wxString *) &_result_ref;
14073 }
14074
14075 wxPyEndAllowThreads(__tstate);
14076 if (PyErr_Occurred()) SWIG_fail;
14077 }
14078 {
14079 #if wxUSE_UNICODE
14080 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14081 #else
14082 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14083 #endif
14084 }
14085 return resultobj;
14086 fail:
14087 return NULL;
14088 }
14089
14090
14091 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14092 PyObject *resultobj;
14093 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14094 wxArrayString *result;
14095 PyObject * obj0 = 0 ;
14096 char *kwnames[] = {
14097 (char *) "self", NULL
14098 };
14099
14100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14102 if (SWIG_arg_fail(1)) SWIG_fail;
14103 {
14104 PyThreadState* __tstate = wxPyBeginAllowThreads();
14105 {
14106 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14107 result = (wxArrayString *) &_result_ref;
14108 }
14109
14110 wxPyEndAllowThreads(__tstate);
14111 if (PyErr_Occurred()) SWIG_fail;
14112 }
14113 {
14114 resultobj = wxArrayString2PyList_helper(*result);
14115 }
14116 return resultobj;
14117 fail:
14118 return NULL;
14119 }
14120
14121
14122 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14123 PyObject *resultobj;
14124 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14125 int result;
14126 PyObject * obj0 = 0 ;
14127 char *kwnames[] = {
14128 (char *) "self", NULL
14129 };
14130
14131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14133 if (SWIG_arg_fail(1)) SWIG_fail;
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14137
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 {
14142 resultobj = SWIG_From_int((int)(result));
14143 }
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14153 wxString *result;
14154 PyObject * obj0 = 0 ;
14155 char *kwnames[] = {
14156 (char *) "self", NULL
14157 };
14158
14159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14161 if (SWIG_arg_fail(1)) SWIG_fail;
14162 {
14163 PyThreadState* __tstate = wxPyBeginAllowThreads();
14164 {
14165 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14166 result = (wxString *) &_result_ref;
14167 }
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 {
14173 #if wxUSE_UNICODE
14174 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14175 #else
14176 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14177 #endif
14178 }
14179 return resultobj;
14180 fail:
14181 return NULL;
14182 }
14183
14184
14185 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14186 PyObject *resultobj;
14187 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14188 int result;
14189 PyObject * obj0 = 0 ;
14190 char *kwnames[] = {
14191 (char *) "self", NULL
14192 };
14193
14194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14196 if (SWIG_arg_fail(1)) SWIG_fail;
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14200
14201 wxPyEndAllowThreads(__tstate);
14202 if (PyErr_Occurred()) SWIG_fail;
14203 }
14204 {
14205 resultobj = SWIG_From_int((int)(result));
14206 }
14207 return resultobj;
14208 fail:
14209 return NULL;
14210 }
14211
14212
14213 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14214 PyObject *obj;
14215 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14216 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14217 Py_INCREF(obj);
14218 return Py_BuildValue((char *)"");
14219 }
14220 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14221 PyObject *resultobj;
14222 wxFileTypeInfo *arg1 = 0 ;
14223 wxFileType *result;
14224 PyObject * obj0 = 0 ;
14225 char *kwnames[] = {
14226 (char *) "ftInfo", NULL
14227 };
14228
14229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14230 {
14231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14232 if (SWIG_arg_fail(1)) SWIG_fail;
14233 if (arg1 == NULL) {
14234 SWIG_null_ref("wxFileTypeInfo");
14235 }
14236 if (SWIG_arg_fail(1)) SWIG_fail;
14237 }
14238 {
14239 PyThreadState* __tstate = wxPyBeginAllowThreads();
14240 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14241
14242 wxPyEndAllowThreads(__tstate);
14243 if (PyErr_Occurred()) SWIG_fail;
14244 }
14245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14246 return resultobj;
14247 fail:
14248 return NULL;
14249 }
14250
14251
14252 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14253 PyObject *resultobj;
14254 wxFileType *arg1 = (wxFileType *) 0 ;
14255 PyObject * obj0 = 0 ;
14256 char *kwnames[] = {
14257 (char *) "self", NULL
14258 };
14259
14260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14262 if (SWIG_arg_fail(1)) SWIG_fail;
14263 {
14264 PyThreadState* __tstate = wxPyBeginAllowThreads();
14265 delete arg1;
14266
14267 wxPyEndAllowThreads(__tstate);
14268 if (PyErr_Occurred()) SWIG_fail;
14269 }
14270 Py_INCREF(Py_None); resultobj = Py_None;
14271 return resultobj;
14272 fail:
14273 return NULL;
14274 }
14275
14276
14277 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14278 PyObject *resultobj;
14279 wxFileType *arg1 = (wxFileType *) 0 ;
14280 PyObject *result;
14281 PyObject * obj0 = 0 ;
14282 char *kwnames[] = {
14283 (char *) "self", NULL
14284 };
14285
14286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14288 if (SWIG_arg_fail(1)) SWIG_fail;
14289 {
14290 PyThreadState* __tstate = wxPyBeginAllowThreads();
14291 result = (PyObject *)wxFileType_GetMimeType(arg1);
14292
14293 wxPyEndAllowThreads(__tstate);
14294 if (PyErr_Occurred()) SWIG_fail;
14295 }
14296 resultobj = result;
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14304 PyObject *resultobj;
14305 wxFileType *arg1 = (wxFileType *) 0 ;
14306 PyObject *result;
14307 PyObject * obj0 = 0 ;
14308 char *kwnames[] = {
14309 (char *) "self", NULL
14310 };
14311
14312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14314 if (SWIG_arg_fail(1)) SWIG_fail;
14315 {
14316 PyThreadState* __tstate = wxPyBeginAllowThreads();
14317 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14318
14319 wxPyEndAllowThreads(__tstate);
14320 if (PyErr_Occurred()) SWIG_fail;
14321 }
14322 resultobj = result;
14323 return resultobj;
14324 fail:
14325 return NULL;
14326 }
14327
14328
14329 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14330 PyObject *resultobj;
14331 wxFileType *arg1 = (wxFileType *) 0 ;
14332 PyObject *result;
14333 PyObject * obj0 = 0 ;
14334 char *kwnames[] = {
14335 (char *) "self", NULL
14336 };
14337
14338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14340 if (SWIG_arg_fail(1)) SWIG_fail;
14341 {
14342 PyThreadState* __tstate = wxPyBeginAllowThreads();
14343 result = (PyObject *)wxFileType_GetExtensions(arg1);
14344
14345 wxPyEndAllowThreads(__tstate);
14346 if (PyErr_Occurred()) SWIG_fail;
14347 }
14348 resultobj = result;
14349 return resultobj;
14350 fail:
14351 return NULL;
14352 }
14353
14354
14355 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14356 PyObject *resultobj;
14357 wxFileType *arg1 = (wxFileType *) 0 ;
14358 wxIcon *result;
14359 PyObject * obj0 = 0 ;
14360 char *kwnames[] = {
14361 (char *) "self", NULL
14362 };
14363
14364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14366 if (SWIG_arg_fail(1)) SWIG_fail;
14367 {
14368 PyThreadState* __tstate = wxPyBeginAllowThreads();
14369 result = (wxIcon *)wxFileType_GetIcon(arg1);
14370
14371 wxPyEndAllowThreads(__tstate);
14372 if (PyErr_Occurred()) SWIG_fail;
14373 }
14374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14375 return resultobj;
14376 fail:
14377 return NULL;
14378 }
14379
14380
14381 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14382 PyObject *resultobj;
14383 wxFileType *arg1 = (wxFileType *) 0 ;
14384 PyObject *result;
14385 PyObject * obj0 = 0 ;
14386 char *kwnames[] = {
14387 (char *) "self", NULL
14388 };
14389
14390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14392 if (SWIG_arg_fail(1)) SWIG_fail;
14393 {
14394 PyThreadState* __tstate = wxPyBeginAllowThreads();
14395 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14396
14397 wxPyEndAllowThreads(__tstate);
14398 if (PyErr_Occurred()) SWIG_fail;
14399 }
14400 resultobj = result;
14401 return resultobj;
14402 fail:
14403 return NULL;
14404 }
14405
14406
14407 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14408 PyObject *resultobj;
14409 wxFileType *arg1 = (wxFileType *) 0 ;
14410 PyObject *result;
14411 PyObject * obj0 = 0 ;
14412 char *kwnames[] = {
14413 (char *) "self", NULL
14414 };
14415
14416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14418 if (SWIG_arg_fail(1)) SWIG_fail;
14419 {
14420 PyThreadState* __tstate = wxPyBeginAllowThreads();
14421 result = (PyObject *)wxFileType_GetDescription(arg1);
14422
14423 wxPyEndAllowThreads(__tstate);
14424 if (PyErr_Occurred()) SWIG_fail;
14425 }
14426 resultobj = result;
14427 return resultobj;
14428 fail:
14429 return NULL;
14430 }
14431
14432
14433 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14434 PyObject *resultobj;
14435 wxFileType *arg1 = (wxFileType *) 0 ;
14436 wxString *arg2 = 0 ;
14437 wxString const &arg3_defvalue = wxPyEmptyString ;
14438 wxString *arg3 = (wxString *) &arg3_defvalue ;
14439 PyObject *result;
14440 bool temp2 = false ;
14441 bool temp3 = false ;
14442 PyObject * obj0 = 0 ;
14443 PyObject * obj1 = 0 ;
14444 PyObject * obj2 = 0 ;
14445 char *kwnames[] = {
14446 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14447 };
14448
14449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14451 if (SWIG_arg_fail(1)) SWIG_fail;
14452 {
14453 arg2 = wxString_in_helper(obj1);
14454 if (arg2 == NULL) SWIG_fail;
14455 temp2 = true;
14456 }
14457 if (obj2) {
14458 {
14459 arg3 = wxString_in_helper(obj2);
14460 if (arg3 == NULL) SWIG_fail;
14461 temp3 = true;
14462 }
14463 }
14464 {
14465 PyThreadState* __tstate = wxPyBeginAllowThreads();
14466 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14467
14468 wxPyEndAllowThreads(__tstate);
14469 if (PyErr_Occurred()) SWIG_fail;
14470 }
14471 resultobj = result;
14472 {
14473 if (temp2)
14474 delete arg2;
14475 }
14476 {
14477 if (temp3)
14478 delete arg3;
14479 }
14480 return resultobj;
14481 fail:
14482 {
14483 if (temp2)
14484 delete arg2;
14485 }
14486 {
14487 if (temp3)
14488 delete arg3;
14489 }
14490 return NULL;
14491 }
14492
14493
14494 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14495 PyObject *resultobj;
14496 wxFileType *arg1 = (wxFileType *) 0 ;
14497 wxString *arg2 = 0 ;
14498 wxString const &arg3_defvalue = wxPyEmptyString ;
14499 wxString *arg3 = (wxString *) &arg3_defvalue ;
14500 PyObject *result;
14501 bool temp2 = false ;
14502 bool temp3 = false ;
14503 PyObject * obj0 = 0 ;
14504 PyObject * obj1 = 0 ;
14505 PyObject * obj2 = 0 ;
14506 char *kwnames[] = {
14507 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14508 };
14509
14510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14512 if (SWIG_arg_fail(1)) SWIG_fail;
14513 {
14514 arg2 = wxString_in_helper(obj1);
14515 if (arg2 == NULL) SWIG_fail;
14516 temp2 = true;
14517 }
14518 if (obj2) {
14519 {
14520 arg3 = wxString_in_helper(obj2);
14521 if (arg3 == NULL) SWIG_fail;
14522 temp3 = true;
14523 }
14524 }
14525 {
14526 PyThreadState* __tstate = wxPyBeginAllowThreads();
14527 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14528
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 resultobj = result;
14533 {
14534 if (temp2)
14535 delete arg2;
14536 }
14537 {
14538 if (temp3)
14539 delete arg3;
14540 }
14541 return resultobj;
14542 fail:
14543 {
14544 if (temp2)
14545 delete arg2;
14546 }
14547 {
14548 if (temp3)
14549 delete arg3;
14550 }
14551 return NULL;
14552 }
14553
14554
14555 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14556 PyObject *resultobj;
14557 wxFileType *arg1 = (wxFileType *) 0 ;
14558 wxString *arg2 = 0 ;
14559 wxString const &arg3_defvalue = wxPyEmptyString ;
14560 wxString *arg3 = (wxString *) &arg3_defvalue ;
14561 PyObject *result;
14562 bool temp2 = false ;
14563 bool temp3 = false ;
14564 PyObject * obj0 = 0 ;
14565 PyObject * obj1 = 0 ;
14566 PyObject * obj2 = 0 ;
14567 char *kwnames[] = {
14568 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14569 };
14570
14571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14573 if (SWIG_arg_fail(1)) SWIG_fail;
14574 {
14575 arg2 = wxString_in_helper(obj1);
14576 if (arg2 == NULL) SWIG_fail;
14577 temp2 = true;
14578 }
14579 if (obj2) {
14580 {
14581 arg3 = wxString_in_helper(obj2);
14582 if (arg3 == NULL) SWIG_fail;
14583 temp3 = true;
14584 }
14585 }
14586 {
14587 PyThreadState* __tstate = wxPyBeginAllowThreads();
14588 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14589
14590 wxPyEndAllowThreads(__tstate);
14591 if (PyErr_Occurred()) SWIG_fail;
14592 }
14593 resultobj = result;
14594 {
14595 if (temp2)
14596 delete arg2;
14597 }
14598 {
14599 if (temp3)
14600 delete arg3;
14601 }
14602 return resultobj;
14603 fail:
14604 {
14605 if (temp2)
14606 delete arg2;
14607 }
14608 {
14609 if (temp3)
14610 delete arg3;
14611 }
14612 return NULL;
14613 }
14614
14615
14616 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14617 PyObject *resultobj;
14618 wxFileType *arg1 = (wxFileType *) 0 ;
14619 wxString *arg2 = 0 ;
14620 wxString *arg3 = 0 ;
14621 bool arg4 = (bool) true ;
14622 bool result;
14623 bool temp2 = false ;
14624 bool temp3 = false ;
14625 PyObject * obj0 = 0 ;
14626 PyObject * obj1 = 0 ;
14627 PyObject * obj2 = 0 ;
14628 PyObject * obj3 = 0 ;
14629 char *kwnames[] = {
14630 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14631 };
14632
14633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14635 if (SWIG_arg_fail(1)) SWIG_fail;
14636 {
14637 arg2 = wxString_in_helper(obj1);
14638 if (arg2 == NULL) SWIG_fail;
14639 temp2 = true;
14640 }
14641 {
14642 arg3 = wxString_in_helper(obj2);
14643 if (arg3 == NULL) SWIG_fail;
14644 temp3 = true;
14645 }
14646 if (obj3) {
14647 {
14648 arg4 = (bool)(SWIG_As_bool(obj3));
14649 if (SWIG_arg_fail(4)) SWIG_fail;
14650 }
14651 }
14652 {
14653 PyThreadState* __tstate = wxPyBeginAllowThreads();
14654 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14655
14656 wxPyEndAllowThreads(__tstate);
14657 if (PyErr_Occurred()) SWIG_fail;
14658 }
14659 {
14660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14661 }
14662 {
14663 if (temp2)
14664 delete arg2;
14665 }
14666 {
14667 if (temp3)
14668 delete arg3;
14669 }
14670 return resultobj;
14671 fail:
14672 {
14673 if (temp2)
14674 delete arg2;
14675 }
14676 {
14677 if (temp3)
14678 delete arg3;
14679 }
14680 return NULL;
14681 }
14682
14683
14684 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14685 PyObject *resultobj;
14686 wxFileType *arg1 = (wxFileType *) 0 ;
14687 wxString const &arg2_defvalue = wxPyEmptyString ;
14688 wxString *arg2 = (wxString *) &arg2_defvalue ;
14689 int arg3 = (int) 0 ;
14690 bool result;
14691 bool temp2 = false ;
14692 PyObject * obj0 = 0 ;
14693 PyObject * obj1 = 0 ;
14694 PyObject * obj2 = 0 ;
14695 char *kwnames[] = {
14696 (char *) "self",(char *) "cmd",(char *) "index", NULL
14697 };
14698
14699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14701 if (SWIG_arg_fail(1)) SWIG_fail;
14702 if (obj1) {
14703 {
14704 arg2 = wxString_in_helper(obj1);
14705 if (arg2 == NULL) SWIG_fail;
14706 temp2 = true;
14707 }
14708 }
14709 if (obj2) {
14710 {
14711 arg3 = (int)(SWIG_As_int(obj2));
14712 if (SWIG_arg_fail(3)) SWIG_fail;
14713 }
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14718
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 {
14723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14724 }
14725 {
14726 if (temp2)
14727 delete arg2;
14728 }
14729 return resultobj;
14730 fail:
14731 {
14732 if (temp2)
14733 delete arg2;
14734 }
14735 return NULL;
14736 }
14737
14738
14739 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14740 PyObject *resultobj;
14741 wxFileType *arg1 = (wxFileType *) 0 ;
14742 bool result;
14743 PyObject * obj0 = 0 ;
14744 char *kwnames[] = {
14745 (char *) "self", NULL
14746 };
14747
14748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14750 if (SWIG_arg_fail(1)) SWIG_fail;
14751 {
14752 PyThreadState* __tstate = wxPyBeginAllowThreads();
14753 result = (bool)(arg1)->Unassociate();
14754
14755 wxPyEndAllowThreads(__tstate);
14756 if (PyErr_Occurred()) SWIG_fail;
14757 }
14758 {
14759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14760 }
14761 return resultobj;
14762 fail:
14763 return NULL;
14764 }
14765
14766
14767 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14768 PyObject *resultobj;
14769 wxString *arg1 = 0 ;
14770 wxString *arg2 = 0 ;
14771 wxString const &arg3_defvalue = wxPyEmptyString ;
14772 wxString *arg3 = (wxString *) &arg3_defvalue ;
14773 wxString result;
14774 bool temp1 = false ;
14775 bool temp2 = false ;
14776 bool temp3 = false ;
14777 PyObject * obj0 = 0 ;
14778 PyObject * obj1 = 0 ;
14779 PyObject * obj2 = 0 ;
14780 char *kwnames[] = {
14781 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14782 };
14783
14784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14785 {
14786 arg1 = wxString_in_helper(obj0);
14787 if (arg1 == NULL) SWIG_fail;
14788 temp1 = true;
14789 }
14790 {
14791 arg2 = wxString_in_helper(obj1);
14792 if (arg2 == NULL) SWIG_fail;
14793 temp2 = true;
14794 }
14795 if (obj2) {
14796 {
14797 arg3 = wxString_in_helper(obj2);
14798 if (arg3 == NULL) SWIG_fail;
14799 temp3 = true;
14800 }
14801 }
14802 {
14803 PyThreadState* __tstate = wxPyBeginAllowThreads();
14804 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14805
14806 wxPyEndAllowThreads(__tstate);
14807 if (PyErr_Occurred()) SWIG_fail;
14808 }
14809 {
14810 #if wxUSE_UNICODE
14811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14812 #else
14813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14814 #endif
14815 }
14816 {
14817 if (temp1)
14818 delete arg1;
14819 }
14820 {
14821 if (temp2)
14822 delete arg2;
14823 }
14824 {
14825 if (temp3)
14826 delete arg3;
14827 }
14828 return resultobj;
14829 fail:
14830 {
14831 if (temp1)
14832 delete arg1;
14833 }
14834 {
14835 if (temp2)
14836 delete arg2;
14837 }
14838 {
14839 if (temp3)
14840 delete arg3;
14841 }
14842 return NULL;
14843 }
14844
14845
14846 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14847 PyObject *obj;
14848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14849 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14850 Py_INCREF(obj);
14851 return Py_BuildValue((char *)"");
14852 }
14853 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14854 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14855 return 1;
14856 }
14857
14858
14859 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14860 PyObject *pyobj;
14861
14862 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14863 return pyobj;
14864 }
14865
14866
14867 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14868 PyObject *resultobj;
14869 wxString *arg1 = 0 ;
14870 wxString *arg2 = 0 ;
14871 bool result;
14872 bool temp1 = false ;
14873 bool temp2 = false ;
14874 PyObject * obj0 = 0 ;
14875 PyObject * obj1 = 0 ;
14876 char *kwnames[] = {
14877 (char *) "mimeType",(char *) "wildcard", NULL
14878 };
14879
14880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14881 {
14882 arg1 = wxString_in_helper(obj0);
14883 if (arg1 == NULL) SWIG_fail;
14884 temp1 = true;
14885 }
14886 {
14887 arg2 = wxString_in_helper(obj1);
14888 if (arg2 == NULL) SWIG_fail;
14889 temp2 = true;
14890 }
14891 {
14892 PyThreadState* __tstate = wxPyBeginAllowThreads();
14893 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14894
14895 wxPyEndAllowThreads(__tstate);
14896 if (PyErr_Occurred()) SWIG_fail;
14897 }
14898 {
14899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14900 }
14901 {
14902 if (temp1)
14903 delete arg1;
14904 }
14905 {
14906 if (temp2)
14907 delete arg2;
14908 }
14909 return resultobj;
14910 fail:
14911 {
14912 if (temp1)
14913 delete arg1;
14914 }
14915 {
14916 if (temp2)
14917 delete arg2;
14918 }
14919 return NULL;
14920 }
14921
14922
14923 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14924 PyObject *resultobj;
14925 wxMimeTypesManager *result;
14926 char *kwnames[] = {
14927 NULL
14928 };
14929
14930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14931 {
14932 PyThreadState* __tstate = wxPyBeginAllowThreads();
14933 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14934
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14939 return resultobj;
14940 fail:
14941 return NULL;
14942 }
14943
14944
14945 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14946 PyObject *resultobj;
14947 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14948 int arg2 = (int) wxMAILCAP_ALL ;
14949 wxString const &arg3_defvalue = wxPyEmptyString ;
14950 wxString *arg3 = (wxString *) &arg3_defvalue ;
14951 bool temp3 = false ;
14952 PyObject * obj0 = 0 ;
14953 PyObject * obj1 = 0 ;
14954 PyObject * obj2 = 0 ;
14955 char *kwnames[] = {
14956 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14957 };
14958
14959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14961 if (SWIG_arg_fail(1)) SWIG_fail;
14962 if (obj1) {
14963 {
14964 arg2 = (int)(SWIG_As_int(obj1));
14965 if (SWIG_arg_fail(2)) SWIG_fail;
14966 }
14967 }
14968 if (obj2) {
14969 {
14970 arg3 = wxString_in_helper(obj2);
14971 if (arg3 == NULL) SWIG_fail;
14972 temp3 = true;
14973 }
14974 }
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14978
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 Py_INCREF(Py_None); resultobj = Py_None;
14983 {
14984 if (temp3)
14985 delete arg3;
14986 }
14987 return resultobj;
14988 fail:
14989 {
14990 if (temp3)
14991 delete arg3;
14992 }
14993 return NULL;
14994 }
14995
14996
14997 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj;
14999 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15000 PyObject * obj0 = 0 ;
15001 char *kwnames[] = {
15002 (char *) "self", NULL
15003 };
15004
15005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15007 if (SWIG_arg_fail(1)) SWIG_fail;
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 (arg1)->ClearData();
15011
15012 wxPyEndAllowThreads(__tstate);
15013 if (PyErr_Occurred()) SWIG_fail;
15014 }
15015 Py_INCREF(Py_None); resultobj = Py_None;
15016 return resultobj;
15017 fail:
15018 return NULL;
15019 }
15020
15021
15022 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj;
15024 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15025 wxString *arg2 = 0 ;
15026 wxFileType *result;
15027 bool temp2 = false ;
15028 PyObject * obj0 = 0 ;
15029 PyObject * obj1 = 0 ;
15030 char *kwnames[] = {
15031 (char *) "self",(char *) "ext", NULL
15032 };
15033
15034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15036 if (SWIG_arg_fail(1)) SWIG_fail;
15037 {
15038 arg2 = wxString_in_helper(obj1);
15039 if (arg2 == NULL) SWIG_fail;
15040 temp2 = true;
15041 }
15042 {
15043 PyThreadState* __tstate = wxPyBeginAllowThreads();
15044 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15045
15046 wxPyEndAllowThreads(__tstate);
15047 if (PyErr_Occurred()) SWIG_fail;
15048 }
15049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15050 {
15051 if (temp2)
15052 delete arg2;
15053 }
15054 return resultobj;
15055 fail:
15056 {
15057 if (temp2)
15058 delete arg2;
15059 }
15060 return NULL;
15061 }
15062
15063
15064 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj;
15066 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15067 wxString *arg2 = 0 ;
15068 wxFileType *result;
15069 bool temp2 = false ;
15070 PyObject * obj0 = 0 ;
15071 PyObject * obj1 = 0 ;
15072 char *kwnames[] = {
15073 (char *) "self",(char *) "mimeType", NULL
15074 };
15075
15076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15078 if (SWIG_arg_fail(1)) SWIG_fail;
15079 {
15080 arg2 = wxString_in_helper(obj1);
15081 if (arg2 == NULL) SWIG_fail;
15082 temp2 = true;
15083 }
15084 {
15085 PyThreadState* __tstate = wxPyBeginAllowThreads();
15086 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15087
15088 wxPyEndAllowThreads(__tstate);
15089 if (PyErr_Occurred()) SWIG_fail;
15090 }
15091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15092 {
15093 if (temp2)
15094 delete arg2;
15095 }
15096 return resultobj;
15097 fail:
15098 {
15099 if (temp2)
15100 delete arg2;
15101 }
15102 return NULL;
15103 }
15104
15105
15106 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15107 PyObject *resultobj;
15108 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15109 wxString *arg2 = 0 ;
15110 bool arg3 = (bool) false ;
15111 bool result;
15112 bool temp2 = false ;
15113 PyObject * obj0 = 0 ;
15114 PyObject * obj1 = 0 ;
15115 PyObject * obj2 = 0 ;
15116 char *kwnames[] = {
15117 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15118 };
15119
15120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15122 if (SWIG_arg_fail(1)) SWIG_fail;
15123 {
15124 arg2 = wxString_in_helper(obj1);
15125 if (arg2 == NULL) SWIG_fail;
15126 temp2 = true;
15127 }
15128 if (obj2) {
15129 {
15130 arg3 = (bool)(SWIG_As_bool(obj2));
15131 if (SWIG_arg_fail(3)) SWIG_fail;
15132 }
15133 }
15134 {
15135 PyThreadState* __tstate = wxPyBeginAllowThreads();
15136 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15137
15138 wxPyEndAllowThreads(__tstate);
15139 if (PyErr_Occurred()) SWIG_fail;
15140 }
15141 {
15142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15143 }
15144 {
15145 if (temp2)
15146 delete arg2;
15147 }
15148 return resultobj;
15149 fail:
15150 {
15151 if (temp2)
15152 delete arg2;
15153 }
15154 return NULL;
15155 }
15156
15157
15158 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15159 PyObject *resultobj;
15160 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15161 wxString *arg2 = 0 ;
15162 bool result;
15163 bool temp2 = false ;
15164 PyObject * obj0 = 0 ;
15165 PyObject * obj1 = 0 ;
15166 char *kwnames[] = {
15167 (char *) "self",(char *) "filename", NULL
15168 };
15169
15170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15172 if (SWIG_arg_fail(1)) SWIG_fail;
15173 {
15174 arg2 = wxString_in_helper(obj1);
15175 if (arg2 == NULL) SWIG_fail;
15176 temp2 = true;
15177 }
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15181
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 {
15186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15187 }
15188 {
15189 if (temp2)
15190 delete arg2;
15191 }
15192 return resultobj;
15193 fail:
15194 {
15195 if (temp2)
15196 delete arg2;
15197 }
15198 return NULL;
15199 }
15200
15201
15202 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15203 PyObject *resultobj;
15204 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15205 PyObject *result;
15206 PyObject * obj0 = 0 ;
15207 char *kwnames[] = {
15208 (char *) "self", NULL
15209 };
15210
15211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15213 if (SWIG_arg_fail(1)) SWIG_fail;
15214 {
15215 PyThreadState* __tstate = wxPyBeginAllowThreads();
15216 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15217
15218 wxPyEndAllowThreads(__tstate);
15219 if (PyErr_Occurred()) SWIG_fail;
15220 }
15221 resultobj = result;
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj;
15230 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15231 wxFileTypeInfo *arg2 = 0 ;
15232 PyObject * obj0 = 0 ;
15233 PyObject * obj1 = 0 ;
15234 char *kwnames[] = {
15235 (char *) "self",(char *) "ft", NULL
15236 };
15237
15238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15240 if (SWIG_arg_fail(1)) SWIG_fail;
15241 {
15242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15243 if (SWIG_arg_fail(2)) SWIG_fail;
15244 if (arg2 == NULL) {
15245 SWIG_null_ref("wxFileTypeInfo");
15246 }
15247 if (SWIG_arg_fail(2)) SWIG_fail;
15248 }
15249 {
15250 PyThreadState* __tstate = wxPyBeginAllowThreads();
15251 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15252
15253 wxPyEndAllowThreads(__tstate);
15254 if (PyErr_Occurred()) SWIG_fail;
15255 }
15256 Py_INCREF(Py_None); resultobj = Py_None;
15257 return resultobj;
15258 fail:
15259 return NULL;
15260 }
15261
15262
15263 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15264 PyObject *resultobj;
15265 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15266 wxFileTypeInfo *arg2 = 0 ;
15267 wxFileType *result;
15268 PyObject * obj0 = 0 ;
15269 PyObject * obj1 = 0 ;
15270 char *kwnames[] = {
15271 (char *) "self",(char *) "ftInfo", NULL
15272 };
15273
15274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15276 if (SWIG_arg_fail(1)) SWIG_fail;
15277 {
15278 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15279 if (SWIG_arg_fail(2)) SWIG_fail;
15280 if (arg2 == NULL) {
15281 SWIG_null_ref("wxFileTypeInfo");
15282 }
15283 if (SWIG_arg_fail(2)) SWIG_fail;
15284 }
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15288
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15300 PyObject *resultobj;
15301 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15302 wxFileType *arg2 = (wxFileType *) 0 ;
15303 bool result;
15304 PyObject * obj0 = 0 ;
15305 PyObject * obj1 = 0 ;
15306 char *kwnames[] = {
15307 (char *) "self",(char *) "ft", NULL
15308 };
15309
15310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15312 if (SWIG_arg_fail(1)) SWIG_fail;
15313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15314 if (SWIG_arg_fail(2)) SWIG_fail;
15315 {
15316 PyThreadState* __tstate = wxPyBeginAllowThreads();
15317 result = (bool)(arg1)->Unassociate(arg2);
15318
15319 wxPyEndAllowThreads(__tstate);
15320 if (PyErr_Occurred()) SWIG_fail;
15321 }
15322 {
15323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15324 }
15325 return resultobj;
15326 fail:
15327 return NULL;
15328 }
15329
15330
15331 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15332 PyObject *resultobj;
15333 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15334 PyObject * obj0 = 0 ;
15335 char *kwnames[] = {
15336 (char *) "self", NULL
15337 };
15338
15339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15341 if (SWIG_arg_fail(1)) SWIG_fail;
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 delete arg1;
15345
15346 wxPyEndAllowThreads(__tstate);
15347 if (PyErr_Occurred()) SWIG_fail;
15348 }
15349 Py_INCREF(Py_None); resultobj = Py_None;
15350 return resultobj;
15351 fail:
15352 return NULL;
15353 }
15354
15355
15356 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15357 PyObject *obj;
15358 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15359 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15360 Py_INCREF(obj);
15361 return Py_BuildValue((char *)"");
15362 }
15363 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15364 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15365 return 1;
15366 }
15367
15368
15369 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15370 PyObject *pyobj;
15371
15372 {
15373 #if wxUSE_UNICODE
15374 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15375 #else
15376 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15377 #endif
15378 }
15379 return pyobj;
15380 }
15381
15382
15383 static int _wrap_ART_MENU_set(PyObject *) {
15384 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15385 return 1;
15386 }
15387
15388
15389 static PyObject *_wrap_ART_MENU_get(void) {
15390 PyObject *pyobj;
15391
15392 {
15393 #if wxUSE_UNICODE
15394 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15395 #else
15396 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15397 #endif
15398 }
15399 return pyobj;
15400 }
15401
15402
15403 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15404 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15405 return 1;
15406 }
15407
15408
15409 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15410 PyObject *pyobj;
15411
15412 {
15413 #if wxUSE_UNICODE
15414 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15415 #else
15416 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15417 #endif
15418 }
15419 return pyobj;
15420 }
15421
15422
15423 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15424 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15425 return 1;
15426 }
15427
15428
15429 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15430 PyObject *pyobj;
15431
15432 {
15433 #if wxUSE_UNICODE
15434 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15435 #else
15436 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15437 #endif
15438 }
15439 return pyobj;
15440 }
15441
15442
15443 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15444 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15445 return 1;
15446 }
15447
15448
15449 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15450 PyObject *pyobj;
15451
15452 {
15453 #if wxUSE_UNICODE
15454 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15455 #else
15456 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15457 #endif
15458 }
15459 return pyobj;
15460 }
15461
15462
15463 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15464 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15465 return 1;
15466 }
15467
15468
15469 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15470 PyObject *pyobj;
15471
15472 {
15473 #if wxUSE_UNICODE
15474 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15475 #else
15476 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15477 #endif
15478 }
15479 return pyobj;
15480 }
15481
15482
15483 static int _wrap_ART_BUTTON_set(PyObject *) {
15484 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15485 return 1;
15486 }
15487
15488
15489 static PyObject *_wrap_ART_BUTTON_get(void) {
15490 PyObject *pyobj;
15491
15492 {
15493 #if wxUSE_UNICODE
15494 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15495 #else
15496 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15497 #endif
15498 }
15499 return pyobj;
15500 }
15501
15502
15503 static int _wrap_ART_OTHER_set(PyObject *) {
15504 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15505 return 1;
15506 }
15507
15508
15509 static PyObject *_wrap_ART_OTHER_get(void) {
15510 PyObject *pyobj;
15511
15512 {
15513 #if wxUSE_UNICODE
15514 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15515 #else
15516 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15517 #endif
15518 }
15519 return pyobj;
15520 }
15521
15522
15523 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15524 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15525 return 1;
15526 }
15527
15528
15529 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15530 PyObject *pyobj;
15531
15532 {
15533 #if wxUSE_UNICODE
15534 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15535 #else
15536 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15537 #endif
15538 }
15539 return pyobj;
15540 }
15541
15542
15543 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15544 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15545 return 1;
15546 }
15547
15548
15549 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15550 PyObject *pyobj;
15551
15552 {
15553 #if wxUSE_UNICODE
15554 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15555 #else
15556 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15557 #endif
15558 }
15559 return pyobj;
15560 }
15561
15562
15563 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15564 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15565 return 1;
15566 }
15567
15568
15569 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15570 PyObject *pyobj;
15571
15572 {
15573 #if wxUSE_UNICODE
15574 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15575 #else
15576 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15577 #endif
15578 }
15579 return pyobj;
15580 }
15581
15582
15583 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15584 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15585 return 1;
15586 }
15587
15588
15589 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15590 PyObject *pyobj;
15591
15592 {
15593 #if wxUSE_UNICODE
15594 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15595 #else
15596 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15597 #endif
15598 }
15599 return pyobj;
15600 }
15601
15602
15603 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15604 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15605 return 1;
15606 }
15607
15608
15609 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15610 PyObject *pyobj;
15611
15612 {
15613 #if wxUSE_UNICODE
15614 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15615 #else
15616 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15617 #endif
15618 }
15619 return pyobj;
15620 }
15621
15622
15623 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15624 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15625 return 1;
15626 }
15627
15628
15629 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15630 PyObject *pyobj;
15631
15632 {
15633 #if wxUSE_UNICODE
15634 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15635 #else
15636 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15637 #endif
15638 }
15639 return pyobj;
15640 }
15641
15642
15643 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15644 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15645 return 1;
15646 }
15647
15648
15649 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15650 PyObject *pyobj;
15651
15652 {
15653 #if wxUSE_UNICODE
15654 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15655 #else
15656 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15657 #endif
15658 }
15659 return pyobj;
15660 }
15661
15662
15663 static int _wrap_ART_GO_BACK_set(PyObject *) {
15664 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15665 return 1;
15666 }
15667
15668
15669 static PyObject *_wrap_ART_GO_BACK_get(void) {
15670 PyObject *pyobj;
15671
15672 {
15673 #if wxUSE_UNICODE
15674 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15675 #else
15676 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15677 #endif
15678 }
15679 return pyobj;
15680 }
15681
15682
15683 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15684 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15685 return 1;
15686 }
15687
15688
15689 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15690 PyObject *pyobj;
15691
15692 {
15693 #if wxUSE_UNICODE
15694 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15695 #else
15696 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15697 #endif
15698 }
15699 return pyobj;
15700 }
15701
15702
15703 static int _wrap_ART_GO_UP_set(PyObject *) {
15704 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15705 return 1;
15706 }
15707
15708
15709 static PyObject *_wrap_ART_GO_UP_get(void) {
15710 PyObject *pyobj;
15711
15712 {
15713 #if wxUSE_UNICODE
15714 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15715 #else
15716 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15717 #endif
15718 }
15719 return pyobj;
15720 }
15721
15722
15723 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15724 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15725 return 1;
15726 }
15727
15728
15729 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15730 PyObject *pyobj;
15731
15732 {
15733 #if wxUSE_UNICODE
15734 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15735 #else
15736 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15737 #endif
15738 }
15739 return pyobj;
15740 }
15741
15742
15743 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15744 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15745 return 1;
15746 }
15747
15748
15749 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15750 PyObject *pyobj;
15751
15752 {
15753 #if wxUSE_UNICODE
15754 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15755 #else
15756 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15757 #endif
15758 }
15759 return pyobj;
15760 }
15761
15762
15763 static int _wrap_ART_GO_HOME_set(PyObject *) {
15764 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15765 return 1;
15766 }
15767
15768
15769 static PyObject *_wrap_ART_GO_HOME_get(void) {
15770 PyObject *pyobj;
15771
15772 {
15773 #if wxUSE_UNICODE
15774 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15775 #else
15776 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15777 #endif
15778 }
15779 return pyobj;
15780 }
15781
15782
15783 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15784 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15785 return 1;
15786 }
15787
15788
15789 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15790 PyObject *pyobj;
15791
15792 {
15793 #if wxUSE_UNICODE
15794 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15795 #else
15796 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15797 #endif
15798 }
15799 return pyobj;
15800 }
15801
15802
15803 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15804 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15805 return 1;
15806 }
15807
15808
15809 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15810 PyObject *pyobj;
15811
15812 {
15813 #if wxUSE_UNICODE
15814 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15815 #else
15816 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15817 #endif
15818 }
15819 return pyobj;
15820 }
15821
15822
15823 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15824 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15825 return 1;
15826 }
15827
15828
15829 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15830 PyObject *pyobj;
15831
15832 {
15833 #if wxUSE_UNICODE
15834 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15835 #else
15836 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15837 #endif
15838 }
15839 return pyobj;
15840 }
15841
15842
15843 static int _wrap_ART_PRINT_set(PyObject *) {
15844 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15845 return 1;
15846 }
15847
15848
15849 static PyObject *_wrap_ART_PRINT_get(void) {
15850 PyObject *pyobj;
15851
15852 {
15853 #if wxUSE_UNICODE
15854 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15855 #else
15856 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15857 #endif
15858 }
15859 return pyobj;
15860 }
15861
15862
15863 static int _wrap_ART_HELP_set(PyObject *) {
15864 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15865 return 1;
15866 }
15867
15868
15869 static PyObject *_wrap_ART_HELP_get(void) {
15870 PyObject *pyobj;
15871
15872 {
15873 #if wxUSE_UNICODE
15874 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15875 #else
15876 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15877 #endif
15878 }
15879 return pyobj;
15880 }
15881
15882
15883 static int _wrap_ART_TIP_set(PyObject *) {
15884 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15885 return 1;
15886 }
15887
15888
15889 static PyObject *_wrap_ART_TIP_get(void) {
15890 PyObject *pyobj;
15891
15892 {
15893 #if wxUSE_UNICODE
15894 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15895 #else
15896 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15897 #endif
15898 }
15899 return pyobj;
15900 }
15901
15902
15903 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15904 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15905 return 1;
15906 }
15907
15908
15909 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15910 PyObject *pyobj;
15911
15912 {
15913 #if wxUSE_UNICODE
15914 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15915 #else
15916 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15917 #endif
15918 }
15919 return pyobj;
15920 }
15921
15922
15923 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15924 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15925 return 1;
15926 }
15927
15928
15929 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15930 PyObject *pyobj;
15931
15932 {
15933 #if wxUSE_UNICODE
15934 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15935 #else
15936 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15937 #endif
15938 }
15939 return pyobj;
15940 }
15941
15942
15943 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15944 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15945 return 1;
15946 }
15947
15948
15949 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15950 PyObject *pyobj;
15951
15952 {
15953 #if wxUSE_UNICODE
15954 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15955 #else
15956 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15957 #endif
15958 }
15959 return pyobj;
15960 }
15961
15962
15963 static int _wrap_ART_HARDDISK_set(PyObject *) {
15964 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15965 return 1;
15966 }
15967
15968
15969 static PyObject *_wrap_ART_HARDDISK_get(void) {
15970 PyObject *pyobj;
15971
15972 {
15973 #if wxUSE_UNICODE
15974 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15975 #else
15976 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15977 #endif
15978 }
15979 return pyobj;
15980 }
15981
15982
15983 static int _wrap_ART_FLOPPY_set(PyObject *) {
15984 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15985 return 1;
15986 }
15987
15988
15989 static PyObject *_wrap_ART_FLOPPY_get(void) {
15990 PyObject *pyobj;
15991
15992 {
15993 #if wxUSE_UNICODE
15994 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15995 #else
15996 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15997 #endif
15998 }
15999 return pyobj;
16000 }
16001
16002
16003 static int _wrap_ART_CDROM_set(PyObject *) {
16004 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16005 return 1;
16006 }
16007
16008
16009 static PyObject *_wrap_ART_CDROM_get(void) {
16010 PyObject *pyobj;
16011
16012 {
16013 #if wxUSE_UNICODE
16014 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16015 #else
16016 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16017 #endif
16018 }
16019 return pyobj;
16020 }
16021
16022
16023 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16024 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16025 return 1;
16026 }
16027
16028
16029 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16030 PyObject *pyobj;
16031
16032 {
16033 #if wxUSE_UNICODE
16034 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16035 #else
16036 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16037 #endif
16038 }
16039 return pyobj;
16040 }
16041
16042
16043 static int _wrap_ART_FOLDER_set(PyObject *) {
16044 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16045 return 1;
16046 }
16047
16048
16049 static PyObject *_wrap_ART_FOLDER_get(void) {
16050 PyObject *pyobj;
16051
16052 {
16053 #if wxUSE_UNICODE
16054 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16055 #else
16056 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16057 #endif
16058 }
16059 return pyobj;
16060 }
16061
16062
16063 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16064 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16065 return 1;
16066 }
16067
16068
16069 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16070 PyObject *pyobj;
16071
16072 {
16073 #if wxUSE_UNICODE
16074 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16075 #else
16076 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16077 #endif
16078 }
16079 return pyobj;
16080 }
16081
16082
16083 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16084 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16085 return 1;
16086 }
16087
16088
16089 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16090 PyObject *pyobj;
16091
16092 {
16093 #if wxUSE_UNICODE
16094 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16095 #else
16096 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16097 #endif
16098 }
16099 return pyobj;
16100 }
16101
16102
16103 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16104 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16105 return 1;
16106 }
16107
16108
16109 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16110 PyObject *pyobj;
16111
16112 {
16113 #if wxUSE_UNICODE
16114 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16115 #else
16116 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16117 #endif
16118 }
16119 return pyobj;
16120 }
16121
16122
16123 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16124 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16125 return 1;
16126 }
16127
16128
16129 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16130 PyObject *pyobj;
16131
16132 {
16133 #if wxUSE_UNICODE
16134 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16135 #else
16136 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16137 #endif
16138 }
16139 return pyobj;
16140 }
16141
16142
16143 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16144 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16145 return 1;
16146 }
16147
16148
16149 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16150 PyObject *pyobj;
16151
16152 {
16153 #if wxUSE_UNICODE
16154 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16155 #else
16156 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16157 #endif
16158 }
16159 return pyobj;
16160 }
16161
16162
16163 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16164 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16165 return 1;
16166 }
16167
16168
16169 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16170 PyObject *pyobj;
16171
16172 {
16173 #if wxUSE_UNICODE
16174 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16175 #else
16176 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16177 #endif
16178 }
16179 return pyobj;
16180 }
16181
16182
16183 static int _wrap_ART_ERROR_set(PyObject *) {
16184 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16185 return 1;
16186 }
16187
16188
16189 static PyObject *_wrap_ART_ERROR_get(void) {
16190 PyObject *pyobj;
16191
16192 {
16193 #if wxUSE_UNICODE
16194 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16195 #else
16196 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16197 #endif
16198 }
16199 return pyobj;
16200 }
16201
16202
16203 static int _wrap_ART_QUESTION_set(PyObject *) {
16204 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16205 return 1;
16206 }
16207
16208
16209 static PyObject *_wrap_ART_QUESTION_get(void) {
16210 PyObject *pyobj;
16211
16212 {
16213 #if wxUSE_UNICODE
16214 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16215 #else
16216 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16217 #endif
16218 }
16219 return pyobj;
16220 }
16221
16222
16223 static int _wrap_ART_WARNING_set(PyObject *) {
16224 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16225 return 1;
16226 }
16227
16228
16229 static PyObject *_wrap_ART_WARNING_get(void) {
16230 PyObject *pyobj;
16231
16232 {
16233 #if wxUSE_UNICODE
16234 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16235 #else
16236 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16237 #endif
16238 }
16239 return pyobj;
16240 }
16241
16242
16243 static int _wrap_ART_INFORMATION_set(PyObject *) {
16244 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16245 return 1;
16246 }
16247
16248
16249 static PyObject *_wrap_ART_INFORMATION_get(void) {
16250 PyObject *pyobj;
16251
16252 {
16253 #if wxUSE_UNICODE
16254 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16255 #else
16256 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16257 #endif
16258 }
16259 return pyobj;
16260 }
16261
16262
16263 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16264 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16265 return 1;
16266 }
16267
16268
16269 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16270 PyObject *pyobj;
16271
16272 {
16273 #if wxUSE_UNICODE
16274 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16275 #else
16276 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16277 #endif
16278 }
16279 return pyobj;
16280 }
16281
16282
16283 static int _wrap_ART_COPY_set(PyObject *) {
16284 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16285 return 1;
16286 }
16287
16288
16289 static PyObject *_wrap_ART_COPY_get(void) {
16290 PyObject *pyobj;
16291
16292 {
16293 #if wxUSE_UNICODE
16294 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16295 #else
16296 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16297 #endif
16298 }
16299 return pyobj;
16300 }
16301
16302
16303 static int _wrap_ART_CUT_set(PyObject *) {
16304 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16305 return 1;
16306 }
16307
16308
16309 static PyObject *_wrap_ART_CUT_get(void) {
16310 PyObject *pyobj;
16311
16312 {
16313 #if wxUSE_UNICODE
16314 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16315 #else
16316 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16317 #endif
16318 }
16319 return pyobj;
16320 }
16321
16322
16323 static int _wrap_ART_PASTE_set(PyObject *) {
16324 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16325 return 1;
16326 }
16327
16328
16329 static PyObject *_wrap_ART_PASTE_get(void) {
16330 PyObject *pyobj;
16331
16332 {
16333 #if wxUSE_UNICODE
16334 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16335 #else
16336 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16337 #endif
16338 }
16339 return pyobj;
16340 }
16341
16342
16343 static int _wrap_ART_DELETE_set(PyObject *) {
16344 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16345 return 1;
16346 }
16347
16348
16349 static PyObject *_wrap_ART_DELETE_get(void) {
16350 PyObject *pyobj;
16351
16352 {
16353 #if wxUSE_UNICODE
16354 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16355 #else
16356 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16357 #endif
16358 }
16359 return pyobj;
16360 }
16361
16362
16363 static int _wrap_ART_UNDO_set(PyObject *) {
16364 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16365 return 1;
16366 }
16367
16368
16369 static PyObject *_wrap_ART_UNDO_get(void) {
16370 PyObject *pyobj;
16371
16372 {
16373 #if wxUSE_UNICODE
16374 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16375 #else
16376 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16377 #endif
16378 }
16379 return pyobj;
16380 }
16381
16382
16383 static int _wrap_ART_REDO_set(PyObject *) {
16384 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16385 return 1;
16386 }
16387
16388
16389 static PyObject *_wrap_ART_REDO_get(void) {
16390 PyObject *pyobj;
16391
16392 {
16393 #if wxUSE_UNICODE
16394 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16395 #else
16396 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16397 #endif
16398 }
16399 return pyobj;
16400 }
16401
16402
16403 static int _wrap_ART_QUIT_set(PyObject *) {
16404 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16405 return 1;
16406 }
16407
16408
16409 static PyObject *_wrap_ART_QUIT_get(void) {
16410 PyObject *pyobj;
16411
16412 {
16413 #if wxUSE_UNICODE
16414 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16415 #else
16416 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16417 #endif
16418 }
16419 return pyobj;
16420 }
16421
16422
16423 static int _wrap_ART_FIND_set(PyObject *) {
16424 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16425 return 1;
16426 }
16427
16428
16429 static PyObject *_wrap_ART_FIND_get(void) {
16430 PyObject *pyobj;
16431
16432 {
16433 #if wxUSE_UNICODE
16434 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16435 #else
16436 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16437 #endif
16438 }
16439 return pyobj;
16440 }
16441
16442
16443 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16444 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16445 return 1;
16446 }
16447
16448
16449 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16450 PyObject *pyobj;
16451
16452 {
16453 #if wxUSE_UNICODE
16454 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16455 #else
16456 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16457 #endif
16458 }
16459 return pyobj;
16460 }
16461
16462
16463 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16464 PyObject *resultobj;
16465 wxPyArtProvider *result;
16466 char *kwnames[] = {
16467 NULL
16468 };
16469
16470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16471 {
16472 if (!wxPyCheckForApp()) SWIG_fail;
16473 PyThreadState* __tstate = wxPyBeginAllowThreads();
16474 result = (wxPyArtProvider *)new wxPyArtProvider();
16475
16476 wxPyEndAllowThreads(__tstate);
16477 if (PyErr_Occurred()) SWIG_fail;
16478 }
16479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16480 return resultobj;
16481 fail:
16482 return NULL;
16483 }
16484
16485
16486 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16487 PyObject *resultobj;
16488 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16489 PyObject *arg2 = (PyObject *) 0 ;
16490 PyObject *arg3 = (PyObject *) 0 ;
16491 PyObject * obj0 = 0 ;
16492 PyObject * obj1 = 0 ;
16493 PyObject * obj2 = 0 ;
16494 char *kwnames[] = {
16495 (char *) "self",(char *) "self",(char *) "_class", NULL
16496 };
16497
16498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16500 if (SWIG_arg_fail(1)) SWIG_fail;
16501 arg2 = obj1;
16502 arg3 = obj2;
16503 {
16504 PyThreadState* __tstate = wxPyBeginAllowThreads();
16505 (arg1)->_setCallbackInfo(arg2,arg3);
16506
16507 wxPyEndAllowThreads(__tstate);
16508 if (PyErr_Occurred()) SWIG_fail;
16509 }
16510 Py_INCREF(Py_None); resultobj = Py_None;
16511 return resultobj;
16512 fail:
16513 return NULL;
16514 }
16515
16516
16517 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16518 PyObject *resultobj;
16519 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16520 PyObject * obj0 = 0 ;
16521 char *kwnames[] = {
16522 (char *) "provider", NULL
16523 };
16524
16525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16527 if (SWIG_arg_fail(1)) SWIG_fail;
16528 {
16529 PyThreadState* __tstate = wxPyBeginAllowThreads();
16530 wxPyArtProvider::PushProvider(arg1);
16531
16532 wxPyEndAllowThreads(__tstate);
16533 if (PyErr_Occurred()) SWIG_fail;
16534 }
16535 Py_INCREF(Py_None); resultobj = Py_None;
16536 return resultobj;
16537 fail:
16538 return NULL;
16539 }
16540
16541
16542 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16543 PyObject *resultobj;
16544 bool result;
16545 char *kwnames[] = {
16546 NULL
16547 };
16548
16549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16550 {
16551 PyThreadState* __tstate = wxPyBeginAllowThreads();
16552 result = (bool)wxPyArtProvider::PopProvider();
16553
16554 wxPyEndAllowThreads(__tstate);
16555 if (PyErr_Occurred()) SWIG_fail;
16556 }
16557 {
16558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16559 }
16560 return resultobj;
16561 fail:
16562 return NULL;
16563 }
16564
16565
16566 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16567 PyObject *resultobj;
16568 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16569 bool result;
16570 PyObject * obj0 = 0 ;
16571 char *kwnames[] = {
16572 (char *) "provider", NULL
16573 };
16574
16575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16577 if (SWIG_arg_fail(1)) SWIG_fail;
16578 {
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16581
16582 wxPyEndAllowThreads(__tstate);
16583 if (PyErr_Occurred()) SWIG_fail;
16584 }
16585 {
16586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16587 }
16588 return resultobj;
16589 fail:
16590 return NULL;
16591 }
16592
16593
16594 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16595 PyObject *resultobj;
16596 wxString *arg1 = 0 ;
16597 wxString const &arg2_defvalue = wxPyART_OTHER ;
16598 wxString *arg2 = (wxString *) &arg2_defvalue ;
16599 wxSize const &arg3_defvalue = wxDefaultSize ;
16600 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16601 wxBitmap result;
16602 bool temp1 = false ;
16603 bool temp2 = false ;
16604 wxSize temp3 ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 PyObject * obj2 = 0 ;
16608 char *kwnames[] = {
16609 (char *) "id",(char *) "client",(char *) "size", NULL
16610 };
16611
16612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16613 {
16614 arg1 = wxString_in_helper(obj0);
16615 if (arg1 == NULL) SWIG_fail;
16616 temp1 = true;
16617 }
16618 if (obj1) {
16619 {
16620 arg2 = wxString_in_helper(obj1);
16621 if (arg2 == NULL) SWIG_fail;
16622 temp2 = true;
16623 }
16624 }
16625 if (obj2) {
16626 {
16627 arg3 = &temp3;
16628 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16629 }
16630 }
16631 {
16632 if (!wxPyCheckForApp()) SWIG_fail;
16633 PyThreadState* __tstate = wxPyBeginAllowThreads();
16634 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16635
16636 wxPyEndAllowThreads(__tstate);
16637 if (PyErr_Occurred()) SWIG_fail;
16638 }
16639 {
16640 wxBitmap * resultptr;
16641 resultptr = new wxBitmap((wxBitmap &)(result));
16642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16643 }
16644 {
16645 if (temp1)
16646 delete arg1;
16647 }
16648 {
16649 if (temp2)
16650 delete arg2;
16651 }
16652 return resultobj;
16653 fail:
16654 {
16655 if (temp1)
16656 delete arg1;
16657 }
16658 {
16659 if (temp2)
16660 delete arg2;
16661 }
16662 return NULL;
16663 }
16664
16665
16666 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16667 PyObject *resultobj;
16668 wxString *arg1 = 0 ;
16669 wxString const &arg2_defvalue = wxPyART_OTHER ;
16670 wxString *arg2 = (wxString *) &arg2_defvalue ;
16671 wxSize const &arg3_defvalue = wxDefaultSize ;
16672 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16673 wxIcon result;
16674 bool temp1 = false ;
16675 bool temp2 = false ;
16676 wxSize temp3 ;
16677 PyObject * obj0 = 0 ;
16678 PyObject * obj1 = 0 ;
16679 PyObject * obj2 = 0 ;
16680 char *kwnames[] = {
16681 (char *) "id",(char *) "client",(char *) "size", NULL
16682 };
16683
16684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16685 {
16686 arg1 = wxString_in_helper(obj0);
16687 if (arg1 == NULL) SWIG_fail;
16688 temp1 = true;
16689 }
16690 if (obj1) {
16691 {
16692 arg2 = wxString_in_helper(obj1);
16693 if (arg2 == NULL) SWIG_fail;
16694 temp2 = true;
16695 }
16696 }
16697 if (obj2) {
16698 {
16699 arg3 = &temp3;
16700 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16701 }
16702 }
16703 {
16704 if (!wxPyCheckForApp()) SWIG_fail;
16705 PyThreadState* __tstate = wxPyBeginAllowThreads();
16706 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16707
16708 wxPyEndAllowThreads(__tstate);
16709 if (PyErr_Occurred()) SWIG_fail;
16710 }
16711 {
16712 wxIcon * resultptr;
16713 resultptr = new wxIcon((wxIcon &)(result));
16714 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16715 }
16716 {
16717 if (temp1)
16718 delete arg1;
16719 }
16720 {
16721 if (temp2)
16722 delete arg2;
16723 }
16724 return resultobj;
16725 fail:
16726 {
16727 if (temp1)
16728 delete arg1;
16729 }
16730 {
16731 if (temp2)
16732 delete arg2;
16733 }
16734 return NULL;
16735 }
16736
16737
16738 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16739 PyObject *resultobj;
16740 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16741 PyObject * obj0 = 0 ;
16742 char *kwnames[] = {
16743 (char *) "self", NULL
16744 };
16745
16746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16748 if (SWIG_arg_fail(1)) SWIG_fail;
16749 {
16750 PyThreadState* __tstate = wxPyBeginAllowThreads();
16751 wxPyArtProvider_Destroy(arg1);
16752
16753 wxPyEndAllowThreads(__tstate);
16754 if (PyErr_Occurred()) SWIG_fail;
16755 }
16756 Py_INCREF(Py_None); resultobj = Py_None;
16757 return resultobj;
16758 fail:
16759 return NULL;
16760 }
16761
16762
16763 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16764 PyObject *obj;
16765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16766 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16767 Py_INCREF(obj);
16768 return Py_BuildValue((char *)"");
16769 }
16770 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16771 PyObject *resultobj;
16772 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16773 PyObject * obj0 = 0 ;
16774 char *kwnames[] = {
16775 (char *) "self", NULL
16776 };
16777
16778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16780 if (SWIG_arg_fail(1)) SWIG_fail;
16781 {
16782 PyThreadState* __tstate = wxPyBeginAllowThreads();
16783 delete arg1;
16784
16785 wxPyEndAllowThreads(__tstate);
16786 if (PyErr_Occurred()) SWIG_fail;
16787 }
16788 Py_INCREF(Py_None); resultobj = Py_None;
16789 return resultobj;
16790 fail:
16791 return NULL;
16792 }
16793
16794
16795 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16796 PyObject *resultobj;
16797 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16798 wxConfigBase *result;
16799 PyObject * obj0 = 0 ;
16800 char *kwnames[] = {
16801 (char *) "config", NULL
16802 };
16803
16804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16806 if (SWIG_arg_fail(1)) SWIG_fail;
16807 {
16808 PyThreadState* __tstate = wxPyBeginAllowThreads();
16809 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16810
16811 wxPyEndAllowThreads(__tstate);
16812 if (PyErr_Occurred()) SWIG_fail;
16813 }
16814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16815 return resultobj;
16816 fail:
16817 return NULL;
16818 }
16819
16820
16821 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16822 PyObject *resultobj;
16823 bool arg1 = (bool) true ;
16824 wxConfigBase *result;
16825 PyObject * obj0 = 0 ;
16826 char *kwnames[] = {
16827 (char *) "createOnDemand", NULL
16828 };
16829
16830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16831 if (obj0) {
16832 {
16833 arg1 = (bool)(SWIG_As_bool(obj0));
16834 if (SWIG_arg_fail(1)) SWIG_fail;
16835 }
16836 }
16837 {
16838 PyThreadState* __tstate = wxPyBeginAllowThreads();
16839 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16840
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj;
16853 wxConfigBase *result;
16854 char *kwnames[] = {
16855 NULL
16856 };
16857
16858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16859 {
16860 PyThreadState* __tstate = wxPyBeginAllowThreads();
16861 result = (wxConfigBase *)wxConfigBase::Create();
16862
16863 wxPyEndAllowThreads(__tstate);
16864 if (PyErr_Occurred()) SWIG_fail;
16865 }
16866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16867 return resultobj;
16868 fail:
16869 return NULL;
16870 }
16871
16872
16873 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16874 PyObject *resultobj;
16875 char *kwnames[] = {
16876 NULL
16877 };
16878
16879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 wxConfigBase::DontCreateOnDemand();
16883
16884 wxPyEndAllowThreads(__tstate);
16885 if (PyErr_Occurred()) SWIG_fail;
16886 }
16887 Py_INCREF(Py_None); resultobj = Py_None;
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj;
16896 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16897 wxString *arg2 = 0 ;
16898 bool temp2 = false ;
16899 PyObject * obj0 = 0 ;
16900 PyObject * obj1 = 0 ;
16901 char *kwnames[] = {
16902 (char *) "self",(char *) "path", NULL
16903 };
16904
16905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16907 if (SWIG_arg_fail(1)) SWIG_fail;
16908 {
16909 arg2 = wxString_in_helper(obj1);
16910 if (arg2 == NULL) SWIG_fail;
16911 temp2 = true;
16912 }
16913 {
16914 PyThreadState* __tstate = wxPyBeginAllowThreads();
16915 (arg1)->SetPath((wxString const &)*arg2);
16916
16917 wxPyEndAllowThreads(__tstate);
16918 if (PyErr_Occurred()) SWIG_fail;
16919 }
16920 Py_INCREF(Py_None); resultobj = Py_None;
16921 {
16922 if (temp2)
16923 delete arg2;
16924 }
16925 return resultobj;
16926 fail:
16927 {
16928 if (temp2)
16929 delete arg2;
16930 }
16931 return NULL;
16932 }
16933
16934
16935 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16936 PyObject *resultobj;
16937 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16938 wxString *result;
16939 PyObject * obj0 = 0 ;
16940 char *kwnames[] = {
16941 (char *) "self", NULL
16942 };
16943
16944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16946 if (SWIG_arg_fail(1)) SWIG_fail;
16947 {
16948 PyThreadState* __tstate = wxPyBeginAllowThreads();
16949 {
16950 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16951 result = (wxString *) &_result_ref;
16952 }
16953
16954 wxPyEndAllowThreads(__tstate);
16955 if (PyErr_Occurred()) SWIG_fail;
16956 }
16957 {
16958 #if wxUSE_UNICODE
16959 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16960 #else
16961 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16962 #endif
16963 }
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16971 PyObject *resultobj;
16972 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16973 PyObject *result;
16974 PyObject * obj0 = 0 ;
16975 char *kwnames[] = {
16976 (char *) "self", NULL
16977 };
16978
16979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16981 if (SWIG_arg_fail(1)) SWIG_fail;
16982 {
16983 PyThreadState* __tstate = wxPyBeginAllowThreads();
16984 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16985
16986 wxPyEndAllowThreads(__tstate);
16987 if (PyErr_Occurred()) SWIG_fail;
16988 }
16989 resultobj = result;
16990 return resultobj;
16991 fail:
16992 return NULL;
16993 }
16994
16995
16996 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16997 PyObject *resultobj;
16998 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16999 long arg2 ;
17000 PyObject *result;
17001 PyObject * obj0 = 0 ;
17002 PyObject * obj1 = 0 ;
17003 char *kwnames[] = {
17004 (char *) "self",(char *) "index", NULL
17005 };
17006
17007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17009 if (SWIG_arg_fail(1)) SWIG_fail;
17010 {
17011 arg2 = (long)(SWIG_As_long(obj1));
17012 if (SWIG_arg_fail(2)) SWIG_fail;
17013 }
17014 {
17015 PyThreadState* __tstate = wxPyBeginAllowThreads();
17016 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17017
17018 wxPyEndAllowThreads(__tstate);
17019 if (PyErr_Occurred()) SWIG_fail;
17020 }
17021 resultobj = result;
17022 return resultobj;
17023 fail:
17024 return NULL;
17025 }
17026
17027
17028 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17029 PyObject *resultobj;
17030 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17031 PyObject *result;
17032 PyObject * obj0 = 0 ;
17033 char *kwnames[] = {
17034 (char *) "self", NULL
17035 };
17036
17037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17039 if (SWIG_arg_fail(1)) SWIG_fail;
17040 {
17041 PyThreadState* __tstate = wxPyBeginAllowThreads();
17042 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17043
17044 wxPyEndAllowThreads(__tstate);
17045 if (PyErr_Occurred()) SWIG_fail;
17046 }
17047 resultobj = result;
17048 return resultobj;
17049 fail:
17050 return NULL;
17051 }
17052
17053
17054 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17055 PyObject *resultobj;
17056 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17057 long arg2 ;
17058 PyObject *result;
17059 PyObject * obj0 = 0 ;
17060 PyObject * obj1 = 0 ;
17061 char *kwnames[] = {
17062 (char *) "self",(char *) "index", NULL
17063 };
17064
17065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17067 if (SWIG_arg_fail(1)) SWIG_fail;
17068 {
17069 arg2 = (long)(SWIG_As_long(obj1));
17070 if (SWIG_arg_fail(2)) SWIG_fail;
17071 }
17072 {
17073 PyThreadState* __tstate = wxPyBeginAllowThreads();
17074 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17075
17076 wxPyEndAllowThreads(__tstate);
17077 if (PyErr_Occurred()) SWIG_fail;
17078 }
17079 resultobj = result;
17080 return resultobj;
17081 fail:
17082 return NULL;
17083 }
17084
17085
17086 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17087 PyObject *resultobj;
17088 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17089 bool arg2 = (bool) false ;
17090 size_t result;
17091 PyObject * obj0 = 0 ;
17092 PyObject * obj1 = 0 ;
17093 char *kwnames[] = {
17094 (char *) "self",(char *) "recursive", NULL
17095 };
17096
17097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17099 if (SWIG_arg_fail(1)) SWIG_fail;
17100 if (obj1) {
17101 {
17102 arg2 = (bool)(SWIG_As_bool(obj1));
17103 if (SWIG_arg_fail(2)) SWIG_fail;
17104 }
17105 }
17106 {
17107 PyThreadState* __tstate = wxPyBeginAllowThreads();
17108 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17109
17110 wxPyEndAllowThreads(__tstate);
17111 if (PyErr_Occurred()) SWIG_fail;
17112 }
17113 {
17114 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17115 }
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17123 PyObject *resultobj;
17124 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17125 bool arg2 = (bool) false ;
17126 size_t result;
17127 PyObject * obj0 = 0 ;
17128 PyObject * obj1 = 0 ;
17129 char *kwnames[] = {
17130 (char *) "self",(char *) "recursive", NULL
17131 };
17132
17133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17135 if (SWIG_arg_fail(1)) SWIG_fail;
17136 if (obj1) {
17137 {
17138 arg2 = (bool)(SWIG_As_bool(obj1));
17139 if (SWIG_arg_fail(2)) SWIG_fail;
17140 }
17141 }
17142 {
17143 PyThreadState* __tstate = wxPyBeginAllowThreads();
17144 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17145
17146 wxPyEndAllowThreads(__tstate);
17147 if (PyErr_Occurred()) SWIG_fail;
17148 }
17149 {
17150 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17151 }
17152 return resultobj;
17153 fail:
17154 return NULL;
17155 }
17156
17157
17158 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17159 PyObject *resultobj;
17160 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17161 wxString *arg2 = 0 ;
17162 bool result;
17163 bool temp2 = false ;
17164 PyObject * obj0 = 0 ;
17165 PyObject * obj1 = 0 ;
17166 char *kwnames[] = {
17167 (char *) "self",(char *) "name", NULL
17168 };
17169
17170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17172 if (SWIG_arg_fail(1)) SWIG_fail;
17173 {
17174 arg2 = wxString_in_helper(obj1);
17175 if (arg2 == NULL) SWIG_fail;
17176 temp2 = true;
17177 }
17178 {
17179 PyThreadState* __tstate = wxPyBeginAllowThreads();
17180 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17181
17182 wxPyEndAllowThreads(__tstate);
17183 if (PyErr_Occurred()) SWIG_fail;
17184 }
17185 {
17186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17187 }
17188 {
17189 if (temp2)
17190 delete arg2;
17191 }
17192 return resultobj;
17193 fail:
17194 {
17195 if (temp2)
17196 delete arg2;
17197 }
17198 return NULL;
17199 }
17200
17201
17202 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17203 PyObject *resultobj;
17204 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17205 wxString *arg2 = 0 ;
17206 bool result;
17207 bool temp2 = false ;
17208 PyObject * obj0 = 0 ;
17209 PyObject * obj1 = 0 ;
17210 char *kwnames[] = {
17211 (char *) "self",(char *) "name", NULL
17212 };
17213
17214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17216 if (SWIG_arg_fail(1)) SWIG_fail;
17217 {
17218 arg2 = wxString_in_helper(obj1);
17219 if (arg2 == NULL) SWIG_fail;
17220 temp2 = true;
17221 }
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17225
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 {
17230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17231 }
17232 {
17233 if (temp2)
17234 delete arg2;
17235 }
17236 return resultobj;
17237 fail:
17238 {
17239 if (temp2)
17240 delete arg2;
17241 }
17242 return NULL;
17243 }
17244
17245
17246 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17247 PyObject *resultobj;
17248 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17249 wxString *arg2 = 0 ;
17250 bool result;
17251 bool temp2 = false ;
17252 PyObject * obj0 = 0 ;
17253 PyObject * obj1 = 0 ;
17254 char *kwnames[] = {
17255 (char *) "self",(char *) "name", NULL
17256 };
17257
17258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17260 if (SWIG_arg_fail(1)) SWIG_fail;
17261 {
17262 arg2 = wxString_in_helper(obj1);
17263 if (arg2 == NULL) SWIG_fail;
17264 temp2 = true;
17265 }
17266 {
17267 PyThreadState* __tstate = wxPyBeginAllowThreads();
17268 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17269
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 {
17274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17275 }
17276 {
17277 if (temp2)
17278 delete arg2;
17279 }
17280 return resultobj;
17281 fail:
17282 {
17283 if (temp2)
17284 delete arg2;
17285 }
17286 return NULL;
17287 }
17288
17289
17290 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17291 PyObject *resultobj;
17292 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17293 wxString *arg2 = 0 ;
17294 wxConfigBase::EntryType result;
17295 bool temp2 = false ;
17296 PyObject * obj0 = 0 ;
17297 PyObject * obj1 = 0 ;
17298 char *kwnames[] = {
17299 (char *) "self",(char *) "name", NULL
17300 };
17301
17302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17304 if (SWIG_arg_fail(1)) SWIG_fail;
17305 {
17306 arg2 = wxString_in_helper(obj1);
17307 if (arg2 == NULL) SWIG_fail;
17308 temp2 = true;
17309 }
17310 {
17311 PyThreadState* __tstate = wxPyBeginAllowThreads();
17312 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17313
17314 wxPyEndAllowThreads(__tstate);
17315 if (PyErr_Occurred()) SWIG_fail;
17316 }
17317 resultobj = SWIG_From_int((result));
17318 {
17319 if (temp2)
17320 delete arg2;
17321 }
17322 return resultobj;
17323 fail:
17324 {
17325 if (temp2)
17326 delete arg2;
17327 }
17328 return NULL;
17329 }
17330
17331
17332 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17333 PyObject *resultobj;
17334 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17335 wxString *arg2 = 0 ;
17336 wxString const &arg3_defvalue = wxPyEmptyString ;
17337 wxString *arg3 = (wxString *) &arg3_defvalue ;
17338 wxString result;
17339 bool temp2 = false ;
17340 bool temp3 = false ;
17341 PyObject * obj0 = 0 ;
17342 PyObject * obj1 = 0 ;
17343 PyObject * obj2 = 0 ;
17344 char *kwnames[] = {
17345 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17346 };
17347
17348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17350 if (SWIG_arg_fail(1)) SWIG_fail;
17351 {
17352 arg2 = wxString_in_helper(obj1);
17353 if (arg2 == NULL) SWIG_fail;
17354 temp2 = true;
17355 }
17356 if (obj2) {
17357 {
17358 arg3 = wxString_in_helper(obj2);
17359 if (arg3 == NULL) SWIG_fail;
17360 temp3 = true;
17361 }
17362 }
17363 {
17364 PyThreadState* __tstate = wxPyBeginAllowThreads();
17365 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17366
17367 wxPyEndAllowThreads(__tstate);
17368 if (PyErr_Occurred()) SWIG_fail;
17369 }
17370 {
17371 #if wxUSE_UNICODE
17372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17373 #else
17374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17375 #endif
17376 }
17377 {
17378 if (temp2)
17379 delete arg2;
17380 }
17381 {
17382 if (temp3)
17383 delete arg3;
17384 }
17385 return resultobj;
17386 fail:
17387 {
17388 if (temp2)
17389 delete arg2;
17390 }
17391 {
17392 if (temp3)
17393 delete arg3;
17394 }
17395 return NULL;
17396 }
17397
17398
17399 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17400 PyObject *resultobj;
17401 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17402 wxString *arg2 = 0 ;
17403 long arg3 = (long) 0 ;
17404 long result;
17405 bool temp2 = false ;
17406 PyObject * obj0 = 0 ;
17407 PyObject * obj1 = 0 ;
17408 PyObject * obj2 = 0 ;
17409 char *kwnames[] = {
17410 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17411 };
17412
17413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17415 if (SWIG_arg_fail(1)) SWIG_fail;
17416 {
17417 arg2 = wxString_in_helper(obj1);
17418 if (arg2 == NULL) SWIG_fail;
17419 temp2 = true;
17420 }
17421 if (obj2) {
17422 {
17423 arg3 = (long)(SWIG_As_long(obj2));
17424 if (SWIG_arg_fail(3)) SWIG_fail;
17425 }
17426 }
17427 {
17428 PyThreadState* __tstate = wxPyBeginAllowThreads();
17429 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17430
17431 wxPyEndAllowThreads(__tstate);
17432 if (PyErr_Occurred()) SWIG_fail;
17433 }
17434 {
17435 resultobj = SWIG_From_long((long)(result));
17436 }
17437 {
17438 if (temp2)
17439 delete arg2;
17440 }
17441 return resultobj;
17442 fail:
17443 {
17444 if (temp2)
17445 delete arg2;
17446 }
17447 return NULL;
17448 }
17449
17450
17451 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17452 PyObject *resultobj;
17453 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17454 wxString *arg2 = 0 ;
17455 double arg3 = (double) 0.0 ;
17456 double result;
17457 bool temp2 = false ;
17458 PyObject * obj0 = 0 ;
17459 PyObject * obj1 = 0 ;
17460 PyObject * obj2 = 0 ;
17461 char *kwnames[] = {
17462 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17463 };
17464
17465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17467 if (SWIG_arg_fail(1)) SWIG_fail;
17468 {
17469 arg2 = wxString_in_helper(obj1);
17470 if (arg2 == NULL) SWIG_fail;
17471 temp2 = true;
17472 }
17473 if (obj2) {
17474 {
17475 arg3 = (double)(SWIG_As_double(obj2));
17476 if (SWIG_arg_fail(3)) SWIG_fail;
17477 }
17478 }
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17482
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 {
17487 resultobj = SWIG_From_double((double)(result));
17488 }
17489 {
17490 if (temp2)
17491 delete arg2;
17492 }
17493 return resultobj;
17494 fail:
17495 {
17496 if (temp2)
17497 delete arg2;
17498 }
17499 return NULL;
17500 }
17501
17502
17503 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17504 PyObject *resultobj;
17505 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17506 wxString *arg2 = 0 ;
17507 bool arg3 = (bool) false ;
17508 bool result;
17509 bool temp2 = false ;
17510 PyObject * obj0 = 0 ;
17511 PyObject * obj1 = 0 ;
17512 PyObject * obj2 = 0 ;
17513 char *kwnames[] = {
17514 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17515 };
17516
17517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17519 if (SWIG_arg_fail(1)) SWIG_fail;
17520 {
17521 arg2 = wxString_in_helper(obj1);
17522 if (arg2 == NULL) SWIG_fail;
17523 temp2 = true;
17524 }
17525 if (obj2) {
17526 {
17527 arg3 = (bool)(SWIG_As_bool(obj2));
17528 if (SWIG_arg_fail(3)) SWIG_fail;
17529 }
17530 }
17531 {
17532 PyThreadState* __tstate = wxPyBeginAllowThreads();
17533 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17534
17535 wxPyEndAllowThreads(__tstate);
17536 if (PyErr_Occurred()) SWIG_fail;
17537 }
17538 {
17539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17540 }
17541 {
17542 if (temp2)
17543 delete arg2;
17544 }
17545 return resultobj;
17546 fail:
17547 {
17548 if (temp2)
17549 delete arg2;
17550 }
17551 return NULL;
17552 }
17553
17554
17555 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17556 PyObject *resultobj;
17557 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17558 wxString *arg2 = 0 ;
17559 wxString *arg3 = 0 ;
17560 bool result;
17561 bool temp2 = false ;
17562 bool temp3 = false ;
17563 PyObject * obj0 = 0 ;
17564 PyObject * obj1 = 0 ;
17565 PyObject * obj2 = 0 ;
17566 char *kwnames[] = {
17567 (char *) "self",(char *) "key",(char *) "value", NULL
17568 };
17569
17570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17572 if (SWIG_arg_fail(1)) SWIG_fail;
17573 {
17574 arg2 = wxString_in_helper(obj1);
17575 if (arg2 == NULL) SWIG_fail;
17576 temp2 = true;
17577 }
17578 {
17579 arg3 = wxString_in_helper(obj2);
17580 if (arg3 == NULL) SWIG_fail;
17581 temp3 = true;
17582 }
17583 {
17584 PyThreadState* __tstate = wxPyBeginAllowThreads();
17585 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17586
17587 wxPyEndAllowThreads(__tstate);
17588 if (PyErr_Occurred()) SWIG_fail;
17589 }
17590 {
17591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17592 }
17593 {
17594 if (temp2)
17595 delete arg2;
17596 }
17597 {
17598 if (temp3)
17599 delete arg3;
17600 }
17601 return resultobj;
17602 fail:
17603 {
17604 if (temp2)
17605 delete arg2;
17606 }
17607 {
17608 if (temp3)
17609 delete arg3;
17610 }
17611 return NULL;
17612 }
17613
17614
17615 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17616 PyObject *resultobj;
17617 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17618 wxString *arg2 = 0 ;
17619 long arg3 ;
17620 bool result;
17621 bool temp2 = false ;
17622 PyObject * obj0 = 0 ;
17623 PyObject * obj1 = 0 ;
17624 PyObject * obj2 = 0 ;
17625 char *kwnames[] = {
17626 (char *) "self",(char *) "key",(char *) "value", NULL
17627 };
17628
17629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17631 if (SWIG_arg_fail(1)) SWIG_fail;
17632 {
17633 arg2 = wxString_in_helper(obj1);
17634 if (arg2 == NULL) SWIG_fail;
17635 temp2 = true;
17636 }
17637 {
17638 arg3 = (long)(SWIG_As_long(obj2));
17639 if (SWIG_arg_fail(3)) SWIG_fail;
17640 }
17641 {
17642 PyThreadState* __tstate = wxPyBeginAllowThreads();
17643 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17644
17645 wxPyEndAllowThreads(__tstate);
17646 if (PyErr_Occurred()) SWIG_fail;
17647 }
17648 {
17649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17650 }
17651 {
17652 if (temp2)
17653 delete arg2;
17654 }
17655 return resultobj;
17656 fail:
17657 {
17658 if (temp2)
17659 delete arg2;
17660 }
17661 return NULL;
17662 }
17663
17664
17665 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17666 PyObject *resultobj;
17667 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17668 wxString *arg2 = 0 ;
17669 double arg3 ;
17670 bool result;
17671 bool temp2 = false ;
17672 PyObject * obj0 = 0 ;
17673 PyObject * obj1 = 0 ;
17674 PyObject * obj2 = 0 ;
17675 char *kwnames[] = {
17676 (char *) "self",(char *) "key",(char *) "value", NULL
17677 };
17678
17679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17681 if (SWIG_arg_fail(1)) SWIG_fail;
17682 {
17683 arg2 = wxString_in_helper(obj1);
17684 if (arg2 == NULL) SWIG_fail;
17685 temp2 = true;
17686 }
17687 {
17688 arg3 = (double)(SWIG_As_double(obj2));
17689 if (SWIG_arg_fail(3)) SWIG_fail;
17690 }
17691 {
17692 PyThreadState* __tstate = wxPyBeginAllowThreads();
17693 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17694
17695 wxPyEndAllowThreads(__tstate);
17696 if (PyErr_Occurred()) SWIG_fail;
17697 }
17698 {
17699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17700 }
17701 {
17702 if (temp2)
17703 delete arg2;
17704 }
17705 return resultobj;
17706 fail:
17707 {
17708 if (temp2)
17709 delete arg2;
17710 }
17711 return NULL;
17712 }
17713
17714
17715 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj;
17717 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17718 wxString *arg2 = 0 ;
17719 bool arg3 ;
17720 bool result;
17721 bool temp2 = false ;
17722 PyObject * obj0 = 0 ;
17723 PyObject * obj1 = 0 ;
17724 PyObject * obj2 = 0 ;
17725 char *kwnames[] = {
17726 (char *) "self",(char *) "key",(char *) "value", NULL
17727 };
17728
17729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17731 if (SWIG_arg_fail(1)) SWIG_fail;
17732 {
17733 arg2 = wxString_in_helper(obj1);
17734 if (arg2 == NULL) SWIG_fail;
17735 temp2 = true;
17736 }
17737 {
17738 arg3 = (bool)(SWIG_As_bool(obj2));
17739 if (SWIG_arg_fail(3)) SWIG_fail;
17740 }
17741 {
17742 PyThreadState* __tstate = wxPyBeginAllowThreads();
17743 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17744
17745 wxPyEndAllowThreads(__tstate);
17746 if (PyErr_Occurred()) SWIG_fail;
17747 }
17748 {
17749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17750 }
17751 {
17752 if (temp2)
17753 delete arg2;
17754 }
17755 return resultobj;
17756 fail:
17757 {
17758 if (temp2)
17759 delete arg2;
17760 }
17761 return NULL;
17762 }
17763
17764
17765 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj;
17767 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17768 bool arg2 = (bool) false ;
17769 bool result;
17770 PyObject * obj0 = 0 ;
17771 PyObject * obj1 = 0 ;
17772 char *kwnames[] = {
17773 (char *) "self",(char *) "currentOnly", NULL
17774 };
17775
17776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17778 if (SWIG_arg_fail(1)) SWIG_fail;
17779 if (obj1) {
17780 {
17781 arg2 = (bool)(SWIG_As_bool(obj1));
17782 if (SWIG_arg_fail(2)) SWIG_fail;
17783 }
17784 }
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 result = (bool)(arg1)->Flush(arg2);
17788
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 {
17793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17794 }
17795 return resultobj;
17796 fail:
17797 return NULL;
17798 }
17799
17800
17801 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17802 PyObject *resultobj;
17803 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17804 wxString *arg2 = 0 ;
17805 wxString *arg3 = 0 ;
17806 bool result;
17807 bool temp2 = false ;
17808 bool temp3 = false ;
17809 PyObject * obj0 = 0 ;
17810 PyObject * obj1 = 0 ;
17811 PyObject * obj2 = 0 ;
17812 char *kwnames[] = {
17813 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17814 };
17815
17816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17818 if (SWIG_arg_fail(1)) SWIG_fail;
17819 {
17820 arg2 = wxString_in_helper(obj1);
17821 if (arg2 == NULL) SWIG_fail;
17822 temp2 = true;
17823 }
17824 {
17825 arg3 = wxString_in_helper(obj2);
17826 if (arg3 == NULL) SWIG_fail;
17827 temp3 = true;
17828 }
17829 {
17830 PyThreadState* __tstate = wxPyBeginAllowThreads();
17831 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17832
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 {
17837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17838 }
17839 {
17840 if (temp2)
17841 delete arg2;
17842 }
17843 {
17844 if (temp3)
17845 delete arg3;
17846 }
17847 return resultobj;
17848 fail:
17849 {
17850 if (temp2)
17851 delete arg2;
17852 }
17853 {
17854 if (temp3)
17855 delete arg3;
17856 }
17857 return NULL;
17858 }
17859
17860
17861 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17862 PyObject *resultobj;
17863 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17864 wxString *arg2 = 0 ;
17865 wxString *arg3 = 0 ;
17866 bool result;
17867 bool temp2 = false ;
17868 bool temp3 = false ;
17869 PyObject * obj0 = 0 ;
17870 PyObject * obj1 = 0 ;
17871 PyObject * obj2 = 0 ;
17872 char *kwnames[] = {
17873 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17874 };
17875
17876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17878 if (SWIG_arg_fail(1)) SWIG_fail;
17879 {
17880 arg2 = wxString_in_helper(obj1);
17881 if (arg2 == NULL) SWIG_fail;
17882 temp2 = true;
17883 }
17884 {
17885 arg3 = wxString_in_helper(obj2);
17886 if (arg3 == NULL) SWIG_fail;
17887 temp3 = true;
17888 }
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17892
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 {
17897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17898 }
17899 {
17900 if (temp2)
17901 delete arg2;
17902 }
17903 {
17904 if (temp3)
17905 delete arg3;
17906 }
17907 return resultobj;
17908 fail:
17909 {
17910 if (temp2)
17911 delete arg2;
17912 }
17913 {
17914 if (temp3)
17915 delete arg3;
17916 }
17917 return NULL;
17918 }
17919
17920
17921 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17922 PyObject *resultobj;
17923 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17924 wxString *arg2 = 0 ;
17925 bool arg3 = (bool) true ;
17926 bool result;
17927 bool temp2 = false ;
17928 PyObject * obj0 = 0 ;
17929 PyObject * obj1 = 0 ;
17930 PyObject * obj2 = 0 ;
17931 char *kwnames[] = {
17932 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17933 };
17934
17935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17937 if (SWIG_arg_fail(1)) SWIG_fail;
17938 {
17939 arg2 = wxString_in_helper(obj1);
17940 if (arg2 == NULL) SWIG_fail;
17941 temp2 = true;
17942 }
17943 if (obj2) {
17944 {
17945 arg3 = (bool)(SWIG_As_bool(obj2));
17946 if (SWIG_arg_fail(3)) SWIG_fail;
17947 }
17948 }
17949 {
17950 PyThreadState* __tstate = wxPyBeginAllowThreads();
17951 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17952
17953 wxPyEndAllowThreads(__tstate);
17954 if (PyErr_Occurred()) SWIG_fail;
17955 }
17956 {
17957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17958 }
17959 {
17960 if (temp2)
17961 delete arg2;
17962 }
17963 return resultobj;
17964 fail:
17965 {
17966 if (temp2)
17967 delete arg2;
17968 }
17969 return NULL;
17970 }
17971
17972
17973 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17974 PyObject *resultobj;
17975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17976 wxString *arg2 = 0 ;
17977 bool result;
17978 bool temp2 = false ;
17979 PyObject * obj0 = 0 ;
17980 PyObject * obj1 = 0 ;
17981 char *kwnames[] = {
17982 (char *) "self",(char *) "key", NULL
17983 };
17984
17985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17987 if (SWIG_arg_fail(1)) SWIG_fail;
17988 {
17989 arg2 = wxString_in_helper(obj1);
17990 if (arg2 == NULL) SWIG_fail;
17991 temp2 = true;
17992 }
17993 {
17994 PyThreadState* __tstate = wxPyBeginAllowThreads();
17995 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17996
17997 wxPyEndAllowThreads(__tstate);
17998 if (PyErr_Occurred()) SWIG_fail;
17999 }
18000 {
18001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18002 }
18003 {
18004 if (temp2)
18005 delete arg2;
18006 }
18007 return resultobj;
18008 fail:
18009 {
18010 if (temp2)
18011 delete arg2;
18012 }
18013 return NULL;
18014 }
18015
18016
18017 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18018 PyObject *resultobj;
18019 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18020 bool result;
18021 PyObject * obj0 = 0 ;
18022 char *kwnames[] = {
18023 (char *) "self", NULL
18024 };
18025
18026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18028 if (SWIG_arg_fail(1)) SWIG_fail;
18029 {
18030 PyThreadState* __tstate = wxPyBeginAllowThreads();
18031 result = (bool)(arg1)->DeleteAll();
18032
18033 wxPyEndAllowThreads(__tstate);
18034 if (PyErr_Occurred()) SWIG_fail;
18035 }
18036 {
18037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18038 }
18039 return resultobj;
18040 fail:
18041 return NULL;
18042 }
18043
18044
18045 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18046 PyObject *resultobj;
18047 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18048 bool arg2 = (bool) true ;
18049 PyObject * obj0 = 0 ;
18050 PyObject * obj1 = 0 ;
18051 char *kwnames[] = {
18052 (char *) "self",(char *) "doIt", NULL
18053 };
18054
18055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18057 if (SWIG_arg_fail(1)) SWIG_fail;
18058 if (obj1) {
18059 {
18060 arg2 = (bool)(SWIG_As_bool(obj1));
18061 if (SWIG_arg_fail(2)) SWIG_fail;
18062 }
18063 }
18064 {
18065 PyThreadState* __tstate = wxPyBeginAllowThreads();
18066 (arg1)->SetExpandEnvVars(arg2);
18067
18068 wxPyEndAllowThreads(__tstate);
18069 if (PyErr_Occurred()) SWIG_fail;
18070 }
18071 Py_INCREF(Py_None); resultobj = Py_None;
18072 return resultobj;
18073 fail:
18074 return NULL;
18075 }
18076
18077
18078 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18079 PyObject *resultobj;
18080 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18081 bool result;
18082 PyObject * obj0 = 0 ;
18083 char *kwnames[] = {
18084 (char *) "self", NULL
18085 };
18086
18087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18089 if (SWIG_arg_fail(1)) SWIG_fail;
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18093
18094 wxPyEndAllowThreads(__tstate);
18095 if (PyErr_Occurred()) SWIG_fail;
18096 }
18097 {
18098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18099 }
18100 return resultobj;
18101 fail:
18102 return NULL;
18103 }
18104
18105
18106 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18107 PyObject *resultobj;
18108 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18109 bool arg2 = (bool) true ;
18110 PyObject * obj0 = 0 ;
18111 PyObject * obj1 = 0 ;
18112 char *kwnames[] = {
18113 (char *) "self",(char *) "doIt", NULL
18114 };
18115
18116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18118 if (SWIG_arg_fail(1)) SWIG_fail;
18119 if (obj1) {
18120 {
18121 arg2 = (bool)(SWIG_As_bool(obj1));
18122 if (SWIG_arg_fail(2)) SWIG_fail;
18123 }
18124 }
18125 {
18126 PyThreadState* __tstate = wxPyBeginAllowThreads();
18127 (arg1)->SetRecordDefaults(arg2);
18128
18129 wxPyEndAllowThreads(__tstate);
18130 if (PyErr_Occurred()) SWIG_fail;
18131 }
18132 Py_INCREF(Py_None); resultobj = Py_None;
18133 return resultobj;
18134 fail:
18135 return NULL;
18136 }
18137
18138
18139 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18140 PyObject *resultobj;
18141 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18142 bool result;
18143 PyObject * obj0 = 0 ;
18144 char *kwnames[] = {
18145 (char *) "self", NULL
18146 };
18147
18148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18150 if (SWIG_arg_fail(1)) SWIG_fail;
18151 {
18152 PyThreadState* __tstate = wxPyBeginAllowThreads();
18153 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18154
18155 wxPyEndAllowThreads(__tstate);
18156 if (PyErr_Occurred()) SWIG_fail;
18157 }
18158 {
18159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18160 }
18161 return resultobj;
18162 fail:
18163 return NULL;
18164 }
18165
18166
18167 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18168 PyObject *resultobj;
18169 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18170 wxString *arg2 = 0 ;
18171 wxString result;
18172 bool temp2 = false ;
18173 PyObject * obj0 = 0 ;
18174 PyObject * obj1 = 0 ;
18175 char *kwnames[] = {
18176 (char *) "self",(char *) "str", NULL
18177 };
18178
18179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18181 if (SWIG_arg_fail(1)) SWIG_fail;
18182 {
18183 arg2 = wxString_in_helper(obj1);
18184 if (arg2 == NULL) SWIG_fail;
18185 temp2 = true;
18186 }
18187 {
18188 PyThreadState* __tstate = wxPyBeginAllowThreads();
18189 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18190
18191 wxPyEndAllowThreads(__tstate);
18192 if (PyErr_Occurred()) SWIG_fail;
18193 }
18194 {
18195 #if wxUSE_UNICODE
18196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18197 #else
18198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18199 #endif
18200 }
18201 {
18202 if (temp2)
18203 delete arg2;
18204 }
18205 return resultobj;
18206 fail:
18207 {
18208 if (temp2)
18209 delete arg2;
18210 }
18211 return NULL;
18212 }
18213
18214
18215 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18216 PyObject *resultobj;
18217 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18218 wxString result;
18219 PyObject * obj0 = 0 ;
18220 char *kwnames[] = {
18221 (char *) "self", NULL
18222 };
18223
18224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18226 if (SWIG_arg_fail(1)) SWIG_fail;
18227 {
18228 PyThreadState* __tstate = wxPyBeginAllowThreads();
18229 result = ((wxConfigBase const *)arg1)->GetAppName();
18230
18231 wxPyEndAllowThreads(__tstate);
18232 if (PyErr_Occurred()) SWIG_fail;
18233 }
18234 {
18235 #if wxUSE_UNICODE
18236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18237 #else
18238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18239 #endif
18240 }
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18248 PyObject *resultobj;
18249 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18250 wxString result;
18251 PyObject * obj0 = 0 ;
18252 char *kwnames[] = {
18253 (char *) "self", NULL
18254 };
18255
18256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18258 if (SWIG_arg_fail(1)) SWIG_fail;
18259 {
18260 PyThreadState* __tstate = wxPyBeginAllowThreads();
18261 result = ((wxConfigBase const *)arg1)->GetVendorName();
18262
18263 wxPyEndAllowThreads(__tstate);
18264 if (PyErr_Occurred()) SWIG_fail;
18265 }
18266 {
18267 #if wxUSE_UNICODE
18268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18269 #else
18270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18271 #endif
18272 }
18273 return resultobj;
18274 fail:
18275 return NULL;
18276 }
18277
18278
18279 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18280 PyObject *resultobj;
18281 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18282 wxString *arg2 = 0 ;
18283 bool temp2 = false ;
18284 PyObject * obj0 = 0 ;
18285 PyObject * obj1 = 0 ;
18286 char *kwnames[] = {
18287 (char *) "self",(char *) "appName", NULL
18288 };
18289
18290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18292 if (SWIG_arg_fail(1)) SWIG_fail;
18293 {
18294 arg2 = wxString_in_helper(obj1);
18295 if (arg2 == NULL) SWIG_fail;
18296 temp2 = true;
18297 }
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 (arg1)->SetAppName((wxString const &)*arg2);
18301
18302 wxPyEndAllowThreads(__tstate);
18303 if (PyErr_Occurred()) SWIG_fail;
18304 }
18305 Py_INCREF(Py_None); resultobj = Py_None;
18306 {
18307 if (temp2)
18308 delete arg2;
18309 }
18310 return resultobj;
18311 fail:
18312 {
18313 if (temp2)
18314 delete arg2;
18315 }
18316 return NULL;
18317 }
18318
18319
18320 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18321 PyObject *resultobj;
18322 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18323 wxString *arg2 = 0 ;
18324 bool temp2 = false ;
18325 PyObject * obj0 = 0 ;
18326 PyObject * obj1 = 0 ;
18327 char *kwnames[] = {
18328 (char *) "self",(char *) "vendorName", NULL
18329 };
18330
18331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18333 if (SWIG_arg_fail(1)) SWIG_fail;
18334 {
18335 arg2 = wxString_in_helper(obj1);
18336 if (arg2 == NULL) SWIG_fail;
18337 temp2 = true;
18338 }
18339 {
18340 PyThreadState* __tstate = wxPyBeginAllowThreads();
18341 (arg1)->SetVendorName((wxString const &)*arg2);
18342
18343 wxPyEndAllowThreads(__tstate);
18344 if (PyErr_Occurred()) SWIG_fail;
18345 }
18346 Py_INCREF(Py_None); resultobj = Py_None;
18347 {
18348 if (temp2)
18349 delete arg2;
18350 }
18351 return resultobj;
18352 fail:
18353 {
18354 if (temp2)
18355 delete arg2;
18356 }
18357 return NULL;
18358 }
18359
18360
18361 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18362 PyObject *resultobj;
18363 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18364 long arg2 ;
18365 PyObject * obj0 = 0 ;
18366 PyObject * obj1 = 0 ;
18367 char *kwnames[] = {
18368 (char *) "self",(char *) "style", NULL
18369 };
18370
18371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18373 if (SWIG_arg_fail(1)) SWIG_fail;
18374 {
18375 arg2 = (long)(SWIG_As_long(obj1));
18376 if (SWIG_arg_fail(2)) SWIG_fail;
18377 }
18378 {
18379 PyThreadState* __tstate = wxPyBeginAllowThreads();
18380 (arg1)->SetStyle(arg2);
18381
18382 wxPyEndAllowThreads(__tstate);
18383 if (PyErr_Occurred()) SWIG_fail;
18384 }
18385 Py_INCREF(Py_None); resultobj = Py_None;
18386 return resultobj;
18387 fail:
18388 return NULL;
18389 }
18390
18391
18392 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18393 PyObject *resultobj;
18394 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18395 long result;
18396 PyObject * obj0 = 0 ;
18397 char *kwnames[] = {
18398 (char *) "self", NULL
18399 };
18400
18401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18403 if (SWIG_arg_fail(1)) SWIG_fail;
18404 {
18405 PyThreadState* __tstate = wxPyBeginAllowThreads();
18406 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18407
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 {
18412 resultobj = SWIG_From_long((long)(result));
18413 }
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18421 PyObject *obj;
18422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18423 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18424 Py_INCREF(obj);
18425 return Py_BuildValue((char *)"");
18426 }
18427 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj;
18429 wxString const &arg1_defvalue = wxPyEmptyString ;
18430 wxString *arg1 = (wxString *) &arg1_defvalue ;
18431 wxString const &arg2_defvalue = wxPyEmptyString ;
18432 wxString *arg2 = (wxString *) &arg2_defvalue ;
18433 wxString const &arg3_defvalue = wxPyEmptyString ;
18434 wxString *arg3 = (wxString *) &arg3_defvalue ;
18435 wxString const &arg4_defvalue = wxPyEmptyString ;
18436 wxString *arg4 = (wxString *) &arg4_defvalue ;
18437 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18438 wxConfig *result;
18439 bool temp1 = false ;
18440 bool temp2 = false ;
18441 bool temp3 = false ;
18442 bool temp4 = false ;
18443 PyObject * obj0 = 0 ;
18444 PyObject * obj1 = 0 ;
18445 PyObject * obj2 = 0 ;
18446 PyObject * obj3 = 0 ;
18447 PyObject * obj4 = 0 ;
18448 char *kwnames[] = {
18449 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18450 };
18451
18452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18453 if (obj0) {
18454 {
18455 arg1 = wxString_in_helper(obj0);
18456 if (arg1 == NULL) SWIG_fail;
18457 temp1 = true;
18458 }
18459 }
18460 if (obj1) {
18461 {
18462 arg2 = wxString_in_helper(obj1);
18463 if (arg2 == NULL) SWIG_fail;
18464 temp2 = true;
18465 }
18466 }
18467 if (obj2) {
18468 {
18469 arg3 = wxString_in_helper(obj2);
18470 if (arg3 == NULL) SWIG_fail;
18471 temp3 = true;
18472 }
18473 }
18474 if (obj3) {
18475 {
18476 arg4 = wxString_in_helper(obj3);
18477 if (arg4 == NULL) SWIG_fail;
18478 temp4 = true;
18479 }
18480 }
18481 if (obj4) {
18482 {
18483 arg5 = (long)(SWIG_As_long(obj4));
18484 if (SWIG_arg_fail(5)) SWIG_fail;
18485 }
18486 }
18487 {
18488 PyThreadState* __tstate = wxPyBeginAllowThreads();
18489 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18490
18491 wxPyEndAllowThreads(__tstate);
18492 if (PyErr_Occurred()) SWIG_fail;
18493 }
18494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18495 {
18496 if (temp1)
18497 delete arg1;
18498 }
18499 {
18500 if (temp2)
18501 delete arg2;
18502 }
18503 {
18504 if (temp3)
18505 delete arg3;
18506 }
18507 {
18508 if (temp4)
18509 delete arg4;
18510 }
18511 return resultobj;
18512 fail:
18513 {
18514 if (temp1)
18515 delete arg1;
18516 }
18517 {
18518 if (temp2)
18519 delete arg2;
18520 }
18521 {
18522 if (temp3)
18523 delete arg3;
18524 }
18525 {
18526 if (temp4)
18527 delete arg4;
18528 }
18529 return NULL;
18530 }
18531
18532
18533 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18534 PyObject *resultobj;
18535 wxConfig *arg1 = (wxConfig *) 0 ;
18536 PyObject * obj0 = 0 ;
18537 char *kwnames[] = {
18538 (char *) "self", NULL
18539 };
18540
18541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18543 if (SWIG_arg_fail(1)) SWIG_fail;
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 delete arg1;
18547
18548 wxPyEndAllowThreads(__tstate);
18549 if (PyErr_Occurred()) SWIG_fail;
18550 }
18551 Py_INCREF(Py_None); resultobj = Py_None;
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18559 PyObject *obj;
18560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18561 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18562 Py_INCREF(obj);
18563 return Py_BuildValue((char *)"");
18564 }
18565 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18566 PyObject *resultobj;
18567 wxString const &arg1_defvalue = wxPyEmptyString ;
18568 wxString *arg1 = (wxString *) &arg1_defvalue ;
18569 wxString const &arg2_defvalue = wxPyEmptyString ;
18570 wxString *arg2 = (wxString *) &arg2_defvalue ;
18571 wxString const &arg3_defvalue = wxPyEmptyString ;
18572 wxString *arg3 = (wxString *) &arg3_defvalue ;
18573 wxString const &arg4_defvalue = wxPyEmptyString ;
18574 wxString *arg4 = (wxString *) &arg4_defvalue ;
18575 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18576 wxFileConfig *result;
18577 bool temp1 = false ;
18578 bool temp2 = false ;
18579 bool temp3 = false ;
18580 bool temp4 = false ;
18581 PyObject * obj0 = 0 ;
18582 PyObject * obj1 = 0 ;
18583 PyObject * obj2 = 0 ;
18584 PyObject * obj3 = 0 ;
18585 PyObject * obj4 = 0 ;
18586 char *kwnames[] = {
18587 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18588 };
18589
18590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18591 if (obj0) {
18592 {
18593 arg1 = wxString_in_helper(obj0);
18594 if (arg1 == NULL) SWIG_fail;
18595 temp1 = true;
18596 }
18597 }
18598 if (obj1) {
18599 {
18600 arg2 = wxString_in_helper(obj1);
18601 if (arg2 == NULL) SWIG_fail;
18602 temp2 = true;
18603 }
18604 }
18605 if (obj2) {
18606 {
18607 arg3 = wxString_in_helper(obj2);
18608 if (arg3 == NULL) SWIG_fail;
18609 temp3 = true;
18610 }
18611 }
18612 if (obj3) {
18613 {
18614 arg4 = wxString_in_helper(obj3);
18615 if (arg4 == NULL) SWIG_fail;
18616 temp4 = true;
18617 }
18618 }
18619 if (obj4) {
18620 {
18621 arg5 = (long)(SWIG_As_long(obj4));
18622 if (SWIG_arg_fail(5)) SWIG_fail;
18623 }
18624 }
18625 {
18626 PyThreadState* __tstate = wxPyBeginAllowThreads();
18627 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18628
18629 wxPyEndAllowThreads(__tstate);
18630 if (PyErr_Occurred()) SWIG_fail;
18631 }
18632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18633 {
18634 if (temp1)
18635 delete arg1;
18636 }
18637 {
18638 if (temp2)
18639 delete arg2;
18640 }
18641 {
18642 if (temp3)
18643 delete arg3;
18644 }
18645 {
18646 if (temp4)
18647 delete arg4;
18648 }
18649 return resultobj;
18650 fail:
18651 {
18652 if (temp1)
18653 delete arg1;
18654 }
18655 {
18656 if (temp2)
18657 delete arg2;
18658 }
18659 {
18660 if (temp3)
18661 delete arg3;
18662 }
18663 {
18664 if (temp4)
18665 delete arg4;
18666 }
18667 return NULL;
18668 }
18669
18670
18671 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18672 PyObject *resultobj;
18673 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18674 PyObject * obj0 = 0 ;
18675 char *kwnames[] = {
18676 (char *) "self", NULL
18677 };
18678
18679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18681 if (SWIG_arg_fail(1)) SWIG_fail;
18682 {
18683 PyThreadState* __tstate = wxPyBeginAllowThreads();
18684 delete arg1;
18685
18686 wxPyEndAllowThreads(__tstate);
18687 if (PyErr_Occurred()) SWIG_fail;
18688 }
18689 Py_INCREF(Py_None); resultobj = Py_None;
18690 return resultobj;
18691 fail:
18692 return NULL;
18693 }
18694
18695
18696 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18697 PyObject *obj;
18698 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18699 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18700 Py_INCREF(obj);
18701 return Py_BuildValue((char *)"");
18702 }
18703 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18704 PyObject *resultobj;
18705 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18706 wxString *arg2 = 0 ;
18707 wxConfigPathChanger *result;
18708 bool temp2 = false ;
18709 PyObject * obj0 = 0 ;
18710 PyObject * obj1 = 0 ;
18711 char *kwnames[] = {
18712 (char *) "config",(char *) "entry", NULL
18713 };
18714
18715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18717 if (SWIG_arg_fail(1)) SWIG_fail;
18718 {
18719 arg2 = wxString_in_helper(obj1);
18720 if (arg2 == NULL) SWIG_fail;
18721 temp2 = true;
18722 }
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18726
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18731 {
18732 if (temp2)
18733 delete arg2;
18734 }
18735 return resultobj;
18736 fail:
18737 {
18738 if (temp2)
18739 delete arg2;
18740 }
18741 return NULL;
18742 }
18743
18744
18745 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18746 PyObject *resultobj;
18747 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18748 PyObject * obj0 = 0 ;
18749 char *kwnames[] = {
18750 (char *) "self", NULL
18751 };
18752
18753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18755 if (SWIG_arg_fail(1)) SWIG_fail;
18756 {
18757 PyThreadState* __tstate = wxPyBeginAllowThreads();
18758 delete arg1;
18759
18760 wxPyEndAllowThreads(__tstate);
18761 if (PyErr_Occurred()) SWIG_fail;
18762 }
18763 Py_INCREF(Py_None); resultobj = Py_None;
18764 return resultobj;
18765 fail:
18766 return NULL;
18767 }
18768
18769
18770 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18771 PyObject *resultobj;
18772 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18773 wxString *result;
18774 PyObject * obj0 = 0 ;
18775 char *kwnames[] = {
18776 (char *) "self", NULL
18777 };
18778
18779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18781 if (SWIG_arg_fail(1)) SWIG_fail;
18782 {
18783 PyThreadState* __tstate = wxPyBeginAllowThreads();
18784 {
18785 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18786 result = (wxString *) &_result_ref;
18787 }
18788
18789 wxPyEndAllowThreads(__tstate);
18790 if (PyErr_Occurred()) SWIG_fail;
18791 }
18792 {
18793 #if wxUSE_UNICODE
18794 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18795 #else
18796 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18797 #endif
18798 }
18799 return resultobj;
18800 fail:
18801 return NULL;
18802 }
18803
18804
18805 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18806 PyObject *obj;
18807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18808 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18809 Py_INCREF(obj);
18810 return Py_BuildValue((char *)"");
18811 }
18812 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18813 PyObject *resultobj;
18814 wxString *arg1 = 0 ;
18815 wxString result;
18816 bool temp1 = false ;
18817 PyObject * obj0 = 0 ;
18818 char *kwnames[] = {
18819 (char *) "sz", NULL
18820 };
18821
18822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18823 {
18824 arg1 = wxString_in_helper(obj0);
18825 if (arg1 == NULL) SWIG_fail;
18826 temp1 = true;
18827 }
18828 {
18829 PyThreadState* __tstate = wxPyBeginAllowThreads();
18830 result = wxExpandEnvVars((wxString const &)*arg1);
18831
18832 wxPyEndAllowThreads(__tstate);
18833 if (PyErr_Occurred()) SWIG_fail;
18834 }
18835 {
18836 #if wxUSE_UNICODE
18837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18838 #else
18839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18840 #endif
18841 }
18842 {
18843 if (temp1)
18844 delete arg1;
18845 }
18846 return resultobj;
18847 fail:
18848 {
18849 if (temp1)
18850 delete arg1;
18851 }
18852 return NULL;
18853 }
18854
18855
18856 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18857 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18858 return 1;
18859 }
18860
18861
18862 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18863 PyObject *pyobj;
18864
18865 {
18866 #if wxUSE_UNICODE
18867 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18868 #else
18869 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18870 #endif
18871 }
18872 return pyobj;
18873 }
18874
18875
18876 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18877 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18878 return 1;
18879 }
18880
18881
18882 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18883 PyObject *pyobj;
18884
18885 {
18886 #if wxUSE_UNICODE
18887 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18888 #else
18889 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18890 #endif
18891 }
18892 return pyobj;
18893 }
18894
18895
18896 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18897 PyObject *resultobj;
18898 wxDateTime::Country arg1 ;
18899 PyObject * obj0 = 0 ;
18900 char *kwnames[] = {
18901 (char *) "country", NULL
18902 };
18903
18904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18905 {
18906 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 }
18909 {
18910 PyThreadState* __tstate = wxPyBeginAllowThreads();
18911 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18912
18913 wxPyEndAllowThreads(__tstate);
18914 if (PyErr_Occurred()) SWIG_fail;
18915 }
18916 Py_INCREF(Py_None); resultobj = Py_None;
18917 return resultobj;
18918 fail:
18919 return NULL;
18920 }
18921
18922
18923 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18924 PyObject *resultobj;
18925 wxDateTime::Country result;
18926 char *kwnames[] = {
18927 NULL
18928 };
18929
18930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18931 {
18932 PyThreadState* __tstate = wxPyBeginAllowThreads();
18933 result = (wxDateTime::Country)wxDateTime::GetCountry();
18934
18935 wxPyEndAllowThreads(__tstate);
18936 if (PyErr_Occurred()) SWIG_fail;
18937 }
18938 resultobj = SWIG_From_int((result));
18939 return resultobj;
18940 fail:
18941 return NULL;
18942 }
18943
18944
18945 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18946 PyObject *resultobj;
18947 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18948 bool result;
18949 PyObject * obj0 = 0 ;
18950 char *kwnames[] = {
18951 (char *) "country", NULL
18952 };
18953
18954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18955 if (obj0) {
18956 {
18957 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18958 if (SWIG_arg_fail(1)) SWIG_fail;
18959 }
18960 }
18961 {
18962 PyThreadState* __tstate = wxPyBeginAllowThreads();
18963 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18964
18965 wxPyEndAllowThreads(__tstate);
18966 if (PyErr_Occurred()) SWIG_fail;
18967 }
18968 {
18969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18970 }
18971 return resultobj;
18972 fail:
18973 return NULL;
18974 }
18975
18976
18977 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18978 PyObject *resultobj;
18979 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18980 int result;
18981 PyObject * obj0 = 0 ;
18982 char *kwnames[] = {
18983 (char *) "cal", NULL
18984 };
18985
18986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18987 if (obj0) {
18988 {
18989 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18990 if (SWIG_arg_fail(1)) SWIG_fail;
18991 }
18992 }
18993 {
18994 PyThreadState* __tstate = wxPyBeginAllowThreads();
18995 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18996
18997 wxPyEndAllowThreads(__tstate);
18998 if (PyErr_Occurred()) SWIG_fail;
18999 }
19000 {
19001 resultobj = SWIG_From_int((int)(result));
19002 }
19003 return resultobj;
19004 fail:
19005 return NULL;
19006 }
19007
19008
19009 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19010 PyObject *resultobj;
19011 int arg1 ;
19012 int result;
19013 PyObject * obj0 = 0 ;
19014 char *kwnames[] = {
19015 (char *) "year", NULL
19016 };
19017
19018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19019 {
19020 arg1 = (int)(SWIG_As_int(obj0));
19021 if (SWIG_arg_fail(1)) SWIG_fail;
19022 }
19023 {
19024 PyThreadState* __tstate = wxPyBeginAllowThreads();
19025 result = (int)wxDateTime::ConvertYearToBC(arg1);
19026
19027 wxPyEndAllowThreads(__tstate);
19028 if (PyErr_Occurred()) SWIG_fail;
19029 }
19030 {
19031 resultobj = SWIG_From_int((int)(result));
19032 }
19033 return resultobj;
19034 fail:
19035 return NULL;
19036 }
19037
19038
19039 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19040 PyObject *resultobj;
19041 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19042 wxDateTime::Month result;
19043 PyObject * obj0 = 0 ;
19044 char *kwnames[] = {
19045 (char *) "cal", NULL
19046 };
19047
19048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19049 if (obj0) {
19050 {
19051 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19052 if (SWIG_arg_fail(1)) SWIG_fail;
19053 }
19054 }
19055 {
19056 PyThreadState* __tstate = wxPyBeginAllowThreads();
19057 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19058
19059 wxPyEndAllowThreads(__tstate);
19060 if (PyErr_Occurred()) SWIG_fail;
19061 }
19062 resultobj = SWIG_From_int((result));
19063 return resultobj;
19064 fail:
19065 return NULL;
19066 }
19067
19068
19069 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19070 PyObject *resultobj;
19071 int arg1 = (int) wxDateTime::Inv_Year ;
19072 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19073 bool result;
19074 PyObject * obj0 = 0 ;
19075 PyObject * obj1 = 0 ;
19076 char *kwnames[] = {
19077 (char *) "year",(char *) "cal", NULL
19078 };
19079
19080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19081 if (obj0) {
19082 {
19083 arg1 = (int)(SWIG_As_int(obj0));
19084 if (SWIG_arg_fail(1)) SWIG_fail;
19085 }
19086 }
19087 if (obj1) {
19088 {
19089 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19090 if (SWIG_arg_fail(2)) SWIG_fail;
19091 }
19092 }
19093 {
19094 PyThreadState* __tstate = wxPyBeginAllowThreads();
19095 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19096
19097 wxPyEndAllowThreads(__tstate);
19098 if (PyErr_Occurred()) SWIG_fail;
19099 }
19100 {
19101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19102 }
19103 return resultobj;
19104 fail:
19105 return NULL;
19106 }
19107
19108
19109 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19110 PyObject *resultobj;
19111 int arg1 = (int) wxDateTime::Inv_Year ;
19112 int result;
19113 PyObject * obj0 = 0 ;
19114 char *kwnames[] = {
19115 (char *) "year", NULL
19116 };
19117
19118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19119 if (obj0) {
19120 {
19121 arg1 = (int)(SWIG_As_int(obj0));
19122 if (SWIG_arg_fail(1)) SWIG_fail;
19123 }
19124 }
19125 {
19126 PyThreadState* __tstate = wxPyBeginAllowThreads();
19127 result = (int)wxDateTime::GetCentury(arg1);
19128
19129 wxPyEndAllowThreads(__tstate);
19130 if (PyErr_Occurred()) SWIG_fail;
19131 }
19132 {
19133 resultobj = SWIG_From_int((int)(result));
19134 }
19135 return resultobj;
19136 fail:
19137 return NULL;
19138 }
19139
19140
19141 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19142 PyObject *resultobj;
19143 int arg1 ;
19144 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19145 int result;
19146 PyObject * obj0 = 0 ;
19147 PyObject * obj1 = 0 ;
19148 char *kwnames[] = {
19149 (char *) "year",(char *) "cal", NULL
19150 };
19151
19152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19153 {
19154 arg1 = (int)(SWIG_As_int(obj0));
19155 if (SWIG_arg_fail(1)) SWIG_fail;
19156 }
19157 if (obj1) {
19158 {
19159 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19160 if (SWIG_arg_fail(2)) SWIG_fail;
19161 }
19162 }
19163 {
19164 PyThreadState* __tstate = wxPyBeginAllowThreads();
19165 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19166
19167 wxPyEndAllowThreads(__tstate);
19168 if (PyErr_Occurred()) SWIG_fail;
19169 }
19170 {
19171 resultobj = SWIG_From_int((int)(result));
19172 }
19173 return resultobj;
19174 fail:
19175 return NULL;
19176 }
19177
19178
19179 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19180 PyObject *resultobj;
19181 wxDateTime::Month arg1 ;
19182 int arg2 = (int) wxDateTime::Inv_Year ;
19183 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19184 int result;
19185 PyObject * obj0 = 0 ;
19186 PyObject * obj1 = 0 ;
19187 PyObject * obj2 = 0 ;
19188 char *kwnames[] = {
19189 (char *) "month",(char *) "year",(char *) "cal", NULL
19190 };
19191
19192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19193 {
19194 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19195 if (SWIG_arg_fail(1)) SWIG_fail;
19196 }
19197 if (obj1) {
19198 {
19199 arg2 = (int)(SWIG_As_int(obj1));
19200 if (SWIG_arg_fail(2)) SWIG_fail;
19201 }
19202 }
19203 if (obj2) {
19204 {
19205 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19206 if (SWIG_arg_fail(3)) SWIG_fail;
19207 }
19208 }
19209 {
19210 PyThreadState* __tstate = wxPyBeginAllowThreads();
19211 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19212
19213 wxPyEndAllowThreads(__tstate);
19214 if (PyErr_Occurred()) SWIG_fail;
19215 }
19216 {
19217 resultobj = SWIG_From_int((int)(result));
19218 }
19219 return resultobj;
19220 fail:
19221 return NULL;
19222 }
19223
19224
19225 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19226 PyObject *resultobj;
19227 wxDateTime::Month arg1 ;
19228 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19229 wxString result;
19230 PyObject * obj0 = 0 ;
19231 PyObject * obj1 = 0 ;
19232 char *kwnames[] = {
19233 (char *) "month",(char *) "flags", NULL
19234 };
19235
19236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19237 {
19238 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19239 if (SWIG_arg_fail(1)) SWIG_fail;
19240 }
19241 if (obj1) {
19242 {
19243 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19244 if (SWIG_arg_fail(2)) SWIG_fail;
19245 }
19246 }
19247 {
19248 PyThreadState* __tstate = wxPyBeginAllowThreads();
19249 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19250
19251 wxPyEndAllowThreads(__tstate);
19252 if (PyErr_Occurred()) SWIG_fail;
19253 }
19254 {
19255 #if wxUSE_UNICODE
19256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19257 #else
19258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19259 #endif
19260 }
19261 return resultobj;
19262 fail:
19263 return NULL;
19264 }
19265
19266
19267 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19268 PyObject *resultobj;
19269 wxDateTime::WeekDay arg1 ;
19270 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19271 wxString result;
19272 PyObject * obj0 = 0 ;
19273 PyObject * obj1 = 0 ;
19274 char *kwnames[] = {
19275 (char *) "weekday",(char *) "flags", NULL
19276 };
19277
19278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19279 {
19280 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19281 if (SWIG_arg_fail(1)) SWIG_fail;
19282 }
19283 if (obj1) {
19284 {
19285 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19286 if (SWIG_arg_fail(2)) SWIG_fail;
19287 }
19288 }
19289 {
19290 PyThreadState* __tstate = wxPyBeginAllowThreads();
19291 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19292
19293 wxPyEndAllowThreads(__tstate);
19294 if (PyErr_Occurred()) SWIG_fail;
19295 }
19296 {
19297 #if wxUSE_UNICODE
19298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19299 #else
19300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19301 #endif
19302 }
19303 return resultobj;
19304 fail:
19305 return NULL;
19306 }
19307
19308
19309 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19310 PyObject *resultobj;
19311 wxString *arg1 = (wxString *) 0 ;
19312 wxString *arg2 = (wxString *) 0 ;
19313 bool temp1 = false ;
19314 bool temp2 = false ;
19315 PyObject * obj0 = 0 ;
19316 PyObject * obj1 = 0 ;
19317 char *kwnames[] = {
19318 (char *) "OUTPUT",(char *) "OUTPUT", NULL
19319 };
19320
19321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
19322 {
19323 arg1 = wxString_in_helper(obj0);
19324 if (arg1 == NULL) SWIG_fail;
19325 temp1 = true;
19326 }
19327 {
19328 arg2 = wxString_in_helper(obj1);
19329 if (arg2 == NULL) SWIG_fail;
19330 temp2 = true;
19331 }
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 wxDateTime::GetAmPmStrings(arg1,arg2);
19335
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 Py_INCREF(Py_None); resultobj = Py_None;
19340 {
19341 if (temp1)
19342 delete arg1;
19343 }
19344 {
19345 if (temp2)
19346 delete arg2;
19347 }
19348 return resultobj;
19349 fail:
19350 {
19351 if (temp1)
19352 delete arg1;
19353 }
19354 {
19355 if (temp2)
19356 delete arg2;
19357 }
19358 return NULL;
19359 }
19360
19361
19362 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj;
19364 int arg1 = (int) wxDateTime::Inv_Year ;
19365 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19366 bool result;
19367 PyObject * obj0 = 0 ;
19368 PyObject * obj1 = 0 ;
19369 char *kwnames[] = {
19370 (char *) "year",(char *) "country", NULL
19371 };
19372
19373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19374 if (obj0) {
19375 {
19376 arg1 = (int)(SWIG_As_int(obj0));
19377 if (SWIG_arg_fail(1)) SWIG_fail;
19378 }
19379 }
19380 if (obj1) {
19381 {
19382 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19383 if (SWIG_arg_fail(2)) SWIG_fail;
19384 }
19385 }
19386 {
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19389
19390 wxPyEndAllowThreads(__tstate);
19391 if (PyErr_Occurred()) SWIG_fail;
19392 }
19393 {
19394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19395 }
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19403 PyObject *resultobj;
19404 int arg1 = (int) wxDateTime::Inv_Year ;
19405 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19406 wxDateTime result;
19407 PyObject * obj0 = 0 ;
19408 PyObject * obj1 = 0 ;
19409 char *kwnames[] = {
19410 (char *) "year",(char *) "country", NULL
19411 };
19412
19413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19414 if (obj0) {
19415 {
19416 arg1 = (int)(SWIG_As_int(obj0));
19417 if (SWIG_arg_fail(1)) SWIG_fail;
19418 }
19419 }
19420 if (obj1) {
19421 {
19422 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19423 if (SWIG_arg_fail(2)) SWIG_fail;
19424 }
19425 }
19426 {
19427 PyThreadState* __tstate = wxPyBeginAllowThreads();
19428 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19429
19430 wxPyEndAllowThreads(__tstate);
19431 if (PyErr_Occurred()) SWIG_fail;
19432 }
19433 {
19434 wxDateTime * resultptr;
19435 resultptr = new wxDateTime((wxDateTime &)(result));
19436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19437 }
19438 return resultobj;
19439 fail:
19440 return NULL;
19441 }
19442
19443
19444 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19445 PyObject *resultobj;
19446 int arg1 = (int) wxDateTime::Inv_Year ;
19447 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19448 wxDateTime result;
19449 PyObject * obj0 = 0 ;
19450 PyObject * obj1 = 0 ;
19451 char *kwnames[] = {
19452 (char *) "year",(char *) "country", NULL
19453 };
19454
19455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19456 if (obj0) {
19457 {
19458 arg1 = (int)(SWIG_As_int(obj0));
19459 if (SWIG_arg_fail(1)) SWIG_fail;
19460 }
19461 }
19462 if (obj1) {
19463 {
19464 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19465 if (SWIG_arg_fail(2)) SWIG_fail;
19466 }
19467 }
19468 {
19469 PyThreadState* __tstate = wxPyBeginAllowThreads();
19470 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19471
19472 wxPyEndAllowThreads(__tstate);
19473 if (PyErr_Occurred()) SWIG_fail;
19474 }
19475 {
19476 wxDateTime * resultptr;
19477 resultptr = new wxDateTime((wxDateTime &)(result));
19478 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19479 }
19480 return resultobj;
19481 fail:
19482 return NULL;
19483 }
19484
19485
19486 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19487 PyObject *resultobj;
19488 wxDateTime result;
19489 char *kwnames[] = {
19490 NULL
19491 };
19492
19493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = wxDateTime::Now();
19497
19498 wxPyEndAllowThreads(__tstate);
19499 if (PyErr_Occurred()) SWIG_fail;
19500 }
19501 {
19502 wxDateTime * resultptr;
19503 resultptr = new wxDateTime((wxDateTime &)(result));
19504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19505 }
19506 return resultobj;
19507 fail:
19508 return NULL;
19509 }
19510
19511
19512 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19513 PyObject *resultobj;
19514 wxDateTime result;
19515 char *kwnames[] = {
19516 NULL
19517 };
19518
19519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19520 {
19521 PyThreadState* __tstate = wxPyBeginAllowThreads();
19522 result = wxDateTime::UNow();
19523
19524 wxPyEndAllowThreads(__tstate);
19525 if (PyErr_Occurred()) SWIG_fail;
19526 }
19527 {
19528 wxDateTime * resultptr;
19529 resultptr = new wxDateTime((wxDateTime &)(result));
19530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19531 }
19532 return resultobj;
19533 fail:
19534 return NULL;
19535 }
19536
19537
19538 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19539 PyObject *resultobj;
19540 wxDateTime result;
19541 char *kwnames[] = {
19542 NULL
19543 };
19544
19545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19546 {
19547 PyThreadState* __tstate = wxPyBeginAllowThreads();
19548 result = wxDateTime::Today();
19549
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 {
19554 wxDateTime * resultptr;
19555 resultptr = new wxDateTime((wxDateTime &)(result));
19556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19557 }
19558 return resultobj;
19559 fail:
19560 return NULL;
19561 }
19562
19563
19564 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19565 PyObject *resultobj;
19566 wxDateTime *result;
19567 char *kwnames[] = {
19568 NULL
19569 };
19570
19571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19572 {
19573 PyThreadState* __tstate = wxPyBeginAllowThreads();
19574 result = (wxDateTime *)new wxDateTime();
19575
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19587 PyObject *resultobj;
19588 time_t arg1 ;
19589 wxDateTime *result;
19590 PyObject * obj0 = 0 ;
19591 char *kwnames[] = {
19592 (char *) "timet", NULL
19593 };
19594
19595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19596 {
19597 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19598 if (SWIG_arg_fail(1)) SWIG_fail;
19599 }
19600 {
19601 PyThreadState* __tstate = wxPyBeginAllowThreads();
19602 result = (wxDateTime *)new wxDateTime(arg1);
19603
19604 wxPyEndAllowThreads(__tstate);
19605 if (PyErr_Occurred()) SWIG_fail;
19606 }
19607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19608 return resultobj;
19609 fail:
19610 return NULL;
19611 }
19612
19613
19614 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19615 PyObject *resultobj;
19616 double arg1 ;
19617 wxDateTime *result;
19618 PyObject * obj0 = 0 ;
19619 char *kwnames[] = {
19620 (char *) "jdn", NULL
19621 };
19622
19623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19624 {
19625 arg1 = (double)(SWIG_As_double(obj0));
19626 if (SWIG_arg_fail(1)) SWIG_fail;
19627 }
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 result = (wxDateTime *)new wxDateTime(arg1);
19631
19632 wxPyEndAllowThreads(__tstate);
19633 if (PyErr_Occurred()) SWIG_fail;
19634 }
19635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19636 return resultobj;
19637 fail:
19638 return NULL;
19639 }
19640
19641
19642 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19643 PyObject *resultobj;
19644 int arg1 ;
19645 int arg2 = (int) 0 ;
19646 int arg3 = (int) 0 ;
19647 int arg4 = (int) 0 ;
19648 wxDateTime *result;
19649 PyObject * obj0 = 0 ;
19650 PyObject * obj1 = 0 ;
19651 PyObject * obj2 = 0 ;
19652 PyObject * obj3 = 0 ;
19653 char *kwnames[] = {
19654 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19655 };
19656
19657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19658 {
19659 arg1 = (int)(SWIG_As_int(obj0));
19660 if (SWIG_arg_fail(1)) SWIG_fail;
19661 }
19662 if (obj1) {
19663 {
19664 arg2 = (int)(SWIG_As_int(obj1));
19665 if (SWIG_arg_fail(2)) SWIG_fail;
19666 }
19667 }
19668 if (obj2) {
19669 {
19670 arg3 = (int)(SWIG_As_int(obj2));
19671 if (SWIG_arg_fail(3)) SWIG_fail;
19672 }
19673 }
19674 if (obj3) {
19675 {
19676 arg4 = (int)(SWIG_As_int(obj3));
19677 if (SWIG_arg_fail(4)) SWIG_fail;
19678 }
19679 }
19680 {
19681 PyThreadState* __tstate = wxPyBeginAllowThreads();
19682 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19683
19684 wxPyEndAllowThreads(__tstate);
19685 if (PyErr_Occurred()) SWIG_fail;
19686 }
19687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19688 return resultobj;
19689 fail:
19690 return NULL;
19691 }
19692
19693
19694 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19695 PyObject *resultobj;
19696 int arg1 ;
19697 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19698 int arg3 = (int) wxDateTime::Inv_Year ;
19699 int arg4 = (int) 0 ;
19700 int arg5 = (int) 0 ;
19701 int arg6 = (int) 0 ;
19702 int arg7 = (int) 0 ;
19703 wxDateTime *result;
19704 PyObject * obj0 = 0 ;
19705 PyObject * obj1 = 0 ;
19706 PyObject * obj2 = 0 ;
19707 PyObject * obj3 = 0 ;
19708 PyObject * obj4 = 0 ;
19709 PyObject * obj5 = 0 ;
19710 PyObject * obj6 = 0 ;
19711 char *kwnames[] = {
19712 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19713 };
19714
19715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19716 {
19717 arg1 = (int)(SWIG_As_int(obj0));
19718 if (SWIG_arg_fail(1)) SWIG_fail;
19719 }
19720 if (obj1) {
19721 {
19722 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19723 if (SWIG_arg_fail(2)) SWIG_fail;
19724 }
19725 }
19726 if (obj2) {
19727 {
19728 arg3 = (int)(SWIG_As_int(obj2));
19729 if (SWIG_arg_fail(3)) SWIG_fail;
19730 }
19731 }
19732 if (obj3) {
19733 {
19734 arg4 = (int)(SWIG_As_int(obj3));
19735 if (SWIG_arg_fail(4)) SWIG_fail;
19736 }
19737 }
19738 if (obj4) {
19739 {
19740 arg5 = (int)(SWIG_As_int(obj4));
19741 if (SWIG_arg_fail(5)) SWIG_fail;
19742 }
19743 }
19744 if (obj5) {
19745 {
19746 arg6 = (int)(SWIG_As_int(obj5));
19747 if (SWIG_arg_fail(6)) SWIG_fail;
19748 }
19749 }
19750 if (obj6) {
19751 {
19752 arg7 = (int)(SWIG_As_int(obj6));
19753 if (SWIG_arg_fail(7)) SWIG_fail;
19754 }
19755 }
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19759
19760 wxPyEndAllowThreads(__tstate);
19761 if (PyErr_Occurred()) SWIG_fail;
19762 }
19763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19764 return resultobj;
19765 fail:
19766 return NULL;
19767 }
19768
19769
19770 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19771 PyObject *resultobj;
19772 wxDateTime *arg1 = (wxDateTime *) 0 ;
19773 PyObject * obj0 = 0 ;
19774 char *kwnames[] = {
19775 (char *) "self", NULL
19776 };
19777
19778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19780 if (SWIG_arg_fail(1)) SWIG_fail;
19781 {
19782 PyThreadState* __tstate = wxPyBeginAllowThreads();
19783 delete arg1;
19784
19785 wxPyEndAllowThreads(__tstate);
19786 if (PyErr_Occurred()) SWIG_fail;
19787 }
19788 Py_INCREF(Py_None); resultobj = Py_None;
19789 return resultobj;
19790 fail:
19791 return NULL;
19792 }
19793
19794
19795 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19796 PyObject *resultobj;
19797 wxDateTime *arg1 = (wxDateTime *) 0 ;
19798 wxDateTime *result;
19799 PyObject * obj0 = 0 ;
19800 char *kwnames[] = {
19801 (char *) "self", NULL
19802 };
19803
19804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19806 if (SWIG_arg_fail(1)) SWIG_fail;
19807 {
19808 PyThreadState* __tstate = wxPyBeginAllowThreads();
19809 {
19810 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19811 result = (wxDateTime *) &_result_ref;
19812 }
19813
19814 wxPyEndAllowThreads(__tstate);
19815 if (PyErr_Occurred()) SWIG_fail;
19816 }
19817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19818 return resultobj;
19819 fail:
19820 return NULL;
19821 }
19822
19823
19824 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19825 PyObject *resultobj;
19826 wxDateTime *arg1 = (wxDateTime *) 0 ;
19827 time_t arg2 ;
19828 wxDateTime *result;
19829 PyObject * obj0 = 0 ;
19830 PyObject * obj1 = 0 ;
19831 char *kwnames[] = {
19832 (char *) "self",(char *) "timet", NULL
19833 };
19834
19835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19837 if (SWIG_arg_fail(1)) SWIG_fail;
19838 {
19839 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19840 if (SWIG_arg_fail(2)) SWIG_fail;
19841 }
19842 {
19843 PyThreadState* __tstate = wxPyBeginAllowThreads();
19844 {
19845 wxDateTime &_result_ref = (arg1)->Set(arg2);
19846 result = (wxDateTime *) &_result_ref;
19847 }
19848
19849 wxPyEndAllowThreads(__tstate);
19850 if (PyErr_Occurred()) SWIG_fail;
19851 }
19852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19853 return resultobj;
19854 fail:
19855 return NULL;
19856 }
19857
19858
19859 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19860 PyObject *resultobj;
19861 wxDateTime *arg1 = (wxDateTime *) 0 ;
19862 double arg2 ;
19863 wxDateTime *result;
19864 PyObject * obj0 = 0 ;
19865 PyObject * obj1 = 0 ;
19866 char *kwnames[] = {
19867 (char *) "self",(char *) "jdn", NULL
19868 };
19869
19870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19872 if (SWIG_arg_fail(1)) SWIG_fail;
19873 {
19874 arg2 = (double)(SWIG_As_double(obj1));
19875 if (SWIG_arg_fail(2)) SWIG_fail;
19876 }
19877 {
19878 PyThreadState* __tstate = wxPyBeginAllowThreads();
19879 {
19880 wxDateTime &_result_ref = (arg1)->Set(arg2);
19881 result = (wxDateTime *) &_result_ref;
19882 }
19883
19884 wxPyEndAllowThreads(__tstate);
19885 if (PyErr_Occurred()) SWIG_fail;
19886 }
19887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19888 return resultobj;
19889 fail:
19890 return NULL;
19891 }
19892
19893
19894 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19895 PyObject *resultobj;
19896 wxDateTime *arg1 = (wxDateTime *) 0 ;
19897 int arg2 ;
19898 int arg3 = (int) 0 ;
19899 int arg4 = (int) 0 ;
19900 int arg5 = (int) 0 ;
19901 wxDateTime *result;
19902 PyObject * obj0 = 0 ;
19903 PyObject * obj1 = 0 ;
19904 PyObject * obj2 = 0 ;
19905 PyObject * obj3 = 0 ;
19906 PyObject * obj4 = 0 ;
19907 char *kwnames[] = {
19908 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19909 };
19910
19911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19913 if (SWIG_arg_fail(1)) SWIG_fail;
19914 {
19915 arg2 = (int)(SWIG_As_int(obj1));
19916 if (SWIG_arg_fail(2)) SWIG_fail;
19917 }
19918 if (obj2) {
19919 {
19920 arg3 = (int)(SWIG_As_int(obj2));
19921 if (SWIG_arg_fail(3)) SWIG_fail;
19922 }
19923 }
19924 if (obj3) {
19925 {
19926 arg4 = (int)(SWIG_As_int(obj3));
19927 if (SWIG_arg_fail(4)) SWIG_fail;
19928 }
19929 }
19930 if (obj4) {
19931 {
19932 arg5 = (int)(SWIG_As_int(obj4));
19933 if (SWIG_arg_fail(5)) SWIG_fail;
19934 }
19935 }
19936 {
19937 PyThreadState* __tstate = wxPyBeginAllowThreads();
19938 {
19939 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19940 result = (wxDateTime *) &_result_ref;
19941 }
19942
19943 wxPyEndAllowThreads(__tstate);
19944 if (PyErr_Occurred()) SWIG_fail;
19945 }
19946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19954 PyObject *resultobj;
19955 wxDateTime *arg1 = (wxDateTime *) 0 ;
19956 int arg2 ;
19957 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19958 int arg4 = (int) wxDateTime::Inv_Year ;
19959 int arg5 = (int) 0 ;
19960 int arg6 = (int) 0 ;
19961 int arg7 = (int) 0 ;
19962 int arg8 = (int) 0 ;
19963 wxDateTime *result;
19964 PyObject * obj0 = 0 ;
19965 PyObject * obj1 = 0 ;
19966 PyObject * obj2 = 0 ;
19967 PyObject * obj3 = 0 ;
19968 PyObject * obj4 = 0 ;
19969 PyObject * obj5 = 0 ;
19970 PyObject * obj6 = 0 ;
19971 PyObject * obj7 = 0 ;
19972 char *kwnames[] = {
19973 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19974 };
19975
19976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19978 if (SWIG_arg_fail(1)) SWIG_fail;
19979 {
19980 arg2 = (int)(SWIG_As_int(obj1));
19981 if (SWIG_arg_fail(2)) SWIG_fail;
19982 }
19983 if (obj2) {
19984 {
19985 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19986 if (SWIG_arg_fail(3)) SWIG_fail;
19987 }
19988 }
19989 if (obj3) {
19990 {
19991 arg4 = (int)(SWIG_As_int(obj3));
19992 if (SWIG_arg_fail(4)) SWIG_fail;
19993 }
19994 }
19995 if (obj4) {
19996 {
19997 arg5 = (int)(SWIG_As_int(obj4));
19998 if (SWIG_arg_fail(5)) SWIG_fail;
19999 }
20000 }
20001 if (obj5) {
20002 {
20003 arg6 = (int)(SWIG_As_int(obj5));
20004 if (SWIG_arg_fail(6)) SWIG_fail;
20005 }
20006 }
20007 if (obj6) {
20008 {
20009 arg7 = (int)(SWIG_As_int(obj6));
20010 if (SWIG_arg_fail(7)) SWIG_fail;
20011 }
20012 }
20013 if (obj7) {
20014 {
20015 arg8 = (int)(SWIG_As_int(obj7));
20016 if (SWIG_arg_fail(8)) SWIG_fail;
20017 }
20018 }
20019 {
20020 PyThreadState* __tstate = wxPyBeginAllowThreads();
20021 {
20022 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20023 result = (wxDateTime *) &_result_ref;
20024 }
20025
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20030 return resultobj;
20031 fail:
20032 return NULL;
20033 }
20034
20035
20036 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20037 PyObject *resultobj;
20038 wxDateTime *arg1 = (wxDateTime *) 0 ;
20039 wxDateTime *result;
20040 PyObject * obj0 = 0 ;
20041 char *kwnames[] = {
20042 (char *) "self", NULL
20043 };
20044
20045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20047 if (SWIG_arg_fail(1)) SWIG_fail;
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 {
20051 wxDateTime &_result_ref = (arg1)->ResetTime();
20052 result = (wxDateTime *) &_result_ref;
20053 }
20054
20055 wxPyEndAllowThreads(__tstate);
20056 if (PyErr_Occurred()) SWIG_fail;
20057 }
20058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20059 return resultobj;
20060 fail:
20061 return NULL;
20062 }
20063
20064
20065 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20066 PyObject *resultobj;
20067 wxDateTime *arg1 = (wxDateTime *) 0 ;
20068 int arg2 ;
20069 wxDateTime *result;
20070 PyObject * obj0 = 0 ;
20071 PyObject * obj1 = 0 ;
20072 char *kwnames[] = {
20073 (char *) "self",(char *) "year", NULL
20074 };
20075
20076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20078 if (SWIG_arg_fail(1)) SWIG_fail;
20079 {
20080 arg2 = (int)(SWIG_As_int(obj1));
20081 if (SWIG_arg_fail(2)) SWIG_fail;
20082 }
20083 {
20084 PyThreadState* __tstate = wxPyBeginAllowThreads();
20085 {
20086 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20087 result = (wxDateTime *) &_result_ref;
20088 }
20089
20090 wxPyEndAllowThreads(__tstate);
20091 if (PyErr_Occurred()) SWIG_fail;
20092 }
20093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20094 return resultobj;
20095 fail:
20096 return NULL;
20097 }
20098
20099
20100 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20101 PyObject *resultobj;
20102 wxDateTime *arg1 = (wxDateTime *) 0 ;
20103 wxDateTime::Month arg2 ;
20104 wxDateTime *result;
20105 PyObject * obj0 = 0 ;
20106 PyObject * obj1 = 0 ;
20107 char *kwnames[] = {
20108 (char *) "self",(char *) "month", NULL
20109 };
20110
20111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20113 if (SWIG_arg_fail(1)) SWIG_fail;
20114 {
20115 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20116 if (SWIG_arg_fail(2)) SWIG_fail;
20117 }
20118 {
20119 PyThreadState* __tstate = wxPyBeginAllowThreads();
20120 {
20121 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20122 result = (wxDateTime *) &_result_ref;
20123 }
20124
20125 wxPyEndAllowThreads(__tstate);
20126 if (PyErr_Occurred()) SWIG_fail;
20127 }
20128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20129 return resultobj;
20130 fail:
20131 return NULL;
20132 }
20133
20134
20135 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20136 PyObject *resultobj;
20137 wxDateTime *arg1 = (wxDateTime *) 0 ;
20138 int arg2 ;
20139 wxDateTime *result;
20140 PyObject * obj0 = 0 ;
20141 PyObject * obj1 = 0 ;
20142 char *kwnames[] = {
20143 (char *) "self",(char *) "day", NULL
20144 };
20145
20146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20148 if (SWIG_arg_fail(1)) SWIG_fail;
20149 {
20150 arg2 = (int)(SWIG_As_int(obj1));
20151 if (SWIG_arg_fail(2)) SWIG_fail;
20152 }
20153 {
20154 PyThreadState* __tstate = wxPyBeginAllowThreads();
20155 {
20156 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20157 result = (wxDateTime *) &_result_ref;
20158 }
20159
20160 wxPyEndAllowThreads(__tstate);
20161 if (PyErr_Occurred()) SWIG_fail;
20162 }
20163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20164 return resultobj;
20165 fail:
20166 return NULL;
20167 }
20168
20169
20170 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20171 PyObject *resultobj;
20172 wxDateTime *arg1 = (wxDateTime *) 0 ;
20173 int arg2 ;
20174 wxDateTime *result;
20175 PyObject * obj0 = 0 ;
20176 PyObject * obj1 = 0 ;
20177 char *kwnames[] = {
20178 (char *) "self",(char *) "hour", NULL
20179 };
20180
20181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20183 if (SWIG_arg_fail(1)) SWIG_fail;
20184 {
20185 arg2 = (int)(SWIG_As_int(obj1));
20186 if (SWIG_arg_fail(2)) SWIG_fail;
20187 }
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 {
20191 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20192 result = (wxDateTime *) &_result_ref;
20193 }
20194
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20206 PyObject *resultobj;
20207 wxDateTime *arg1 = (wxDateTime *) 0 ;
20208 int arg2 ;
20209 wxDateTime *result;
20210 PyObject * obj0 = 0 ;
20211 PyObject * obj1 = 0 ;
20212 char *kwnames[] = {
20213 (char *) "self",(char *) "minute", NULL
20214 };
20215
20216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20218 if (SWIG_arg_fail(1)) SWIG_fail;
20219 {
20220 arg2 = (int)(SWIG_As_int(obj1));
20221 if (SWIG_arg_fail(2)) SWIG_fail;
20222 }
20223 {
20224 PyThreadState* __tstate = wxPyBeginAllowThreads();
20225 {
20226 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20227 result = (wxDateTime *) &_result_ref;
20228 }
20229
20230 wxPyEndAllowThreads(__tstate);
20231 if (PyErr_Occurred()) SWIG_fail;
20232 }
20233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20234 return resultobj;
20235 fail:
20236 return NULL;
20237 }
20238
20239
20240 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20241 PyObject *resultobj;
20242 wxDateTime *arg1 = (wxDateTime *) 0 ;
20243 int arg2 ;
20244 wxDateTime *result;
20245 PyObject * obj0 = 0 ;
20246 PyObject * obj1 = 0 ;
20247 char *kwnames[] = {
20248 (char *) "self",(char *) "second", NULL
20249 };
20250
20251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20253 if (SWIG_arg_fail(1)) SWIG_fail;
20254 {
20255 arg2 = (int)(SWIG_As_int(obj1));
20256 if (SWIG_arg_fail(2)) SWIG_fail;
20257 }
20258 {
20259 PyThreadState* __tstate = wxPyBeginAllowThreads();
20260 {
20261 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20262 result = (wxDateTime *) &_result_ref;
20263 }
20264
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20269 return resultobj;
20270 fail:
20271 return NULL;
20272 }
20273
20274
20275 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20276 PyObject *resultobj;
20277 wxDateTime *arg1 = (wxDateTime *) 0 ;
20278 int arg2 ;
20279 wxDateTime *result;
20280 PyObject * obj0 = 0 ;
20281 PyObject * obj1 = 0 ;
20282 char *kwnames[] = {
20283 (char *) "self",(char *) "millisecond", NULL
20284 };
20285
20286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20288 if (SWIG_arg_fail(1)) SWIG_fail;
20289 {
20290 arg2 = (int)(SWIG_As_int(obj1));
20291 if (SWIG_arg_fail(2)) SWIG_fail;
20292 }
20293 {
20294 PyThreadState* __tstate = wxPyBeginAllowThreads();
20295 {
20296 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20297 result = (wxDateTime *) &_result_ref;
20298 }
20299
20300 wxPyEndAllowThreads(__tstate);
20301 if (PyErr_Occurred()) SWIG_fail;
20302 }
20303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20304 return resultobj;
20305 fail:
20306 return NULL;
20307 }
20308
20309
20310 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20311 PyObject *resultobj;
20312 wxDateTime *arg1 = (wxDateTime *) 0 ;
20313 wxDateTime::WeekDay arg2 ;
20314 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20315 wxDateTime *result;
20316 PyObject * obj0 = 0 ;
20317 PyObject * obj1 = 0 ;
20318 PyObject * obj2 = 0 ;
20319 char *kwnames[] = {
20320 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20321 };
20322
20323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20325 if (SWIG_arg_fail(1)) SWIG_fail;
20326 {
20327 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20328 if (SWIG_arg_fail(2)) SWIG_fail;
20329 }
20330 if (obj2) {
20331 {
20332 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20333 if (SWIG_arg_fail(3)) SWIG_fail;
20334 }
20335 }
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 {
20339 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20340 result = (wxDateTime *) &_result_ref;
20341 }
20342
20343 wxPyEndAllowThreads(__tstate);
20344 if (PyErr_Occurred()) SWIG_fail;
20345 }
20346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20347 return resultobj;
20348 fail:
20349 return NULL;
20350 }
20351
20352
20353 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20354 PyObject *resultobj;
20355 wxDateTime *arg1 = (wxDateTime *) 0 ;
20356 wxDateTime::WeekDay arg2 ;
20357 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20358 wxDateTime result;
20359 PyObject * obj0 = 0 ;
20360 PyObject * obj1 = 0 ;
20361 PyObject * obj2 = 0 ;
20362 char *kwnames[] = {
20363 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20364 };
20365
20366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20368 if (SWIG_arg_fail(1)) SWIG_fail;
20369 {
20370 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20371 if (SWIG_arg_fail(2)) SWIG_fail;
20372 }
20373 if (obj2) {
20374 {
20375 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20376 if (SWIG_arg_fail(3)) SWIG_fail;
20377 }
20378 }
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20382
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 {
20387 wxDateTime * resultptr;
20388 resultptr = new wxDateTime((wxDateTime &)(result));
20389 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20390 }
20391 return resultobj;
20392 fail:
20393 return NULL;
20394 }
20395
20396
20397 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20398 PyObject *resultobj;
20399 wxDateTime *arg1 = (wxDateTime *) 0 ;
20400 wxDateTime::WeekDay arg2 ;
20401 wxDateTime *result;
20402 PyObject * obj0 = 0 ;
20403 PyObject * obj1 = 0 ;
20404 char *kwnames[] = {
20405 (char *) "self",(char *) "weekday", NULL
20406 };
20407
20408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20410 if (SWIG_arg_fail(1)) SWIG_fail;
20411 {
20412 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20413 if (SWIG_arg_fail(2)) SWIG_fail;
20414 }
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 {
20418 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20419 result = (wxDateTime *) &_result_ref;
20420 }
20421
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20426 return resultobj;
20427 fail:
20428 return NULL;
20429 }
20430
20431
20432 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20433 PyObject *resultobj;
20434 wxDateTime *arg1 = (wxDateTime *) 0 ;
20435 wxDateTime::WeekDay arg2 ;
20436 wxDateTime result;
20437 PyObject * obj0 = 0 ;
20438 PyObject * obj1 = 0 ;
20439 char *kwnames[] = {
20440 (char *) "self",(char *) "weekday", NULL
20441 };
20442
20443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20445 if (SWIG_arg_fail(1)) SWIG_fail;
20446 {
20447 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20448 if (SWIG_arg_fail(2)) SWIG_fail;
20449 }
20450 {
20451 PyThreadState* __tstate = wxPyBeginAllowThreads();
20452 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20453
20454 wxPyEndAllowThreads(__tstate);
20455 if (PyErr_Occurred()) SWIG_fail;
20456 }
20457 {
20458 wxDateTime * resultptr;
20459 resultptr = new wxDateTime((wxDateTime &)(result));
20460 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20461 }
20462 return resultobj;
20463 fail:
20464 return NULL;
20465 }
20466
20467
20468 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20469 PyObject *resultobj;
20470 wxDateTime *arg1 = (wxDateTime *) 0 ;
20471 wxDateTime::WeekDay arg2 ;
20472 wxDateTime *result;
20473 PyObject * obj0 = 0 ;
20474 PyObject * obj1 = 0 ;
20475 char *kwnames[] = {
20476 (char *) "self",(char *) "weekday", NULL
20477 };
20478
20479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20481 if (SWIG_arg_fail(1)) SWIG_fail;
20482 {
20483 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20484 if (SWIG_arg_fail(2)) SWIG_fail;
20485 }
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 {
20489 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20490 result = (wxDateTime *) &_result_ref;
20491 }
20492
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20497 return resultobj;
20498 fail:
20499 return NULL;
20500 }
20501
20502
20503 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20504 PyObject *resultobj;
20505 wxDateTime *arg1 = (wxDateTime *) 0 ;
20506 wxDateTime::WeekDay arg2 ;
20507 wxDateTime result;
20508 PyObject * obj0 = 0 ;
20509 PyObject * obj1 = 0 ;
20510 char *kwnames[] = {
20511 (char *) "self",(char *) "weekday", NULL
20512 };
20513
20514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20516 if (SWIG_arg_fail(1)) SWIG_fail;
20517 {
20518 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20519 if (SWIG_arg_fail(2)) SWIG_fail;
20520 }
20521 {
20522 PyThreadState* __tstate = wxPyBeginAllowThreads();
20523 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20524
20525 wxPyEndAllowThreads(__tstate);
20526 if (PyErr_Occurred()) SWIG_fail;
20527 }
20528 {
20529 wxDateTime * resultptr;
20530 resultptr = new wxDateTime((wxDateTime &)(result));
20531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20532 }
20533 return resultobj;
20534 fail:
20535 return NULL;
20536 }
20537
20538
20539 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20540 PyObject *resultobj;
20541 wxDateTime *arg1 = (wxDateTime *) 0 ;
20542 wxDateTime::WeekDay arg2 ;
20543 int arg3 = (int) 1 ;
20544 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20545 int arg5 = (int) wxDateTime::Inv_Year ;
20546 bool result;
20547 PyObject * obj0 = 0 ;
20548 PyObject * obj1 = 0 ;
20549 PyObject * obj2 = 0 ;
20550 PyObject * obj3 = 0 ;
20551 PyObject * obj4 = 0 ;
20552 char *kwnames[] = {
20553 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20554 };
20555
20556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20558 if (SWIG_arg_fail(1)) SWIG_fail;
20559 {
20560 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20561 if (SWIG_arg_fail(2)) SWIG_fail;
20562 }
20563 if (obj2) {
20564 {
20565 arg3 = (int)(SWIG_As_int(obj2));
20566 if (SWIG_arg_fail(3)) SWIG_fail;
20567 }
20568 }
20569 if (obj3) {
20570 {
20571 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20572 if (SWIG_arg_fail(4)) SWIG_fail;
20573 }
20574 }
20575 if (obj4) {
20576 {
20577 arg5 = (int)(SWIG_As_int(obj4));
20578 if (SWIG_arg_fail(5)) SWIG_fail;
20579 }
20580 }
20581 {
20582 PyThreadState* __tstate = wxPyBeginAllowThreads();
20583 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20584
20585 wxPyEndAllowThreads(__tstate);
20586 if (PyErr_Occurred()) SWIG_fail;
20587 }
20588 {
20589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20590 }
20591 return resultobj;
20592 fail:
20593 return NULL;
20594 }
20595
20596
20597 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20598 PyObject *resultobj;
20599 wxDateTime *arg1 = (wxDateTime *) 0 ;
20600 wxDateTime::WeekDay arg2 ;
20601 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20602 int arg4 = (int) wxDateTime::Inv_Year ;
20603 bool result;
20604 PyObject * obj0 = 0 ;
20605 PyObject * obj1 = 0 ;
20606 PyObject * obj2 = 0 ;
20607 PyObject * obj3 = 0 ;
20608 char *kwnames[] = {
20609 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20610 };
20611
20612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20614 if (SWIG_arg_fail(1)) SWIG_fail;
20615 {
20616 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20617 if (SWIG_arg_fail(2)) SWIG_fail;
20618 }
20619 if (obj2) {
20620 {
20621 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20622 if (SWIG_arg_fail(3)) SWIG_fail;
20623 }
20624 }
20625 if (obj3) {
20626 {
20627 arg4 = (int)(SWIG_As_int(obj3));
20628 if (SWIG_arg_fail(4)) SWIG_fail;
20629 }
20630 }
20631 {
20632 PyThreadState* __tstate = wxPyBeginAllowThreads();
20633 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20634
20635 wxPyEndAllowThreads(__tstate);
20636 if (PyErr_Occurred()) SWIG_fail;
20637 }
20638 {
20639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20640 }
20641 return resultobj;
20642 fail:
20643 return NULL;
20644 }
20645
20646
20647 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20648 PyObject *resultobj;
20649 wxDateTime *arg1 = (wxDateTime *) 0 ;
20650 wxDateTime::WeekDay arg2 ;
20651 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20652 int arg4 = (int) wxDateTime::Inv_Year ;
20653 wxDateTime result;
20654 PyObject * obj0 = 0 ;
20655 PyObject * obj1 = 0 ;
20656 PyObject * obj2 = 0 ;
20657 PyObject * obj3 = 0 ;
20658 char *kwnames[] = {
20659 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20660 };
20661
20662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20664 if (SWIG_arg_fail(1)) SWIG_fail;
20665 {
20666 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20667 if (SWIG_arg_fail(2)) SWIG_fail;
20668 }
20669 if (obj2) {
20670 {
20671 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20672 if (SWIG_arg_fail(3)) SWIG_fail;
20673 }
20674 }
20675 if (obj3) {
20676 {
20677 arg4 = (int)(SWIG_As_int(obj3));
20678 if (SWIG_arg_fail(4)) SWIG_fail;
20679 }
20680 }
20681 {
20682 PyThreadState* __tstate = wxPyBeginAllowThreads();
20683 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20684
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 {
20689 wxDateTime * resultptr;
20690 resultptr = new wxDateTime((wxDateTime &)(result));
20691 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20692 }
20693 return resultobj;
20694 fail:
20695 return NULL;
20696 }
20697
20698
20699 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20700 PyObject *resultobj;
20701 wxDateTime *arg1 = (wxDateTime *) 0 ;
20702 int arg2 ;
20703 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20704 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20705 bool result;
20706 PyObject * obj0 = 0 ;
20707 PyObject * obj1 = 0 ;
20708 PyObject * obj2 = 0 ;
20709 PyObject * obj3 = 0 ;
20710 char *kwnames[] = {
20711 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20712 };
20713
20714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20716 if (SWIG_arg_fail(1)) SWIG_fail;
20717 {
20718 arg2 = (int)(SWIG_As_int(obj1));
20719 if (SWIG_arg_fail(2)) SWIG_fail;
20720 }
20721 if (obj2) {
20722 {
20723 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20724 if (SWIG_arg_fail(3)) SWIG_fail;
20725 }
20726 }
20727 if (obj3) {
20728 {
20729 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20730 if (SWIG_arg_fail(4)) SWIG_fail;
20731 }
20732 }
20733 {
20734 PyThreadState* __tstate = wxPyBeginAllowThreads();
20735 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20736
20737 wxPyEndAllowThreads(__tstate);
20738 if (PyErr_Occurred()) SWIG_fail;
20739 }
20740 {
20741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20742 }
20743 return resultobj;
20744 fail:
20745 return NULL;
20746 }
20747
20748
20749 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20750 PyObject *resultobj;
20751 wxDateTime *arg1 = (wxDateTime *) 0 ;
20752 int arg2 ;
20753 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20754 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20755 wxDateTime result;
20756 PyObject * obj0 = 0 ;
20757 PyObject * obj1 = 0 ;
20758 PyObject * obj2 = 0 ;
20759 PyObject * obj3 = 0 ;
20760 char *kwnames[] = {
20761 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20762 };
20763
20764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20766 if (SWIG_arg_fail(1)) SWIG_fail;
20767 {
20768 arg2 = (int)(SWIG_As_int(obj1));
20769 if (SWIG_arg_fail(2)) SWIG_fail;
20770 }
20771 if (obj2) {
20772 {
20773 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20774 if (SWIG_arg_fail(3)) SWIG_fail;
20775 }
20776 }
20777 if (obj3) {
20778 {
20779 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20780 if (SWIG_arg_fail(4)) SWIG_fail;
20781 }
20782 }
20783 {
20784 PyThreadState* __tstate = wxPyBeginAllowThreads();
20785 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20786
20787 wxPyEndAllowThreads(__tstate);
20788 if (PyErr_Occurred()) SWIG_fail;
20789 }
20790 {
20791 wxDateTime * resultptr;
20792 resultptr = new wxDateTime((wxDateTime &)(result));
20793 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20794 }
20795 return resultobj;
20796 fail:
20797 return NULL;
20798 }
20799
20800
20801 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20802 PyObject *resultobj;
20803 int arg1 ;
20804 int arg2 ;
20805 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20806 wxDateTime result;
20807 PyObject * obj0 = 0 ;
20808 PyObject * obj1 = 0 ;
20809 PyObject * obj2 = 0 ;
20810 char *kwnames[] = {
20811 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20812 };
20813
20814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20815 {
20816 arg1 = (int)(SWIG_As_int(obj0));
20817 if (SWIG_arg_fail(1)) SWIG_fail;
20818 }
20819 {
20820 arg2 = (int)(SWIG_As_int(obj1));
20821 if (SWIG_arg_fail(2)) SWIG_fail;
20822 }
20823 if (obj2) {
20824 {
20825 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20826 if (SWIG_arg_fail(3)) SWIG_fail;
20827 }
20828 }
20829 {
20830 PyThreadState* __tstate = wxPyBeginAllowThreads();
20831 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20832
20833 wxPyEndAllowThreads(__tstate);
20834 if (PyErr_Occurred()) SWIG_fail;
20835 }
20836 {
20837 wxDateTime * resultptr;
20838 resultptr = new wxDateTime((wxDateTime &)(result));
20839 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20840 }
20841 return resultobj;
20842 fail:
20843 return NULL;
20844 }
20845
20846
20847 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20848 PyObject *resultobj;
20849 wxDateTime *arg1 = (wxDateTime *) 0 ;
20850 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20851 int arg3 = (int) wxDateTime::Inv_Year ;
20852 wxDateTime *result;
20853 PyObject * obj0 = 0 ;
20854 PyObject * obj1 = 0 ;
20855 PyObject * obj2 = 0 ;
20856 char *kwnames[] = {
20857 (char *) "self",(char *) "month",(char *) "year", NULL
20858 };
20859
20860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20862 if (SWIG_arg_fail(1)) SWIG_fail;
20863 if (obj1) {
20864 {
20865 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20866 if (SWIG_arg_fail(2)) SWIG_fail;
20867 }
20868 }
20869 if (obj2) {
20870 {
20871 arg3 = (int)(SWIG_As_int(obj2));
20872 if (SWIG_arg_fail(3)) SWIG_fail;
20873 }
20874 }
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 {
20878 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20879 result = (wxDateTime *) &_result_ref;
20880 }
20881
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20886 return resultobj;
20887 fail:
20888 return NULL;
20889 }
20890
20891
20892 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20893 PyObject *resultobj;
20894 wxDateTime *arg1 = (wxDateTime *) 0 ;
20895 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20896 int arg3 = (int) wxDateTime::Inv_Year ;
20897 wxDateTime result;
20898 PyObject * obj0 = 0 ;
20899 PyObject * obj1 = 0 ;
20900 PyObject * obj2 = 0 ;
20901 char *kwnames[] = {
20902 (char *) "self",(char *) "month",(char *) "year", NULL
20903 };
20904
20905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20907 if (SWIG_arg_fail(1)) SWIG_fail;
20908 if (obj1) {
20909 {
20910 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20911 if (SWIG_arg_fail(2)) SWIG_fail;
20912 }
20913 }
20914 if (obj2) {
20915 {
20916 arg3 = (int)(SWIG_As_int(obj2));
20917 if (SWIG_arg_fail(3)) SWIG_fail;
20918 }
20919 }
20920 {
20921 PyThreadState* __tstate = wxPyBeginAllowThreads();
20922 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20923
20924 wxPyEndAllowThreads(__tstate);
20925 if (PyErr_Occurred()) SWIG_fail;
20926 }
20927 {
20928 wxDateTime * resultptr;
20929 resultptr = new wxDateTime((wxDateTime &)(result));
20930 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20931 }
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20939 PyObject *resultobj;
20940 wxDateTime *arg1 = (wxDateTime *) 0 ;
20941 int arg2 ;
20942 wxDateTime *result;
20943 PyObject * obj0 = 0 ;
20944 PyObject * obj1 = 0 ;
20945 char *kwnames[] = {
20946 (char *) "self",(char *) "yday", NULL
20947 };
20948
20949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20951 if (SWIG_arg_fail(1)) SWIG_fail;
20952 {
20953 arg2 = (int)(SWIG_As_int(obj1));
20954 if (SWIG_arg_fail(2)) SWIG_fail;
20955 }
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 {
20959 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20960 result = (wxDateTime *) &_result_ref;
20961 }
20962
20963 wxPyEndAllowThreads(__tstate);
20964 if (PyErr_Occurred()) SWIG_fail;
20965 }
20966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20967 return resultobj;
20968 fail:
20969 return NULL;
20970 }
20971
20972
20973 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20974 PyObject *resultobj;
20975 wxDateTime *arg1 = (wxDateTime *) 0 ;
20976 int arg2 ;
20977 wxDateTime result;
20978 PyObject * obj0 = 0 ;
20979 PyObject * obj1 = 0 ;
20980 char *kwnames[] = {
20981 (char *) "self",(char *) "yday", NULL
20982 };
20983
20984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20986 if (SWIG_arg_fail(1)) SWIG_fail;
20987 {
20988 arg2 = (int)(SWIG_As_int(obj1));
20989 if (SWIG_arg_fail(2)) SWIG_fail;
20990 }
20991 {
20992 PyThreadState* __tstate = wxPyBeginAllowThreads();
20993 result = (arg1)->GetYearDay(arg2);
20994
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 {
20999 wxDateTime * resultptr;
21000 resultptr = new wxDateTime((wxDateTime &)(result));
21001 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21002 }
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21010 PyObject *resultobj;
21011 wxDateTime *arg1 = (wxDateTime *) 0 ;
21012 double result;
21013 PyObject * obj0 = 0 ;
21014 char *kwnames[] = {
21015 (char *) "self", NULL
21016 };
21017
21018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21020 if (SWIG_arg_fail(1)) SWIG_fail;
21021 {
21022 PyThreadState* __tstate = wxPyBeginAllowThreads();
21023 result = (double)(arg1)->GetJulianDayNumber();
21024
21025 wxPyEndAllowThreads(__tstate);
21026 if (PyErr_Occurred()) SWIG_fail;
21027 }
21028 {
21029 resultobj = SWIG_From_double((double)(result));
21030 }
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21038 PyObject *resultobj;
21039 wxDateTime *arg1 = (wxDateTime *) 0 ;
21040 double result;
21041 PyObject * obj0 = 0 ;
21042 char *kwnames[] = {
21043 (char *) "self", NULL
21044 };
21045
21046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21048 if (SWIG_arg_fail(1)) SWIG_fail;
21049 {
21050 PyThreadState* __tstate = wxPyBeginAllowThreads();
21051 result = (double)(arg1)->GetJDN();
21052
21053 wxPyEndAllowThreads(__tstate);
21054 if (PyErr_Occurred()) SWIG_fail;
21055 }
21056 {
21057 resultobj = SWIG_From_double((double)(result));
21058 }
21059 return resultobj;
21060 fail:
21061 return NULL;
21062 }
21063
21064
21065 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21066 PyObject *resultobj;
21067 wxDateTime *arg1 = (wxDateTime *) 0 ;
21068 double result;
21069 PyObject * obj0 = 0 ;
21070 char *kwnames[] = {
21071 (char *) "self", NULL
21072 };
21073
21074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21076 if (SWIG_arg_fail(1)) SWIG_fail;
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21080
21081 wxPyEndAllowThreads(__tstate);
21082 if (PyErr_Occurred()) SWIG_fail;
21083 }
21084 {
21085 resultobj = SWIG_From_double((double)(result));
21086 }
21087 return resultobj;
21088 fail:
21089 return NULL;
21090 }
21091
21092
21093 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21094 PyObject *resultobj;
21095 wxDateTime *arg1 = (wxDateTime *) 0 ;
21096 double result;
21097 PyObject * obj0 = 0 ;
21098 char *kwnames[] = {
21099 (char *) "self", NULL
21100 };
21101
21102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21104 if (SWIG_arg_fail(1)) SWIG_fail;
21105 {
21106 PyThreadState* __tstate = wxPyBeginAllowThreads();
21107 result = (double)(arg1)->GetMJD();
21108
21109 wxPyEndAllowThreads(__tstate);
21110 if (PyErr_Occurred()) SWIG_fail;
21111 }
21112 {
21113 resultobj = SWIG_From_double((double)(result));
21114 }
21115 return resultobj;
21116 fail:
21117 return NULL;
21118 }
21119
21120
21121 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21122 PyObject *resultobj;
21123 wxDateTime *arg1 = (wxDateTime *) 0 ;
21124 double result;
21125 PyObject * obj0 = 0 ;
21126 char *kwnames[] = {
21127 (char *) "self", NULL
21128 };
21129
21130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21132 if (SWIG_arg_fail(1)) SWIG_fail;
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 result = (double)(arg1)->GetRataDie();
21136
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 {
21141 resultobj = SWIG_From_double((double)(result));
21142 }
21143 return resultobj;
21144 fail:
21145 return NULL;
21146 }
21147
21148
21149 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21150 PyObject *resultobj;
21151 wxDateTime *arg1 = (wxDateTime *) 0 ;
21152 wxDateTime::TimeZone *arg2 = 0 ;
21153 bool arg3 = (bool) false ;
21154 wxDateTime result;
21155 bool temp2 = false ;
21156 PyObject * obj0 = 0 ;
21157 PyObject * obj1 = 0 ;
21158 PyObject * obj2 = 0 ;
21159 char *kwnames[] = {
21160 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21161 };
21162
21163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21165 if (SWIG_arg_fail(1)) SWIG_fail;
21166 {
21167 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21168 temp2 = true;
21169 }
21170 if (obj2) {
21171 {
21172 arg3 = (bool)(SWIG_As_bool(obj2));
21173 if (SWIG_arg_fail(3)) SWIG_fail;
21174 }
21175 }
21176 {
21177 PyThreadState* __tstate = wxPyBeginAllowThreads();
21178 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21179
21180 wxPyEndAllowThreads(__tstate);
21181 if (PyErr_Occurred()) SWIG_fail;
21182 }
21183 {
21184 wxDateTime * resultptr;
21185 resultptr = new wxDateTime((wxDateTime &)(result));
21186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21187 }
21188 {
21189 if (temp2) delete arg2;
21190 }
21191 return resultobj;
21192 fail:
21193 {
21194 if (temp2) delete arg2;
21195 }
21196 return NULL;
21197 }
21198
21199
21200 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21201 PyObject *resultobj;
21202 wxDateTime *arg1 = (wxDateTime *) 0 ;
21203 wxDateTime::TimeZone *arg2 = 0 ;
21204 bool arg3 = (bool) false ;
21205 wxDateTime *result;
21206 bool temp2 = false ;
21207 PyObject * obj0 = 0 ;
21208 PyObject * obj1 = 0 ;
21209 PyObject * obj2 = 0 ;
21210 char *kwnames[] = {
21211 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21212 };
21213
21214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21216 if (SWIG_arg_fail(1)) SWIG_fail;
21217 {
21218 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21219 temp2 = true;
21220 }
21221 if (obj2) {
21222 {
21223 arg3 = (bool)(SWIG_As_bool(obj2));
21224 if (SWIG_arg_fail(3)) SWIG_fail;
21225 }
21226 }
21227 {
21228 PyThreadState* __tstate = wxPyBeginAllowThreads();
21229 {
21230 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21231 result = (wxDateTime *) &_result_ref;
21232 }
21233
21234 wxPyEndAllowThreads(__tstate);
21235 if (PyErr_Occurred()) SWIG_fail;
21236 }
21237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21238 {
21239 if (temp2) delete arg2;
21240 }
21241 return resultobj;
21242 fail:
21243 {
21244 if (temp2) delete arg2;
21245 }
21246 return NULL;
21247 }
21248
21249
21250 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21251 PyObject *resultobj;
21252 wxDateTime *arg1 = (wxDateTime *) 0 ;
21253 bool arg2 = (bool) false ;
21254 wxDateTime result;
21255 PyObject * obj0 = 0 ;
21256 PyObject * obj1 = 0 ;
21257 char *kwnames[] = {
21258 (char *) "self",(char *) "noDST", NULL
21259 };
21260
21261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21263 if (SWIG_arg_fail(1)) SWIG_fail;
21264 if (obj1) {
21265 {
21266 arg2 = (bool)(SWIG_As_bool(obj1));
21267 if (SWIG_arg_fail(2)) SWIG_fail;
21268 }
21269 }
21270 {
21271 PyThreadState* __tstate = wxPyBeginAllowThreads();
21272 result = (arg1)->ToGMT(arg2);
21273
21274 wxPyEndAllowThreads(__tstate);
21275 if (PyErr_Occurred()) SWIG_fail;
21276 }
21277 {
21278 wxDateTime * resultptr;
21279 resultptr = new wxDateTime((wxDateTime &)(result));
21280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21281 }
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21289 PyObject *resultobj;
21290 wxDateTime *arg1 = (wxDateTime *) 0 ;
21291 bool arg2 = (bool) false ;
21292 wxDateTime *result;
21293 PyObject * obj0 = 0 ;
21294 PyObject * obj1 = 0 ;
21295 char *kwnames[] = {
21296 (char *) "self",(char *) "noDST", NULL
21297 };
21298
21299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21301 if (SWIG_arg_fail(1)) SWIG_fail;
21302 if (obj1) {
21303 {
21304 arg2 = (bool)(SWIG_As_bool(obj1));
21305 if (SWIG_arg_fail(2)) SWIG_fail;
21306 }
21307 }
21308 {
21309 PyThreadState* __tstate = wxPyBeginAllowThreads();
21310 {
21311 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21312 result = (wxDateTime *) &_result_ref;
21313 }
21314
21315 wxPyEndAllowThreads(__tstate);
21316 if (PyErr_Occurred()) SWIG_fail;
21317 }
21318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21319 return resultobj;
21320 fail:
21321 return NULL;
21322 }
21323
21324
21325 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21326 PyObject *resultobj;
21327 wxDateTime *arg1 = (wxDateTime *) 0 ;
21328 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21329 int result;
21330 PyObject * obj0 = 0 ;
21331 PyObject * obj1 = 0 ;
21332 char *kwnames[] = {
21333 (char *) "self",(char *) "country", NULL
21334 };
21335
21336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21338 if (SWIG_arg_fail(1)) SWIG_fail;
21339 if (obj1) {
21340 {
21341 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21342 if (SWIG_arg_fail(2)) SWIG_fail;
21343 }
21344 }
21345 {
21346 PyThreadState* __tstate = wxPyBeginAllowThreads();
21347 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21348
21349 wxPyEndAllowThreads(__tstate);
21350 if (PyErr_Occurred()) SWIG_fail;
21351 }
21352 {
21353 resultobj = SWIG_From_int((int)(result));
21354 }
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21362 PyObject *resultobj;
21363 wxDateTime *arg1 = (wxDateTime *) 0 ;
21364 bool result;
21365 PyObject * obj0 = 0 ;
21366 char *kwnames[] = {
21367 (char *) "self", NULL
21368 };
21369
21370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21372 if (SWIG_arg_fail(1)) SWIG_fail;
21373 {
21374 PyThreadState* __tstate = wxPyBeginAllowThreads();
21375 result = (bool)((wxDateTime const *)arg1)->IsValid();
21376
21377 wxPyEndAllowThreads(__tstate);
21378 if (PyErr_Occurred()) SWIG_fail;
21379 }
21380 {
21381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21382 }
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj;
21391 wxDateTime *arg1 = (wxDateTime *) 0 ;
21392 time_t result;
21393 PyObject * obj0 = 0 ;
21394 char *kwnames[] = {
21395 (char *) "self", NULL
21396 };
21397
21398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21400 if (SWIG_arg_fail(1)) SWIG_fail;
21401 {
21402 PyThreadState* __tstate = wxPyBeginAllowThreads();
21403 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21404
21405 wxPyEndAllowThreads(__tstate);
21406 if (PyErr_Occurred()) SWIG_fail;
21407 }
21408 {
21409 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21410 }
21411 return resultobj;
21412 fail:
21413 return NULL;
21414 }
21415
21416
21417 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21418 PyObject *resultobj;
21419 wxDateTime *arg1 = (wxDateTime *) 0 ;
21420 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21421 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21422 int result;
21423 bool temp2 = false ;
21424 PyObject * obj0 = 0 ;
21425 PyObject * obj1 = 0 ;
21426 char *kwnames[] = {
21427 (char *) "self",(char *) "tz", NULL
21428 };
21429
21430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21432 if (SWIG_arg_fail(1)) SWIG_fail;
21433 if (obj1) {
21434 {
21435 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21436 temp2 = true;
21437 }
21438 }
21439 {
21440 PyThreadState* __tstate = wxPyBeginAllowThreads();
21441 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21442
21443 wxPyEndAllowThreads(__tstate);
21444 if (PyErr_Occurred()) SWIG_fail;
21445 }
21446 {
21447 resultobj = SWIG_From_int((int)(result));
21448 }
21449 {
21450 if (temp2) delete arg2;
21451 }
21452 return resultobj;
21453 fail:
21454 {
21455 if (temp2) delete arg2;
21456 }
21457 return NULL;
21458 }
21459
21460
21461 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21462 PyObject *resultobj;
21463 wxDateTime *arg1 = (wxDateTime *) 0 ;
21464 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21465 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21466 wxDateTime::Month result;
21467 bool temp2 = false ;
21468 PyObject * obj0 = 0 ;
21469 PyObject * obj1 = 0 ;
21470 char *kwnames[] = {
21471 (char *) "self",(char *) "tz", NULL
21472 };
21473
21474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21476 if (SWIG_arg_fail(1)) SWIG_fail;
21477 if (obj1) {
21478 {
21479 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21480 temp2 = true;
21481 }
21482 }
21483 {
21484 PyThreadState* __tstate = wxPyBeginAllowThreads();
21485 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21486
21487 wxPyEndAllowThreads(__tstate);
21488 if (PyErr_Occurred()) SWIG_fail;
21489 }
21490 resultobj = SWIG_From_int((result));
21491 {
21492 if (temp2) delete arg2;
21493 }
21494 return resultobj;
21495 fail:
21496 {
21497 if (temp2) delete arg2;
21498 }
21499 return NULL;
21500 }
21501
21502
21503 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21504 PyObject *resultobj;
21505 wxDateTime *arg1 = (wxDateTime *) 0 ;
21506 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21507 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21508 int result;
21509 bool temp2 = false ;
21510 PyObject * obj0 = 0 ;
21511 PyObject * obj1 = 0 ;
21512 char *kwnames[] = {
21513 (char *) "self",(char *) "tz", NULL
21514 };
21515
21516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21518 if (SWIG_arg_fail(1)) SWIG_fail;
21519 if (obj1) {
21520 {
21521 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21522 temp2 = true;
21523 }
21524 }
21525 {
21526 PyThreadState* __tstate = wxPyBeginAllowThreads();
21527 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21528
21529 wxPyEndAllowThreads(__tstate);
21530 if (PyErr_Occurred()) SWIG_fail;
21531 }
21532 {
21533 resultobj = SWIG_From_int((int)(result));
21534 }
21535 {
21536 if (temp2) delete arg2;
21537 }
21538 return resultobj;
21539 fail:
21540 {
21541 if (temp2) delete arg2;
21542 }
21543 return NULL;
21544 }
21545
21546
21547 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21548 PyObject *resultobj;
21549 wxDateTime *arg1 = (wxDateTime *) 0 ;
21550 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21551 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21552 wxDateTime::WeekDay result;
21553 bool temp2 = false ;
21554 PyObject * obj0 = 0 ;
21555 PyObject * obj1 = 0 ;
21556 char *kwnames[] = {
21557 (char *) "self",(char *) "tz", NULL
21558 };
21559
21560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21562 if (SWIG_arg_fail(1)) SWIG_fail;
21563 if (obj1) {
21564 {
21565 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21566 temp2 = true;
21567 }
21568 }
21569 {
21570 PyThreadState* __tstate = wxPyBeginAllowThreads();
21571 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21572
21573 wxPyEndAllowThreads(__tstate);
21574 if (PyErr_Occurred()) SWIG_fail;
21575 }
21576 resultobj = SWIG_From_int((result));
21577 {
21578 if (temp2) delete arg2;
21579 }
21580 return resultobj;
21581 fail:
21582 {
21583 if (temp2) delete arg2;
21584 }
21585 return NULL;
21586 }
21587
21588
21589 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21590 PyObject *resultobj;
21591 wxDateTime *arg1 = (wxDateTime *) 0 ;
21592 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21593 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21594 int result;
21595 bool temp2 = false ;
21596 PyObject * obj0 = 0 ;
21597 PyObject * obj1 = 0 ;
21598 char *kwnames[] = {
21599 (char *) "self",(char *) "tz", NULL
21600 };
21601
21602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21604 if (SWIG_arg_fail(1)) SWIG_fail;
21605 if (obj1) {
21606 {
21607 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21608 temp2 = true;
21609 }
21610 }
21611 {
21612 PyThreadState* __tstate = wxPyBeginAllowThreads();
21613 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21614
21615 wxPyEndAllowThreads(__tstate);
21616 if (PyErr_Occurred()) SWIG_fail;
21617 }
21618 {
21619 resultobj = SWIG_From_int((int)(result));
21620 }
21621 {
21622 if (temp2) delete arg2;
21623 }
21624 return resultobj;
21625 fail:
21626 {
21627 if (temp2) delete arg2;
21628 }
21629 return NULL;
21630 }
21631
21632
21633 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21634 PyObject *resultobj;
21635 wxDateTime *arg1 = (wxDateTime *) 0 ;
21636 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21637 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21638 int result;
21639 bool temp2 = false ;
21640 PyObject * obj0 = 0 ;
21641 PyObject * obj1 = 0 ;
21642 char *kwnames[] = {
21643 (char *) "self",(char *) "tz", NULL
21644 };
21645
21646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21648 if (SWIG_arg_fail(1)) SWIG_fail;
21649 if (obj1) {
21650 {
21651 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21652 temp2 = true;
21653 }
21654 }
21655 {
21656 PyThreadState* __tstate = wxPyBeginAllowThreads();
21657 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21658
21659 wxPyEndAllowThreads(__tstate);
21660 if (PyErr_Occurred()) SWIG_fail;
21661 }
21662 {
21663 resultobj = SWIG_From_int((int)(result));
21664 }
21665 {
21666 if (temp2) delete arg2;
21667 }
21668 return resultobj;
21669 fail:
21670 {
21671 if (temp2) delete arg2;
21672 }
21673 return NULL;
21674 }
21675
21676
21677 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21678 PyObject *resultobj;
21679 wxDateTime *arg1 = (wxDateTime *) 0 ;
21680 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21681 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21682 int result;
21683 bool temp2 = false ;
21684 PyObject * obj0 = 0 ;
21685 PyObject * obj1 = 0 ;
21686 char *kwnames[] = {
21687 (char *) "self",(char *) "tz", NULL
21688 };
21689
21690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21692 if (SWIG_arg_fail(1)) SWIG_fail;
21693 if (obj1) {
21694 {
21695 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21696 temp2 = true;
21697 }
21698 }
21699 {
21700 PyThreadState* __tstate = wxPyBeginAllowThreads();
21701 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21702
21703 wxPyEndAllowThreads(__tstate);
21704 if (PyErr_Occurred()) SWIG_fail;
21705 }
21706 {
21707 resultobj = SWIG_From_int((int)(result));
21708 }
21709 {
21710 if (temp2) delete arg2;
21711 }
21712 return resultobj;
21713 fail:
21714 {
21715 if (temp2) delete arg2;
21716 }
21717 return NULL;
21718 }
21719
21720
21721 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21722 PyObject *resultobj;
21723 wxDateTime *arg1 = (wxDateTime *) 0 ;
21724 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21725 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21726 int result;
21727 bool temp2 = false ;
21728 PyObject * obj0 = 0 ;
21729 PyObject * obj1 = 0 ;
21730 char *kwnames[] = {
21731 (char *) "self",(char *) "tz", NULL
21732 };
21733
21734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21736 if (SWIG_arg_fail(1)) SWIG_fail;
21737 if (obj1) {
21738 {
21739 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21740 temp2 = true;
21741 }
21742 }
21743 {
21744 PyThreadState* __tstate = wxPyBeginAllowThreads();
21745 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21746
21747 wxPyEndAllowThreads(__tstate);
21748 if (PyErr_Occurred()) SWIG_fail;
21749 }
21750 {
21751 resultobj = SWIG_From_int((int)(result));
21752 }
21753 {
21754 if (temp2) delete arg2;
21755 }
21756 return resultobj;
21757 fail:
21758 {
21759 if (temp2) delete arg2;
21760 }
21761 return NULL;
21762 }
21763
21764
21765 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21766 PyObject *resultobj;
21767 wxDateTime *arg1 = (wxDateTime *) 0 ;
21768 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21769 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21770 int result;
21771 bool temp2 = false ;
21772 PyObject * obj0 = 0 ;
21773 PyObject * obj1 = 0 ;
21774 char *kwnames[] = {
21775 (char *) "self",(char *) "tz", NULL
21776 };
21777
21778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21780 if (SWIG_arg_fail(1)) SWIG_fail;
21781 if (obj1) {
21782 {
21783 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21784 temp2 = true;
21785 }
21786 }
21787 {
21788 PyThreadState* __tstate = wxPyBeginAllowThreads();
21789 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21790
21791 wxPyEndAllowThreads(__tstate);
21792 if (PyErr_Occurred()) SWIG_fail;
21793 }
21794 {
21795 resultobj = SWIG_From_int((int)(result));
21796 }
21797 {
21798 if (temp2) delete arg2;
21799 }
21800 return resultobj;
21801 fail:
21802 {
21803 if (temp2) delete arg2;
21804 }
21805 return NULL;
21806 }
21807
21808
21809 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21810 PyObject *resultobj;
21811 wxDateTime *arg1 = (wxDateTime *) 0 ;
21812 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21813 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21814 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21815 int result;
21816 bool temp3 = false ;
21817 PyObject * obj0 = 0 ;
21818 PyObject * obj1 = 0 ;
21819 PyObject * obj2 = 0 ;
21820 char *kwnames[] = {
21821 (char *) "self",(char *) "flags",(char *) "tz", NULL
21822 };
21823
21824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21826 if (SWIG_arg_fail(1)) SWIG_fail;
21827 if (obj1) {
21828 {
21829 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21830 if (SWIG_arg_fail(2)) SWIG_fail;
21831 }
21832 }
21833 if (obj2) {
21834 {
21835 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21836 temp3 = true;
21837 }
21838 }
21839 {
21840 PyThreadState* __tstate = wxPyBeginAllowThreads();
21841 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21842
21843 wxPyEndAllowThreads(__tstate);
21844 if (PyErr_Occurred()) SWIG_fail;
21845 }
21846 {
21847 resultobj = SWIG_From_int((int)(result));
21848 }
21849 {
21850 if (temp3) delete arg3;
21851 }
21852 return resultobj;
21853 fail:
21854 {
21855 if (temp3) delete arg3;
21856 }
21857 return NULL;
21858 }
21859
21860
21861 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21862 PyObject *resultobj;
21863 wxDateTime *arg1 = (wxDateTime *) 0 ;
21864 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21865 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21866 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21867 int result;
21868 bool temp3 = false ;
21869 PyObject * obj0 = 0 ;
21870 PyObject * obj1 = 0 ;
21871 PyObject * obj2 = 0 ;
21872 char *kwnames[] = {
21873 (char *) "self",(char *) "flags",(char *) "tz", NULL
21874 };
21875
21876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21878 if (SWIG_arg_fail(1)) SWIG_fail;
21879 if (obj1) {
21880 {
21881 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21882 if (SWIG_arg_fail(2)) SWIG_fail;
21883 }
21884 }
21885 if (obj2) {
21886 {
21887 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21888 temp3 = true;
21889 }
21890 }
21891 {
21892 PyThreadState* __tstate = wxPyBeginAllowThreads();
21893 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21894
21895 wxPyEndAllowThreads(__tstate);
21896 if (PyErr_Occurred()) SWIG_fail;
21897 }
21898 {
21899 resultobj = SWIG_From_int((int)(result));
21900 }
21901 {
21902 if (temp3) delete arg3;
21903 }
21904 return resultobj;
21905 fail:
21906 {
21907 if (temp3) delete arg3;
21908 }
21909 return NULL;
21910 }
21911
21912
21913 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21914 PyObject *resultobj;
21915 wxDateTime *arg1 = (wxDateTime *) 0 ;
21916 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21917 bool result;
21918 PyObject * obj0 = 0 ;
21919 PyObject * obj1 = 0 ;
21920 char *kwnames[] = {
21921 (char *) "self",(char *) "country", NULL
21922 };
21923
21924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21926 if (SWIG_arg_fail(1)) SWIG_fail;
21927 if (obj1) {
21928 {
21929 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21930 if (SWIG_arg_fail(2)) SWIG_fail;
21931 }
21932 }
21933 {
21934 PyThreadState* __tstate = wxPyBeginAllowThreads();
21935 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21936
21937 wxPyEndAllowThreads(__tstate);
21938 if (PyErr_Occurred()) SWIG_fail;
21939 }
21940 {
21941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21942 }
21943 return resultobj;
21944 fail:
21945 return NULL;
21946 }
21947
21948
21949 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21950 PyObject *resultobj;
21951 wxDateTime *arg1 = (wxDateTime *) 0 ;
21952 wxDateTime *arg2 = 0 ;
21953 bool result;
21954 PyObject * obj0 = 0 ;
21955 PyObject * obj1 = 0 ;
21956 char *kwnames[] = {
21957 (char *) "self",(char *) "datetime", NULL
21958 };
21959
21960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21962 if (SWIG_arg_fail(1)) SWIG_fail;
21963 {
21964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21965 if (SWIG_arg_fail(2)) SWIG_fail;
21966 if (arg2 == NULL) {
21967 SWIG_null_ref("wxDateTime");
21968 }
21969 if (SWIG_arg_fail(2)) SWIG_fail;
21970 }
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21974
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 {
21979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21980 }
21981 return resultobj;
21982 fail:
21983 return NULL;
21984 }
21985
21986
21987 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21988 PyObject *resultobj;
21989 wxDateTime *arg1 = (wxDateTime *) 0 ;
21990 wxDateTime *arg2 = 0 ;
21991 bool result;
21992 PyObject * obj0 = 0 ;
21993 PyObject * obj1 = 0 ;
21994 char *kwnames[] = {
21995 (char *) "self",(char *) "datetime", NULL
21996 };
21997
21998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22000 if (SWIG_arg_fail(1)) SWIG_fail;
22001 {
22002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22003 if (SWIG_arg_fail(2)) SWIG_fail;
22004 if (arg2 == NULL) {
22005 SWIG_null_ref("wxDateTime");
22006 }
22007 if (SWIG_arg_fail(2)) SWIG_fail;
22008 }
22009 {
22010 PyThreadState* __tstate = wxPyBeginAllowThreads();
22011 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22012
22013 wxPyEndAllowThreads(__tstate);
22014 if (PyErr_Occurred()) SWIG_fail;
22015 }
22016 {
22017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22018 }
22019 return resultobj;
22020 fail:
22021 return NULL;
22022 }
22023
22024
22025 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22026 PyObject *resultobj;
22027 wxDateTime *arg1 = (wxDateTime *) 0 ;
22028 wxDateTime *arg2 = 0 ;
22029 bool result;
22030 PyObject * obj0 = 0 ;
22031 PyObject * obj1 = 0 ;
22032 char *kwnames[] = {
22033 (char *) "self",(char *) "datetime", NULL
22034 };
22035
22036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22038 if (SWIG_arg_fail(1)) SWIG_fail;
22039 {
22040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22041 if (SWIG_arg_fail(2)) SWIG_fail;
22042 if (arg2 == NULL) {
22043 SWIG_null_ref("wxDateTime");
22044 }
22045 if (SWIG_arg_fail(2)) SWIG_fail;
22046 }
22047 {
22048 PyThreadState* __tstate = wxPyBeginAllowThreads();
22049 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22050
22051 wxPyEndAllowThreads(__tstate);
22052 if (PyErr_Occurred()) SWIG_fail;
22053 }
22054 {
22055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22056 }
22057 return resultobj;
22058 fail:
22059 return NULL;
22060 }
22061
22062
22063 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22064 PyObject *resultobj;
22065 wxDateTime *arg1 = (wxDateTime *) 0 ;
22066 wxDateTime *arg2 = 0 ;
22067 wxDateTime *arg3 = 0 ;
22068 bool result;
22069 PyObject * obj0 = 0 ;
22070 PyObject * obj1 = 0 ;
22071 PyObject * obj2 = 0 ;
22072 char *kwnames[] = {
22073 (char *) "self",(char *) "t1",(char *) "t2", NULL
22074 };
22075
22076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22078 if (SWIG_arg_fail(1)) SWIG_fail;
22079 {
22080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22081 if (SWIG_arg_fail(2)) SWIG_fail;
22082 if (arg2 == NULL) {
22083 SWIG_null_ref("wxDateTime");
22084 }
22085 if (SWIG_arg_fail(2)) SWIG_fail;
22086 }
22087 {
22088 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22089 if (SWIG_arg_fail(3)) SWIG_fail;
22090 if (arg3 == NULL) {
22091 SWIG_null_ref("wxDateTime");
22092 }
22093 if (SWIG_arg_fail(3)) SWIG_fail;
22094 }
22095 {
22096 PyThreadState* __tstate = wxPyBeginAllowThreads();
22097 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22098
22099 wxPyEndAllowThreads(__tstate);
22100 if (PyErr_Occurred()) SWIG_fail;
22101 }
22102 {
22103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22104 }
22105 return resultobj;
22106 fail:
22107 return NULL;
22108 }
22109
22110
22111 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22112 PyObject *resultobj;
22113 wxDateTime *arg1 = (wxDateTime *) 0 ;
22114 wxDateTime *arg2 = 0 ;
22115 wxDateTime *arg3 = 0 ;
22116 bool result;
22117 PyObject * obj0 = 0 ;
22118 PyObject * obj1 = 0 ;
22119 PyObject * obj2 = 0 ;
22120 char *kwnames[] = {
22121 (char *) "self",(char *) "t1",(char *) "t2", NULL
22122 };
22123
22124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22126 if (SWIG_arg_fail(1)) SWIG_fail;
22127 {
22128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22129 if (SWIG_arg_fail(2)) SWIG_fail;
22130 if (arg2 == NULL) {
22131 SWIG_null_ref("wxDateTime");
22132 }
22133 if (SWIG_arg_fail(2)) SWIG_fail;
22134 }
22135 {
22136 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22137 if (SWIG_arg_fail(3)) SWIG_fail;
22138 if (arg3 == NULL) {
22139 SWIG_null_ref("wxDateTime");
22140 }
22141 if (SWIG_arg_fail(3)) SWIG_fail;
22142 }
22143 {
22144 PyThreadState* __tstate = wxPyBeginAllowThreads();
22145 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22146
22147 wxPyEndAllowThreads(__tstate);
22148 if (PyErr_Occurred()) SWIG_fail;
22149 }
22150 {
22151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22152 }
22153 return resultobj;
22154 fail:
22155 return NULL;
22156 }
22157
22158
22159 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22160 PyObject *resultobj;
22161 wxDateTime *arg1 = (wxDateTime *) 0 ;
22162 wxDateTime *arg2 = 0 ;
22163 bool result;
22164 PyObject * obj0 = 0 ;
22165 PyObject * obj1 = 0 ;
22166 char *kwnames[] = {
22167 (char *) "self",(char *) "dt", NULL
22168 };
22169
22170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22172 if (SWIG_arg_fail(1)) SWIG_fail;
22173 {
22174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22175 if (SWIG_arg_fail(2)) SWIG_fail;
22176 if (arg2 == NULL) {
22177 SWIG_null_ref("wxDateTime");
22178 }
22179 if (SWIG_arg_fail(2)) SWIG_fail;
22180 }
22181 {
22182 PyThreadState* __tstate = wxPyBeginAllowThreads();
22183 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22184
22185 wxPyEndAllowThreads(__tstate);
22186 if (PyErr_Occurred()) SWIG_fail;
22187 }
22188 {
22189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22190 }
22191 return resultobj;
22192 fail:
22193 return NULL;
22194 }
22195
22196
22197 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22198 PyObject *resultobj;
22199 wxDateTime *arg1 = (wxDateTime *) 0 ;
22200 wxDateTime *arg2 = 0 ;
22201 bool result;
22202 PyObject * obj0 = 0 ;
22203 PyObject * obj1 = 0 ;
22204 char *kwnames[] = {
22205 (char *) "self",(char *) "dt", NULL
22206 };
22207
22208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22210 if (SWIG_arg_fail(1)) SWIG_fail;
22211 {
22212 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22213 if (SWIG_arg_fail(2)) SWIG_fail;
22214 if (arg2 == NULL) {
22215 SWIG_null_ref("wxDateTime");
22216 }
22217 if (SWIG_arg_fail(2)) SWIG_fail;
22218 }
22219 {
22220 PyThreadState* __tstate = wxPyBeginAllowThreads();
22221 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22222
22223 wxPyEndAllowThreads(__tstate);
22224 if (PyErr_Occurred()) SWIG_fail;
22225 }
22226 {
22227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22228 }
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22236 PyObject *resultobj;
22237 wxDateTime *arg1 = (wxDateTime *) 0 ;
22238 wxDateTime *arg2 = 0 ;
22239 wxTimeSpan *arg3 = 0 ;
22240 bool result;
22241 PyObject * obj0 = 0 ;
22242 PyObject * obj1 = 0 ;
22243 PyObject * obj2 = 0 ;
22244 char *kwnames[] = {
22245 (char *) "self",(char *) "dt",(char *) "ts", NULL
22246 };
22247
22248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22250 if (SWIG_arg_fail(1)) SWIG_fail;
22251 {
22252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22253 if (SWIG_arg_fail(2)) SWIG_fail;
22254 if (arg2 == NULL) {
22255 SWIG_null_ref("wxDateTime");
22256 }
22257 if (SWIG_arg_fail(2)) SWIG_fail;
22258 }
22259 {
22260 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22261 if (SWIG_arg_fail(3)) SWIG_fail;
22262 if (arg3 == NULL) {
22263 SWIG_null_ref("wxTimeSpan");
22264 }
22265 if (SWIG_arg_fail(3)) SWIG_fail;
22266 }
22267 {
22268 PyThreadState* __tstate = wxPyBeginAllowThreads();
22269 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22270
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 {
22275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22276 }
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22284 PyObject *resultobj;
22285 wxDateTime *arg1 = (wxDateTime *) 0 ;
22286 wxTimeSpan *arg2 = 0 ;
22287 wxDateTime *result;
22288 PyObject * obj0 = 0 ;
22289 PyObject * obj1 = 0 ;
22290 char *kwnames[] = {
22291 (char *) "self",(char *) "diff", NULL
22292 };
22293
22294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22296 if (SWIG_arg_fail(1)) SWIG_fail;
22297 {
22298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22299 if (SWIG_arg_fail(2)) SWIG_fail;
22300 if (arg2 == NULL) {
22301 SWIG_null_ref("wxTimeSpan");
22302 }
22303 if (SWIG_arg_fail(2)) SWIG_fail;
22304 }
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 {
22308 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22309 result = (wxDateTime *) &_result_ref;
22310 }
22311
22312 wxPyEndAllowThreads(__tstate);
22313 if (PyErr_Occurred()) SWIG_fail;
22314 }
22315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22316 return resultobj;
22317 fail:
22318 return NULL;
22319 }
22320
22321
22322 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22323 PyObject *resultobj;
22324 wxDateTime *arg1 = (wxDateTime *) 0 ;
22325 wxDateSpan *arg2 = 0 ;
22326 wxDateTime *result;
22327 PyObject * obj0 = 0 ;
22328 PyObject * obj1 = 0 ;
22329 char *kwnames[] = {
22330 (char *) "self",(char *) "diff", NULL
22331 };
22332
22333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22335 if (SWIG_arg_fail(1)) SWIG_fail;
22336 {
22337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22338 if (SWIG_arg_fail(2)) SWIG_fail;
22339 if (arg2 == NULL) {
22340 SWIG_null_ref("wxDateSpan");
22341 }
22342 if (SWIG_arg_fail(2)) SWIG_fail;
22343 }
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 {
22347 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22348 result = (wxDateTime *) &_result_ref;
22349 }
22350
22351 wxPyEndAllowThreads(__tstate);
22352 if (PyErr_Occurred()) SWIG_fail;
22353 }
22354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22355 return resultobj;
22356 fail:
22357 return NULL;
22358 }
22359
22360
22361 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22362 PyObject *resultobj;
22363 wxDateTime *arg1 = (wxDateTime *) 0 ;
22364 wxTimeSpan *arg2 = 0 ;
22365 wxDateTime *result;
22366 PyObject * obj0 = 0 ;
22367 PyObject * obj1 = 0 ;
22368 char *kwnames[] = {
22369 (char *) "self",(char *) "diff", NULL
22370 };
22371
22372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22374 if (SWIG_arg_fail(1)) SWIG_fail;
22375 {
22376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22377 if (SWIG_arg_fail(2)) SWIG_fail;
22378 if (arg2 == NULL) {
22379 SWIG_null_ref("wxTimeSpan");
22380 }
22381 if (SWIG_arg_fail(2)) SWIG_fail;
22382 }
22383 {
22384 PyThreadState* __tstate = wxPyBeginAllowThreads();
22385 {
22386 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22387 result = (wxDateTime *) &_result_ref;
22388 }
22389
22390 wxPyEndAllowThreads(__tstate);
22391 if (PyErr_Occurred()) SWIG_fail;
22392 }
22393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22394 return resultobj;
22395 fail:
22396 return NULL;
22397 }
22398
22399
22400 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22401 PyObject *resultobj;
22402 wxDateTime *arg1 = (wxDateTime *) 0 ;
22403 wxDateSpan *arg2 = 0 ;
22404 wxDateTime *result;
22405 PyObject * obj0 = 0 ;
22406 PyObject * obj1 = 0 ;
22407 char *kwnames[] = {
22408 (char *) "self",(char *) "diff", NULL
22409 };
22410
22411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22413 if (SWIG_arg_fail(1)) SWIG_fail;
22414 {
22415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22416 if (SWIG_arg_fail(2)) SWIG_fail;
22417 if (arg2 == NULL) {
22418 SWIG_null_ref("wxDateSpan");
22419 }
22420 if (SWIG_arg_fail(2)) SWIG_fail;
22421 }
22422 {
22423 PyThreadState* __tstate = wxPyBeginAllowThreads();
22424 {
22425 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22426 result = (wxDateTime *) &_result_ref;
22427 }
22428
22429 wxPyEndAllowThreads(__tstate);
22430 if (PyErr_Occurred()) SWIG_fail;
22431 }
22432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22433 return resultobj;
22434 fail:
22435 return NULL;
22436 }
22437
22438
22439 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22440 PyObject *resultobj;
22441 wxDateTime *arg1 = (wxDateTime *) 0 ;
22442 wxDateTime *arg2 = 0 ;
22443 wxTimeSpan result;
22444 PyObject * obj0 = 0 ;
22445 PyObject * obj1 = 0 ;
22446 char *kwnames[] = {
22447 (char *) "self",(char *) "dt", NULL
22448 };
22449
22450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22452 if (SWIG_arg_fail(1)) SWIG_fail;
22453 {
22454 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22455 if (SWIG_arg_fail(2)) SWIG_fail;
22456 if (arg2 == NULL) {
22457 SWIG_null_ref("wxDateTime");
22458 }
22459 if (SWIG_arg_fail(2)) SWIG_fail;
22460 }
22461 {
22462 PyThreadState* __tstate = wxPyBeginAllowThreads();
22463 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22464
22465 wxPyEndAllowThreads(__tstate);
22466 if (PyErr_Occurred()) SWIG_fail;
22467 }
22468 {
22469 wxTimeSpan * resultptr;
22470 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22472 }
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22480 PyObject *resultobj;
22481 wxDateTime *arg1 = (wxDateTime *) 0 ;
22482 wxTimeSpan *arg2 = 0 ;
22483 wxDateTime *result;
22484 PyObject * obj0 = 0 ;
22485 PyObject * obj1 = 0 ;
22486
22487 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22489 if (SWIG_arg_fail(1)) SWIG_fail;
22490 {
22491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22492 if (SWIG_arg_fail(2)) SWIG_fail;
22493 if (arg2 == NULL) {
22494 SWIG_null_ref("wxTimeSpan");
22495 }
22496 if (SWIG_arg_fail(2)) SWIG_fail;
22497 }
22498 {
22499 PyThreadState* __tstate = wxPyBeginAllowThreads();
22500 {
22501 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22502 result = (wxDateTime *) &_result_ref;
22503 }
22504
22505 wxPyEndAllowThreads(__tstate);
22506 if (PyErr_Occurred()) SWIG_fail;
22507 }
22508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22509 return resultobj;
22510 fail:
22511 return NULL;
22512 }
22513
22514
22515 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22516 PyObject *resultobj;
22517 wxDateTime *arg1 = (wxDateTime *) 0 ;
22518 wxDateSpan *arg2 = 0 ;
22519 wxDateTime *result;
22520 PyObject * obj0 = 0 ;
22521 PyObject * obj1 = 0 ;
22522
22523 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22525 if (SWIG_arg_fail(1)) SWIG_fail;
22526 {
22527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22528 if (SWIG_arg_fail(2)) SWIG_fail;
22529 if (arg2 == NULL) {
22530 SWIG_null_ref("wxDateSpan");
22531 }
22532 if (SWIG_arg_fail(2)) SWIG_fail;
22533 }
22534 {
22535 PyThreadState* __tstate = wxPyBeginAllowThreads();
22536 {
22537 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22538 result = (wxDateTime *) &_result_ref;
22539 }
22540
22541 wxPyEndAllowThreads(__tstate);
22542 if (PyErr_Occurred()) SWIG_fail;
22543 }
22544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22552 int argc;
22553 PyObject *argv[3];
22554 int ii;
22555
22556 argc = PyObject_Length(args);
22557 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22558 argv[ii] = PyTuple_GetItem(args,ii);
22559 }
22560 if (argc == 2) {
22561 int _v;
22562 {
22563 void *ptr;
22564 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22565 _v = 0;
22566 PyErr_Clear();
22567 } else {
22568 _v = 1;
22569 }
22570 }
22571 if (_v) {
22572 {
22573 void *ptr = 0;
22574 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22575 _v = 0;
22576 PyErr_Clear();
22577 } else {
22578 _v = (ptr != 0);
22579 }
22580 }
22581 if (_v) {
22582 return _wrap_DateTime___iadd____SWIG_0(self,args);
22583 }
22584 }
22585 }
22586 if (argc == 2) {
22587 int _v;
22588 {
22589 void *ptr;
22590 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22591 _v = 0;
22592 PyErr_Clear();
22593 } else {
22594 _v = 1;
22595 }
22596 }
22597 if (_v) {
22598 {
22599 void *ptr = 0;
22600 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22601 _v = 0;
22602 PyErr_Clear();
22603 } else {
22604 _v = (ptr != 0);
22605 }
22606 }
22607 if (_v) {
22608 return _wrap_DateTime___iadd____SWIG_1(self,args);
22609 }
22610 }
22611 }
22612
22613 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22614 return NULL;
22615 }
22616
22617
22618 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22619 PyObject *resultobj;
22620 wxDateTime *arg1 = (wxDateTime *) 0 ;
22621 wxTimeSpan *arg2 = 0 ;
22622 wxDateTime *result;
22623 PyObject * obj0 = 0 ;
22624 PyObject * obj1 = 0 ;
22625
22626 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22628 if (SWIG_arg_fail(1)) SWIG_fail;
22629 {
22630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22631 if (SWIG_arg_fail(2)) SWIG_fail;
22632 if (arg2 == NULL) {
22633 SWIG_null_ref("wxTimeSpan");
22634 }
22635 if (SWIG_arg_fail(2)) SWIG_fail;
22636 }
22637 {
22638 PyThreadState* __tstate = wxPyBeginAllowThreads();
22639 {
22640 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22641 result = (wxDateTime *) &_result_ref;
22642 }
22643
22644 wxPyEndAllowThreads(__tstate);
22645 if (PyErr_Occurred()) SWIG_fail;
22646 }
22647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22648 return resultobj;
22649 fail:
22650 return NULL;
22651 }
22652
22653
22654 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22655 PyObject *resultobj;
22656 wxDateTime *arg1 = (wxDateTime *) 0 ;
22657 wxDateSpan *arg2 = 0 ;
22658 wxDateTime *result;
22659 PyObject * obj0 = 0 ;
22660 PyObject * obj1 = 0 ;
22661
22662 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22664 if (SWIG_arg_fail(1)) SWIG_fail;
22665 {
22666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22667 if (SWIG_arg_fail(2)) SWIG_fail;
22668 if (arg2 == NULL) {
22669 SWIG_null_ref("wxDateSpan");
22670 }
22671 if (SWIG_arg_fail(2)) SWIG_fail;
22672 }
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 {
22676 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22677 result = (wxDateTime *) &_result_ref;
22678 }
22679
22680 wxPyEndAllowThreads(__tstate);
22681 if (PyErr_Occurred()) SWIG_fail;
22682 }
22683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22684 return resultobj;
22685 fail:
22686 return NULL;
22687 }
22688
22689
22690 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22691 int argc;
22692 PyObject *argv[3];
22693 int ii;
22694
22695 argc = PyObject_Length(args);
22696 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22697 argv[ii] = PyTuple_GetItem(args,ii);
22698 }
22699 if (argc == 2) {
22700 int _v;
22701 {
22702 void *ptr;
22703 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22704 _v = 0;
22705 PyErr_Clear();
22706 } else {
22707 _v = 1;
22708 }
22709 }
22710 if (_v) {
22711 {
22712 void *ptr = 0;
22713 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22714 _v = 0;
22715 PyErr_Clear();
22716 } else {
22717 _v = (ptr != 0);
22718 }
22719 }
22720 if (_v) {
22721 return _wrap_DateTime___isub____SWIG_0(self,args);
22722 }
22723 }
22724 }
22725 if (argc == 2) {
22726 int _v;
22727 {
22728 void *ptr;
22729 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22730 _v = 0;
22731 PyErr_Clear();
22732 } else {
22733 _v = 1;
22734 }
22735 }
22736 if (_v) {
22737 {
22738 void *ptr = 0;
22739 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22740 _v = 0;
22741 PyErr_Clear();
22742 } else {
22743 _v = (ptr != 0);
22744 }
22745 }
22746 if (_v) {
22747 return _wrap_DateTime___isub____SWIG_1(self,args);
22748 }
22749 }
22750 }
22751
22752 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22753 return NULL;
22754 }
22755
22756
22757 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22758 PyObject *resultobj;
22759 wxDateTime *arg1 = (wxDateTime *) 0 ;
22760 wxTimeSpan *arg2 = 0 ;
22761 wxDateTime result;
22762 PyObject * obj0 = 0 ;
22763 PyObject * obj1 = 0 ;
22764
22765 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22767 if (SWIG_arg_fail(1)) SWIG_fail;
22768 {
22769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22770 if (SWIG_arg_fail(2)) SWIG_fail;
22771 if (arg2 == NULL) {
22772 SWIG_null_ref("wxTimeSpan");
22773 }
22774 if (SWIG_arg_fail(2)) SWIG_fail;
22775 }
22776 {
22777 PyThreadState* __tstate = wxPyBeginAllowThreads();
22778 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22779
22780 wxPyEndAllowThreads(__tstate);
22781 if (PyErr_Occurred()) SWIG_fail;
22782 }
22783 {
22784 wxDateTime * resultptr;
22785 resultptr = new wxDateTime((wxDateTime &)(result));
22786 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22787 }
22788 return resultobj;
22789 fail:
22790 return NULL;
22791 }
22792
22793
22794 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22795 PyObject *resultobj;
22796 wxDateTime *arg1 = (wxDateTime *) 0 ;
22797 wxDateSpan *arg2 = 0 ;
22798 wxDateTime result;
22799 PyObject * obj0 = 0 ;
22800 PyObject * obj1 = 0 ;
22801
22802 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22804 if (SWIG_arg_fail(1)) SWIG_fail;
22805 {
22806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22807 if (SWIG_arg_fail(2)) SWIG_fail;
22808 if (arg2 == NULL) {
22809 SWIG_null_ref("wxDateSpan");
22810 }
22811 if (SWIG_arg_fail(2)) SWIG_fail;
22812 }
22813 {
22814 PyThreadState* __tstate = wxPyBeginAllowThreads();
22815 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22816
22817 wxPyEndAllowThreads(__tstate);
22818 if (PyErr_Occurred()) SWIG_fail;
22819 }
22820 {
22821 wxDateTime * resultptr;
22822 resultptr = new wxDateTime((wxDateTime &)(result));
22823 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22824 }
22825 return resultobj;
22826 fail:
22827 return NULL;
22828 }
22829
22830
22831 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22832 int argc;
22833 PyObject *argv[3];
22834 int ii;
22835
22836 argc = PyObject_Length(args);
22837 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22838 argv[ii] = PyTuple_GetItem(args,ii);
22839 }
22840 if (argc == 2) {
22841 int _v;
22842 {
22843 void *ptr;
22844 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22845 _v = 0;
22846 PyErr_Clear();
22847 } else {
22848 _v = 1;
22849 }
22850 }
22851 if (_v) {
22852 {
22853 void *ptr = 0;
22854 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22855 _v = 0;
22856 PyErr_Clear();
22857 } else {
22858 _v = (ptr != 0);
22859 }
22860 }
22861 if (_v) {
22862 return _wrap_DateTime___add____SWIG_0(self,args);
22863 }
22864 }
22865 }
22866 if (argc == 2) {
22867 int _v;
22868 {
22869 void *ptr;
22870 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22871 _v = 0;
22872 PyErr_Clear();
22873 } else {
22874 _v = 1;
22875 }
22876 }
22877 if (_v) {
22878 {
22879 void *ptr = 0;
22880 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22881 _v = 0;
22882 PyErr_Clear();
22883 } else {
22884 _v = (ptr != 0);
22885 }
22886 }
22887 if (_v) {
22888 return _wrap_DateTime___add____SWIG_1(self,args);
22889 }
22890 }
22891 }
22892
22893 Py_INCREF(Py_NotImplemented);
22894 return Py_NotImplemented;
22895 }
22896
22897
22898 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22899 PyObject *resultobj;
22900 wxDateTime *arg1 = (wxDateTime *) 0 ;
22901 wxDateTime *arg2 = 0 ;
22902 wxTimeSpan result;
22903 PyObject * obj0 = 0 ;
22904 PyObject * obj1 = 0 ;
22905
22906 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22908 if (SWIG_arg_fail(1)) SWIG_fail;
22909 {
22910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22911 if (SWIG_arg_fail(2)) SWIG_fail;
22912 if (arg2 == NULL) {
22913 SWIG_null_ref("wxDateTime");
22914 }
22915 if (SWIG_arg_fail(2)) SWIG_fail;
22916 }
22917 {
22918 PyThreadState* __tstate = wxPyBeginAllowThreads();
22919 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22920
22921 wxPyEndAllowThreads(__tstate);
22922 if (PyErr_Occurred()) SWIG_fail;
22923 }
22924 {
22925 wxTimeSpan * resultptr;
22926 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22927 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22928 }
22929 return resultobj;
22930 fail:
22931 return NULL;
22932 }
22933
22934
22935 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22936 PyObject *resultobj;
22937 wxDateTime *arg1 = (wxDateTime *) 0 ;
22938 wxTimeSpan *arg2 = 0 ;
22939 wxDateTime result;
22940 PyObject * obj0 = 0 ;
22941 PyObject * obj1 = 0 ;
22942
22943 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22945 if (SWIG_arg_fail(1)) SWIG_fail;
22946 {
22947 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22948 if (SWIG_arg_fail(2)) SWIG_fail;
22949 if (arg2 == NULL) {
22950 SWIG_null_ref("wxTimeSpan");
22951 }
22952 if (SWIG_arg_fail(2)) SWIG_fail;
22953 }
22954 {
22955 PyThreadState* __tstate = wxPyBeginAllowThreads();
22956 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22957
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 {
22962 wxDateTime * resultptr;
22963 resultptr = new wxDateTime((wxDateTime &)(result));
22964 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22965 }
22966 return resultobj;
22967 fail:
22968 return NULL;
22969 }
22970
22971
22972 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22973 PyObject *resultobj;
22974 wxDateTime *arg1 = (wxDateTime *) 0 ;
22975 wxDateSpan *arg2 = 0 ;
22976 wxDateTime result;
22977 PyObject * obj0 = 0 ;
22978 PyObject * obj1 = 0 ;
22979
22980 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22982 if (SWIG_arg_fail(1)) SWIG_fail;
22983 {
22984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22985 if (SWIG_arg_fail(2)) SWIG_fail;
22986 if (arg2 == NULL) {
22987 SWIG_null_ref("wxDateSpan");
22988 }
22989 if (SWIG_arg_fail(2)) SWIG_fail;
22990 }
22991 {
22992 PyThreadState* __tstate = wxPyBeginAllowThreads();
22993 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22994
22995 wxPyEndAllowThreads(__tstate);
22996 if (PyErr_Occurred()) SWIG_fail;
22997 }
22998 {
22999 wxDateTime * resultptr;
23000 resultptr = new wxDateTime((wxDateTime &)(result));
23001 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23002 }
23003 return resultobj;
23004 fail:
23005 return NULL;
23006 }
23007
23008
23009 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23010 int argc;
23011 PyObject *argv[3];
23012 int ii;
23013
23014 argc = PyObject_Length(args);
23015 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23016 argv[ii] = PyTuple_GetItem(args,ii);
23017 }
23018 if (argc == 2) {
23019 int _v;
23020 {
23021 void *ptr;
23022 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23023 _v = 0;
23024 PyErr_Clear();
23025 } else {
23026 _v = 1;
23027 }
23028 }
23029 if (_v) {
23030 {
23031 void *ptr = 0;
23032 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23033 _v = 0;
23034 PyErr_Clear();
23035 } else {
23036 _v = (ptr != 0);
23037 }
23038 }
23039 if (_v) {
23040 return _wrap_DateTime___sub____SWIG_0(self,args);
23041 }
23042 }
23043 }
23044 if (argc == 2) {
23045 int _v;
23046 {
23047 void *ptr;
23048 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23049 _v = 0;
23050 PyErr_Clear();
23051 } else {
23052 _v = 1;
23053 }
23054 }
23055 if (_v) {
23056 {
23057 void *ptr = 0;
23058 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23059 _v = 0;
23060 PyErr_Clear();
23061 } else {
23062 _v = (ptr != 0);
23063 }
23064 }
23065 if (_v) {
23066 return _wrap_DateTime___sub____SWIG_1(self,args);
23067 }
23068 }
23069 }
23070 if (argc == 2) {
23071 int _v;
23072 {
23073 void *ptr;
23074 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23075 _v = 0;
23076 PyErr_Clear();
23077 } else {
23078 _v = 1;
23079 }
23080 }
23081 if (_v) {
23082 {
23083 void *ptr = 0;
23084 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23085 _v = 0;
23086 PyErr_Clear();
23087 } else {
23088 _v = (ptr != 0);
23089 }
23090 }
23091 if (_v) {
23092 return _wrap_DateTime___sub____SWIG_2(self,args);
23093 }
23094 }
23095 }
23096
23097 Py_INCREF(Py_NotImplemented);
23098 return Py_NotImplemented;
23099 }
23100
23101
23102 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23103 PyObject *resultobj;
23104 wxDateTime *arg1 = (wxDateTime *) 0 ;
23105 wxDateTime *arg2 = (wxDateTime *) 0 ;
23106 bool result;
23107 PyObject * obj0 = 0 ;
23108 PyObject * obj1 = 0 ;
23109 char *kwnames[] = {
23110 (char *) "self",(char *) "other", NULL
23111 };
23112
23113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23115 if (SWIG_arg_fail(1)) SWIG_fail;
23116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23117 if (SWIG_arg_fail(2)) SWIG_fail;
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23121
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 {
23126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23127 }
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23135 PyObject *resultobj;
23136 wxDateTime *arg1 = (wxDateTime *) 0 ;
23137 wxDateTime *arg2 = (wxDateTime *) 0 ;
23138 bool result;
23139 PyObject * obj0 = 0 ;
23140 PyObject * obj1 = 0 ;
23141 char *kwnames[] = {
23142 (char *) "self",(char *) "other", NULL
23143 };
23144
23145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&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___le__(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___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
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 char *kwnames[] = {
23174 (char *) "self",(char *) "other", NULL
23175 };
23176
23177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23179 if (SWIG_arg_fail(1)) SWIG_fail;
23180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23181 if (SWIG_arg_fail(2)) SWIG_fail;
23182 {
23183 PyThreadState* __tstate = wxPyBeginAllowThreads();
23184 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23185
23186 wxPyEndAllowThreads(__tstate);
23187 if (PyErr_Occurred()) SWIG_fail;
23188 }
23189 {
23190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23191 }
23192 return resultobj;
23193 fail:
23194 return NULL;
23195 }
23196
23197
23198 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23199 PyObject *resultobj;
23200 wxDateTime *arg1 = (wxDateTime *) 0 ;
23201 wxDateTime *arg2 = (wxDateTime *) 0 ;
23202 bool result;
23203 PyObject * obj0 = 0 ;
23204 PyObject * obj1 = 0 ;
23205 char *kwnames[] = {
23206 (char *) "self",(char *) "other", NULL
23207 };
23208
23209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23211 if (SWIG_arg_fail(1)) SWIG_fail;
23212 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23213 if (SWIG_arg_fail(2)) SWIG_fail;
23214 {
23215 PyThreadState* __tstate = wxPyBeginAllowThreads();
23216 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23217
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 {
23222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23223 }
23224 return resultobj;
23225 fail:
23226 return NULL;
23227 }
23228
23229
23230 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23231 PyObject *resultobj;
23232 wxDateTime *arg1 = (wxDateTime *) 0 ;
23233 wxDateTime *arg2 = (wxDateTime *) 0 ;
23234 bool result;
23235 PyObject * obj0 = 0 ;
23236 PyObject * obj1 = 0 ;
23237 char *kwnames[] = {
23238 (char *) "self",(char *) "other", NULL
23239 };
23240
23241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23243 if (SWIG_arg_fail(1)) SWIG_fail;
23244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23245 if (SWIG_arg_fail(2)) SWIG_fail;
23246 {
23247 PyThreadState* __tstate = wxPyBeginAllowThreads();
23248 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23249
23250 wxPyEndAllowThreads(__tstate);
23251 if (PyErr_Occurred()) SWIG_fail;
23252 }
23253 {
23254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23255 }
23256 return resultobj;
23257 fail:
23258 return NULL;
23259 }
23260
23261
23262 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23263 PyObject *resultobj;
23264 wxDateTime *arg1 = (wxDateTime *) 0 ;
23265 wxDateTime *arg2 = (wxDateTime *) 0 ;
23266 bool result;
23267 PyObject * obj0 = 0 ;
23268 PyObject * obj1 = 0 ;
23269 char *kwnames[] = {
23270 (char *) "self",(char *) "other", NULL
23271 };
23272
23273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23275 if (SWIG_arg_fail(1)) SWIG_fail;
23276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23277 if (SWIG_arg_fail(2)) SWIG_fail;
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23281
23282 wxPyEndAllowThreads(__tstate);
23283 if (PyErr_Occurred()) SWIG_fail;
23284 }
23285 {
23286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23287 }
23288 return resultobj;
23289 fail:
23290 return NULL;
23291 }
23292
23293
23294 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23295 PyObject *resultobj;
23296 wxDateTime *arg1 = (wxDateTime *) 0 ;
23297 wxString *arg2 = 0 ;
23298 int result;
23299 bool temp2 = false ;
23300 PyObject * obj0 = 0 ;
23301 PyObject * obj1 = 0 ;
23302 char *kwnames[] = {
23303 (char *) "self",(char *) "date", NULL
23304 };
23305
23306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23308 if (SWIG_arg_fail(1)) SWIG_fail;
23309 {
23310 arg2 = wxString_in_helper(obj1);
23311 if (arg2 == NULL) SWIG_fail;
23312 temp2 = true;
23313 }
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23317
23318 wxPyEndAllowThreads(__tstate);
23319 if (PyErr_Occurred()) SWIG_fail;
23320 }
23321 {
23322 resultobj = SWIG_From_int((int)(result));
23323 }
23324 {
23325 if (temp2)
23326 delete arg2;
23327 }
23328 return resultobj;
23329 fail:
23330 {
23331 if (temp2)
23332 delete arg2;
23333 }
23334 return NULL;
23335 }
23336
23337
23338 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23339 PyObject *resultobj;
23340 wxDateTime *arg1 = (wxDateTime *) 0 ;
23341 wxString *arg2 = 0 ;
23342 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23343 wxString *arg3 = (wxString *) &arg3_defvalue ;
23344 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23345 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23346 int result;
23347 bool temp2 = false ;
23348 bool temp3 = false ;
23349 PyObject * obj0 = 0 ;
23350 PyObject * obj1 = 0 ;
23351 PyObject * obj2 = 0 ;
23352 PyObject * obj3 = 0 ;
23353 char *kwnames[] = {
23354 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23355 };
23356
23357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23359 if (SWIG_arg_fail(1)) SWIG_fail;
23360 {
23361 arg2 = wxString_in_helper(obj1);
23362 if (arg2 == NULL) SWIG_fail;
23363 temp2 = true;
23364 }
23365 if (obj2) {
23366 {
23367 arg3 = wxString_in_helper(obj2);
23368 if (arg3 == NULL) SWIG_fail;
23369 temp3 = true;
23370 }
23371 }
23372 if (obj3) {
23373 {
23374 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23375 if (SWIG_arg_fail(4)) SWIG_fail;
23376 if (arg4 == NULL) {
23377 SWIG_null_ref("wxDateTime");
23378 }
23379 if (SWIG_arg_fail(4)) SWIG_fail;
23380 }
23381 }
23382 {
23383 PyThreadState* __tstate = wxPyBeginAllowThreads();
23384 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23385
23386 wxPyEndAllowThreads(__tstate);
23387 if (PyErr_Occurred()) SWIG_fail;
23388 }
23389 {
23390 resultobj = SWIG_From_int((int)(result));
23391 }
23392 {
23393 if (temp2)
23394 delete arg2;
23395 }
23396 {
23397 if (temp3)
23398 delete arg3;
23399 }
23400 return resultobj;
23401 fail:
23402 {
23403 if (temp2)
23404 delete arg2;
23405 }
23406 {
23407 if (temp3)
23408 delete arg3;
23409 }
23410 return NULL;
23411 }
23412
23413
23414 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23415 PyObject *resultobj;
23416 wxDateTime *arg1 = (wxDateTime *) 0 ;
23417 wxString *arg2 = 0 ;
23418 int result;
23419 bool temp2 = false ;
23420 PyObject * obj0 = 0 ;
23421 PyObject * obj1 = 0 ;
23422 char *kwnames[] = {
23423 (char *) "self",(char *) "datetime", NULL
23424 };
23425
23426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23428 if (SWIG_arg_fail(1)) SWIG_fail;
23429 {
23430 arg2 = wxString_in_helper(obj1);
23431 if (arg2 == NULL) SWIG_fail;
23432 temp2 = true;
23433 }
23434 {
23435 PyThreadState* __tstate = wxPyBeginAllowThreads();
23436 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23437
23438 wxPyEndAllowThreads(__tstate);
23439 if (PyErr_Occurred()) SWIG_fail;
23440 }
23441 {
23442 resultobj = SWIG_From_int((int)(result));
23443 }
23444 {
23445 if (temp2)
23446 delete arg2;
23447 }
23448 return resultobj;
23449 fail:
23450 {
23451 if (temp2)
23452 delete arg2;
23453 }
23454 return NULL;
23455 }
23456
23457
23458 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23459 PyObject *resultobj;
23460 wxDateTime *arg1 = (wxDateTime *) 0 ;
23461 wxString *arg2 = 0 ;
23462 int result;
23463 bool temp2 = false ;
23464 PyObject * obj0 = 0 ;
23465 PyObject * obj1 = 0 ;
23466 char *kwnames[] = {
23467 (char *) "self",(char *) "date", NULL
23468 };
23469
23470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23472 if (SWIG_arg_fail(1)) SWIG_fail;
23473 {
23474 arg2 = wxString_in_helper(obj1);
23475 if (arg2 == NULL) SWIG_fail;
23476 temp2 = true;
23477 }
23478 {
23479 PyThreadState* __tstate = wxPyBeginAllowThreads();
23480 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23481
23482 wxPyEndAllowThreads(__tstate);
23483 if (PyErr_Occurred()) SWIG_fail;
23484 }
23485 {
23486 resultobj = SWIG_From_int((int)(result));
23487 }
23488 {
23489 if (temp2)
23490 delete arg2;
23491 }
23492 return resultobj;
23493 fail:
23494 {
23495 if (temp2)
23496 delete arg2;
23497 }
23498 return NULL;
23499 }
23500
23501
23502 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23503 PyObject *resultobj;
23504 wxDateTime *arg1 = (wxDateTime *) 0 ;
23505 wxString *arg2 = 0 ;
23506 int result;
23507 bool temp2 = false ;
23508 PyObject * obj0 = 0 ;
23509 PyObject * obj1 = 0 ;
23510 char *kwnames[] = {
23511 (char *) "self",(char *) "time", NULL
23512 };
23513
23514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23516 if (SWIG_arg_fail(1)) SWIG_fail;
23517 {
23518 arg2 = wxString_in_helper(obj1);
23519 if (arg2 == NULL) SWIG_fail;
23520 temp2 = true;
23521 }
23522 {
23523 PyThreadState* __tstate = wxPyBeginAllowThreads();
23524 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23525
23526 wxPyEndAllowThreads(__tstate);
23527 if (PyErr_Occurred()) SWIG_fail;
23528 }
23529 {
23530 resultobj = SWIG_From_int((int)(result));
23531 }
23532 {
23533 if (temp2)
23534 delete arg2;
23535 }
23536 return resultobj;
23537 fail:
23538 {
23539 if (temp2)
23540 delete arg2;
23541 }
23542 return NULL;
23543 }
23544
23545
23546 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23547 PyObject *resultobj;
23548 wxDateTime *arg1 = (wxDateTime *) 0 ;
23549 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23550 wxString *arg2 = (wxString *) &arg2_defvalue ;
23551 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23552 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23553 wxString result;
23554 bool temp2 = false ;
23555 bool temp3 = false ;
23556 PyObject * obj0 = 0 ;
23557 PyObject * obj1 = 0 ;
23558 PyObject * obj2 = 0 ;
23559 char *kwnames[] = {
23560 (char *) "self",(char *) "format",(char *) "tz", NULL
23561 };
23562
23563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23565 if (SWIG_arg_fail(1)) SWIG_fail;
23566 if (obj1) {
23567 {
23568 arg2 = wxString_in_helper(obj1);
23569 if (arg2 == NULL) SWIG_fail;
23570 temp2 = true;
23571 }
23572 }
23573 if (obj2) {
23574 {
23575 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23576 temp3 = true;
23577 }
23578 }
23579 {
23580 PyThreadState* __tstate = wxPyBeginAllowThreads();
23581 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23582
23583 wxPyEndAllowThreads(__tstate);
23584 if (PyErr_Occurred()) SWIG_fail;
23585 }
23586 {
23587 #if wxUSE_UNICODE
23588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23589 #else
23590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23591 #endif
23592 }
23593 {
23594 if (temp2)
23595 delete arg2;
23596 }
23597 {
23598 if (temp3) delete arg3;
23599 }
23600 return resultobj;
23601 fail:
23602 {
23603 if (temp2)
23604 delete arg2;
23605 }
23606 {
23607 if (temp3) delete arg3;
23608 }
23609 return NULL;
23610 }
23611
23612
23613 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23614 PyObject *resultobj;
23615 wxDateTime *arg1 = (wxDateTime *) 0 ;
23616 wxString result;
23617 PyObject * obj0 = 0 ;
23618 char *kwnames[] = {
23619 (char *) "self", NULL
23620 };
23621
23622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23624 if (SWIG_arg_fail(1)) SWIG_fail;
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 result = ((wxDateTime const *)arg1)->FormatDate();
23628
23629 wxPyEndAllowThreads(__tstate);
23630 if (PyErr_Occurred()) SWIG_fail;
23631 }
23632 {
23633 #if wxUSE_UNICODE
23634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23635 #else
23636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23637 #endif
23638 }
23639 return resultobj;
23640 fail:
23641 return NULL;
23642 }
23643
23644
23645 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23646 PyObject *resultobj;
23647 wxDateTime *arg1 = (wxDateTime *) 0 ;
23648 wxString result;
23649 PyObject * obj0 = 0 ;
23650 char *kwnames[] = {
23651 (char *) "self", NULL
23652 };
23653
23654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23656 if (SWIG_arg_fail(1)) SWIG_fail;
23657 {
23658 PyThreadState* __tstate = wxPyBeginAllowThreads();
23659 result = ((wxDateTime const *)arg1)->FormatTime();
23660
23661 wxPyEndAllowThreads(__tstate);
23662 if (PyErr_Occurred()) SWIG_fail;
23663 }
23664 {
23665 #if wxUSE_UNICODE
23666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23667 #else
23668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23669 #endif
23670 }
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23678 PyObject *resultobj;
23679 wxDateTime *arg1 = (wxDateTime *) 0 ;
23680 wxString result;
23681 PyObject * obj0 = 0 ;
23682 char *kwnames[] = {
23683 (char *) "self", NULL
23684 };
23685
23686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23688 if (SWIG_arg_fail(1)) SWIG_fail;
23689 {
23690 PyThreadState* __tstate = wxPyBeginAllowThreads();
23691 result = ((wxDateTime const *)arg1)->FormatISODate();
23692
23693 wxPyEndAllowThreads(__tstate);
23694 if (PyErr_Occurred()) SWIG_fail;
23695 }
23696 {
23697 #if wxUSE_UNICODE
23698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23699 #else
23700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23701 #endif
23702 }
23703 return resultobj;
23704 fail:
23705 return NULL;
23706 }
23707
23708
23709 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23710 PyObject *resultobj;
23711 wxDateTime *arg1 = (wxDateTime *) 0 ;
23712 wxString result;
23713 PyObject * obj0 = 0 ;
23714 char *kwnames[] = {
23715 (char *) "self", NULL
23716 };
23717
23718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23720 if (SWIG_arg_fail(1)) SWIG_fail;
23721 {
23722 PyThreadState* __tstate = wxPyBeginAllowThreads();
23723 result = ((wxDateTime const *)arg1)->FormatISOTime();
23724
23725 wxPyEndAllowThreads(__tstate);
23726 if (PyErr_Occurred()) SWIG_fail;
23727 }
23728 {
23729 #if wxUSE_UNICODE
23730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23731 #else
23732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23733 #endif
23734 }
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23742 PyObject *obj;
23743 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23744 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23745 Py_INCREF(obj);
23746 return Py_BuildValue((char *)"");
23747 }
23748 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23749 PyObject *resultobj;
23750 long arg1 ;
23751 wxTimeSpan result;
23752 PyObject * obj0 = 0 ;
23753 char *kwnames[] = {
23754 (char *) "sec", NULL
23755 };
23756
23757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23758 {
23759 arg1 = (long)(SWIG_As_long(obj0));
23760 if (SWIG_arg_fail(1)) SWIG_fail;
23761 }
23762 {
23763 PyThreadState* __tstate = wxPyBeginAllowThreads();
23764 result = wxTimeSpan::Seconds(arg1);
23765
23766 wxPyEndAllowThreads(__tstate);
23767 if (PyErr_Occurred()) SWIG_fail;
23768 }
23769 {
23770 wxTimeSpan * resultptr;
23771 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23772 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23773 }
23774 return resultobj;
23775 fail:
23776 return NULL;
23777 }
23778
23779
23780 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23781 PyObject *resultobj;
23782 wxTimeSpan result;
23783 char *kwnames[] = {
23784 NULL
23785 };
23786
23787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23788 {
23789 PyThreadState* __tstate = wxPyBeginAllowThreads();
23790 result = wxTimeSpan::Second();
23791
23792 wxPyEndAllowThreads(__tstate);
23793 if (PyErr_Occurred()) SWIG_fail;
23794 }
23795 {
23796 wxTimeSpan * resultptr;
23797 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23798 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23799 }
23800 return resultobj;
23801 fail:
23802 return NULL;
23803 }
23804
23805
23806 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23807 PyObject *resultobj;
23808 long arg1 ;
23809 wxTimeSpan result;
23810 PyObject * obj0 = 0 ;
23811 char *kwnames[] = {
23812 (char *) "min", NULL
23813 };
23814
23815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23816 {
23817 arg1 = (long)(SWIG_As_long(obj0));
23818 if (SWIG_arg_fail(1)) SWIG_fail;
23819 }
23820 {
23821 PyThreadState* __tstate = wxPyBeginAllowThreads();
23822 result = wxTimeSpan::Minutes(arg1);
23823
23824 wxPyEndAllowThreads(__tstate);
23825 if (PyErr_Occurred()) SWIG_fail;
23826 }
23827 {
23828 wxTimeSpan * resultptr;
23829 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23831 }
23832 return resultobj;
23833 fail:
23834 return NULL;
23835 }
23836
23837
23838 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23839 PyObject *resultobj;
23840 wxTimeSpan result;
23841 char *kwnames[] = {
23842 NULL
23843 };
23844
23845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23846 {
23847 PyThreadState* __tstate = wxPyBeginAllowThreads();
23848 result = wxTimeSpan::Minute();
23849
23850 wxPyEndAllowThreads(__tstate);
23851 if (PyErr_Occurred()) SWIG_fail;
23852 }
23853 {
23854 wxTimeSpan * resultptr;
23855 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23856 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23857 }
23858 return resultobj;
23859 fail:
23860 return NULL;
23861 }
23862
23863
23864 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23865 PyObject *resultobj;
23866 long arg1 ;
23867 wxTimeSpan result;
23868 PyObject * obj0 = 0 ;
23869 char *kwnames[] = {
23870 (char *) "hours", NULL
23871 };
23872
23873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23874 {
23875 arg1 = (long)(SWIG_As_long(obj0));
23876 if (SWIG_arg_fail(1)) SWIG_fail;
23877 }
23878 {
23879 PyThreadState* __tstate = wxPyBeginAllowThreads();
23880 result = wxTimeSpan::Hours(arg1);
23881
23882 wxPyEndAllowThreads(__tstate);
23883 if (PyErr_Occurred()) SWIG_fail;
23884 }
23885 {
23886 wxTimeSpan * resultptr;
23887 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23888 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23889 }
23890 return resultobj;
23891 fail:
23892 return NULL;
23893 }
23894
23895
23896 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23897 PyObject *resultobj;
23898 wxTimeSpan result;
23899 char *kwnames[] = {
23900 NULL
23901 };
23902
23903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23904 {
23905 PyThreadState* __tstate = wxPyBeginAllowThreads();
23906 result = wxTimeSpan::Hour();
23907
23908 wxPyEndAllowThreads(__tstate);
23909 if (PyErr_Occurred()) SWIG_fail;
23910 }
23911 {
23912 wxTimeSpan * resultptr;
23913 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23914 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23915 }
23916 return resultobj;
23917 fail:
23918 return NULL;
23919 }
23920
23921
23922 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23923 PyObject *resultobj;
23924 long arg1 ;
23925 wxTimeSpan result;
23926 PyObject * obj0 = 0 ;
23927 char *kwnames[] = {
23928 (char *) "days", NULL
23929 };
23930
23931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23932 {
23933 arg1 = (long)(SWIG_As_long(obj0));
23934 if (SWIG_arg_fail(1)) SWIG_fail;
23935 }
23936 {
23937 PyThreadState* __tstate = wxPyBeginAllowThreads();
23938 result = wxTimeSpan::Days(arg1);
23939
23940 wxPyEndAllowThreads(__tstate);
23941 if (PyErr_Occurred()) SWIG_fail;
23942 }
23943 {
23944 wxTimeSpan * resultptr;
23945 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23946 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23947 }
23948 return resultobj;
23949 fail:
23950 return NULL;
23951 }
23952
23953
23954 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23955 PyObject *resultobj;
23956 wxTimeSpan result;
23957 char *kwnames[] = {
23958 NULL
23959 };
23960
23961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = wxTimeSpan::Day();
23965
23966 wxPyEndAllowThreads(__tstate);
23967 if (PyErr_Occurred()) SWIG_fail;
23968 }
23969 {
23970 wxTimeSpan * resultptr;
23971 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23973 }
23974 return resultobj;
23975 fail:
23976 return NULL;
23977 }
23978
23979
23980 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23981 PyObject *resultobj;
23982 long arg1 ;
23983 wxTimeSpan result;
23984 PyObject * obj0 = 0 ;
23985 char *kwnames[] = {
23986 (char *) "days", NULL
23987 };
23988
23989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23990 {
23991 arg1 = (long)(SWIG_As_long(obj0));
23992 if (SWIG_arg_fail(1)) SWIG_fail;
23993 }
23994 {
23995 PyThreadState* __tstate = wxPyBeginAllowThreads();
23996 result = wxTimeSpan::Weeks(arg1);
23997
23998 wxPyEndAllowThreads(__tstate);
23999 if (PyErr_Occurred()) SWIG_fail;
24000 }
24001 {
24002 wxTimeSpan * resultptr;
24003 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24005 }
24006 return resultobj;
24007 fail:
24008 return NULL;
24009 }
24010
24011
24012 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24013 PyObject *resultobj;
24014 wxTimeSpan result;
24015 char *kwnames[] = {
24016 NULL
24017 };
24018
24019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24020 {
24021 PyThreadState* __tstate = wxPyBeginAllowThreads();
24022 result = wxTimeSpan::Week();
24023
24024 wxPyEndAllowThreads(__tstate);
24025 if (PyErr_Occurred()) SWIG_fail;
24026 }
24027 {
24028 wxTimeSpan * resultptr;
24029 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24031 }
24032 return resultobj;
24033 fail:
24034 return NULL;
24035 }
24036
24037
24038 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24039 PyObject *resultobj;
24040 long arg1 = (long) 0 ;
24041 long arg2 = (long) 0 ;
24042 long arg3 = (long) 0 ;
24043 long arg4 = (long) 0 ;
24044 wxTimeSpan *result;
24045 PyObject * obj0 = 0 ;
24046 PyObject * obj1 = 0 ;
24047 PyObject * obj2 = 0 ;
24048 PyObject * obj3 = 0 ;
24049 char *kwnames[] = {
24050 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24051 };
24052
24053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24054 if (obj0) {
24055 {
24056 arg1 = (long)(SWIG_As_long(obj0));
24057 if (SWIG_arg_fail(1)) SWIG_fail;
24058 }
24059 }
24060 if (obj1) {
24061 {
24062 arg2 = (long)(SWIG_As_long(obj1));
24063 if (SWIG_arg_fail(2)) SWIG_fail;
24064 }
24065 }
24066 if (obj2) {
24067 {
24068 arg3 = (long)(SWIG_As_long(obj2));
24069 if (SWIG_arg_fail(3)) SWIG_fail;
24070 }
24071 }
24072 if (obj3) {
24073 {
24074 arg4 = (long)(SWIG_As_long(obj3));
24075 if (SWIG_arg_fail(4)) SWIG_fail;
24076 }
24077 }
24078 {
24079 PyThreadState* __tstate = wxPyBeginAllowThreads();
24080 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24081
24082 wxPyEndAllowThreads(__tstate);
24083 if (PyErr_Occurred()) SWIG_fail;
24084 }
24085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24086 return resultobj;
24087 fail:
24088 return NULL;
24089 }
24090
24091
24092 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24093 PyObject *resultobj;
24094 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24095 PyObject * obj0 = 0 ;
24096 char *kwnames[] = {
24097 (char *) "self", NULL
24098 };
24099
24100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24102 if (SWIG_arg_fail(1)) SWIG_fail;
24103 {
24104 PyThreadState* __tstate = wxPyBeginAllowThreads();
24105 delete arg1;
24106
24107 wxPyEndAllowThreads(__tstate);
24108 if (PyErr_Occurred()) SWIG_fail;
24109 }
24110 Py_INCREF(Py_None); resultobj = Py_None;
24111 return resultobj;
24112 fail:
24113 return NULL;
24114 }
24115
24116
24117 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24118 PyObject *resultobj;
24119 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24120 wxTimeSpan *arg2 = 0 ;
24121 wxTimeSpan *result;
24122 PyObject * obj0 = 0 ;
24123 PyObject * obj1 = 0 ;
24124 char *kwnames[] = {
24125 (char *) "self",(char *) "diff", NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(1)) SWIG_fail;
24131 {
24132 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24133 if (SWIG_arg_fail(2)) SWIG_fail;
24134 if (arg2 == NULL) {
24135 SWIG_null_ref("wxTimeSpan");
24136 }
24137 if (SWIG_arg_fail(2)) SWIG_fail;
24138 }
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 {
24142 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24143 result = (wxTimeSpan *) &_result_ref;
24144 }
24145
24146 wxPyEndAllowThreads(__tstate);
24147 if (PyErr_Occurred()) SWIG_fail;
24148 }
24149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24157 PyObject *resultobj;
24158 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24159 wxTimeSpan *arg2 = 0 ;
24160 wxTimeSpan *result;
24161 PyObject * obj0 = 0 ;
24162 PyObject * obj1 = 0 ;
24163 char *kwnames[] = {
24164 (char *) "self",(char *) "diff", NULL
24165 };
24166
24167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24169 if (SWIG_arg_fail(1)) SWIG_fail;
24170 {
24171 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24172 if (SWIG_arg_fail(2)) SWIG_fail;
24173 if (arg2 == NULL) {
24174 SWIG_null_ref("wxTimeSpan");
24175 }
24176 if (SWIG_arg_fail(2)) SWIG_fail;
24177 }
24178 {
24179 PyThreadState* __tstate = wxPyBeginAllowThreads();
24180 {
24181 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24182 result = (wxTimeSpan *) &_result_ref;
24183 }
24184
24185 wxPyEndAllowThreads(__tstate);
24186 if (PyErr_Occurred()) SWIG_fail;
24187 }
24188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24189 return resultobj;
24190 fail:
24191 return NULL;
24192 }
24193
24194
24195 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24196 PyObject *resultobj;
24197 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24198 int arg2 ;
24199 wxTimeSpan *result;
24200 PyObject * obj0 = 0 ;
24201 PyObject * obj1 = 0 ;
24202 char *kwnames[] = {
24203 (char *) "self",(char *) "n", NULL
24204 };
24205
24206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24208 if (SWIG_arg_fail(1)) SWIG_fail;
24209 {
24210 arg2 = (int)(SWIG_As_int(obj1));
24211 if (SWIG_arg_fail(2)) SWIG_fail;
24212 }
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 {
24216 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24217 result = (wxTimeSpan *) &_result_ref;
24218 }
24219
24220 wxPyEndAllowThreads(__tstate);
24221 if (PyErr_Occurred()) SWIG_fail;
24222 }
24223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24224 return resultobj;
24225 fail:
24226 return NULL;
24227 }
24228
24229
24230 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24231 PyObject *resultobj;
24232 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24233 wxTimeSpan *result;
24234 PyObject * obj0 = 0 ;
24235 char *kwnames[] = {
24236 (char *) "self", NULL
24237 };
24238
24239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24241 if (SWIG_arg_fail(1)) SWIG_fail;
24242 {
24243 PyThreadState* __tstate = wxPyBeginAllowThreads();
24244 {
24245 wxTimeSpan &_result_ref = (arg1)->Neg();
24246 result = (wxTimeSpan *) &_result_ref;
24247 }
24248
24249 wxPyEndAllowThreads(__tstate);
24250 if (PyErr_Occurred()) SWIG_fail;
24251 }
24252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24253 return resultobj;
24254 fail:
24255 return NULL;
24256 }
24257
24258
24259 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24260 PyObject *resultobj;
24261 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24262 wxTimeSpan result;
24263 PyObject * obj0 = 0 ;
24264 char *kwnames[] = {
24265 (char *) "self", NULL
24266 };
24267
24268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24270 if (SWIG_arg_fail(1)) SWIG_fail;
24271 {
24272 PyThreadState* __tstate = wxPyBeginAllowThreads();
24273 result = ((wxTimeSpan const *)arg1)->Abs();
24274
24275 wxPyEndAllowThreads(__tstate);
24276 if (PyErr_Occurred()) SWIG_fail;
24277 }
24278 {
24279 wxTimeSpan * resultptr;
24280 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24281 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24282 }
24283 return resultobj;
24284 fail:
24285 return NULL;
24286 }
24287
24288
24289 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24290 PyObject *resultobj;
24291 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24292 wxTimeSpan *arg2 = 0 ;
24293 wxTimeSpan *result;
24294 PyObject * obj0 = 0 ;
24295 PyObject * obj1 = 0 ;
24296 char *kwnames[] = {
24297 (char *) "self",(char *) "diff", NULL
24298 };
24299
24300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24302 if (SWIG_arg_fail(1)) SWIG_fail;
24303 {
24304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24305 if (SWIG_arg_fail(2)) SWIG_fail;
24306 if (arg2 == NULL) {
24307 SWIG_null_ref("wxTimeSpan");
24308 }
24309 if (SWIG_arg_fail(2)) SWIG_fail;
24310 }
24311 {
24312 PyThreadState* __tstate = wxPyBeginAllowThreads();
24313 {
24314 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24315 result = (wxTimeSpan *) &_result_ref;
24316 }
24317
24318 wxPyEndAllowThreads(__tstate);
24319 if (PyErr_Occurred()) SWIG_fail;
24320 }
24321 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24322 return resultobj;
24323 fail:
24324 return NULL;
24325 }
24326
24327
24328 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24329 PyObject *resultobj;
24330 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24331 wxTimeSpan *arg2 = 0 ;
24332 wxTimeSpan *result;
24333 PyObject * obj0 = 0 ;
24334 PyObject * obj1 = 0 ;
24335 char *kwnames[] = {
24336 (char *) "self",(char *) "diff", NULL
24337 };
24338
24339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24341 if (SWIG_arg_fail(1)) SWIG_fail;
24342 {
24343 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24344 if (SWIG_arg_fail(2)) SWIG_fail;
24345 if (arg2 == NULL) {
24346 SWIG_null_ref("wxTimeSpan");
24347 }
24348 if (SWIG_arg_fail(2)) SWIG_fail;
24349 }
24350 {
24351 PyThreadState* __tstate = wxPyBeginAllowThreads();
24352 {
24353 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24354 result = (wxTimeSpan *) &_result_ref;
24355 }
24356
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24361 return resultobj;
24362 fail:
24363 return NULL;
24364 }
24365
24366
24367 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24368 PyObject *resultobj;
24369 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24370 int arg2 ;
24371 wxTimeSpan *result;
24372 PyObject * obj0 = 0 ;
24373 PyObject * obj1 = 0 ;
24374 char *kwnames[] = {
24375 (char *) "self",(char *) "n", NULL
24376 };
24377
24378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24380 if (SWIG_arg_fail(1)) SWIG_fail;
24381 {
24382 arg2 = (int)(SWIG_As_int(obj1));
24383 if (SWIG_arg_fail(2)) SWIG_fail;
24384 }
24385 {
24386 PyThreadState* __tstate = wxPyBeginAllowThreads();
24387 {
24388 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24389 result = (wxTimeSpan *) &_result_ref;
24390 }
24391
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24403 PyObject *resultobj;
24404 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24405 wxTimeSpan *result;
24406 PyObject * obj0 = 0 ;
24407 char *kwnames[] = {
24408 (char *) "self", NULL
24409 };
24410
24411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24413 if (SWIG_arg_fail(1)) SWIG_fail;
24414 {
24415 PyThreadState* __tstate = wxPyBeginAllowThreads();
24416 {
24417 wxTimeSpan &_result_ref = (arg1)->operator -();
24418 result = (wxTimeSpan *) &_result_ref;
24419 }
24420
24421 wxPyEndAllowThreads(__tstate);
24422 if (PyErr_Occurred()) SWIG_fail;
24423 }
24424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24425 return resultobj;
24426 fail:
24427 return NULL;
24428 }
24429
24430
24431 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24432 PyObject *resultobj;
24433 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24434 wxTimeSpan *arg2 = 0 ;
24435 wxTimeSpan result;
24436 PyObject * obj0 = 0 ;
24437 PyObject * obj1 = 0 ;
24438 char *kwnames[] = {
24439 (char *) "self",(char *) "other", NULL
24440 };
24441
24442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24444 if (SWIG_arg_fail(1)) SWIG_fail;
24445 {
24446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24447 if (SWIG_arg_fail(2)) SWIG_fail;
24448 if (arg2 == NULL) {
24449 SWIG_null_ref("wxTimeSpan");
24450 }
24451 if (SWIG_arg_fail(2)) SWIG_fail;
24452 }
24453 {
24454 PyThreadState* __tstate = wxPyBeginAllowThreads();
24455 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24456
24457 wxPyEndAllowThreads(__tstate);
24458 if (PyErr_Occurred()) SWIG_fail;
24459 }
24460 {
24461 wxTimeSpan * resultptr;
24462 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24463 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24464 }
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24472 PyObject *resultobj;
24473 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24474 wxTimeSpan *arg2 = 0 ;
24475 wxTimeSpan result;
24476 PyObject * obj0 = 0 ;
24477 PyObject * obj1 = 0 ;
24478 char *kwnames[] = {
24479 (char *) "self",(char *) "other", NULL
24480 };
24481
24482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24484 if (SWIG_arg_fail(1)) SWIG_fail;
24485 {
24486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24487 if (SWIG_arg_fail(2)) SWIG_fail;
24488 if (arg2 == NULL) {
24489 SWIG_null_ref("wxTimeSpan");
24490 }
24491 if (SWIG_arg_fail(2)) SWIG_fail;
24492 }
24493 {
24494 PyThreadState* __tstate = wxPyBeginAllowThreads();
24495 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24496
24497 wxPyEndAllowThreads(__tstate);
24498 if (PyErr_Occurred()) SWIG_fail;
24499 }
24500 {
24501 wxTimeSpan * resultptr;
24502 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24504 }
24505 return resultobj;
24506 fail:
24507 return NULL;
24508 }
24509
24510
24511 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24512 PyObject *resultobj;
24513 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24514 int arg2 ;
24515 wxTimeSpan result;
24516 PyObject * obj0 = 0 ;
24517 PyObject * obj1 = 0 ;
24518 char *kwnames[] = {
24519 (char *) "self",(char *) "n", NULL
24520 };
24521
24522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24524 if (SWIG_arg_fail(1)) SWIG_fail;
24525 {
24526 arg2 = (int)(SWIG_As_int(obj1));
24527 if (SWIG_arg_fail(2)) SWIG_fail;
24528 }
24529 {
24530 PyThreadState* __tstate = wxPyBeginAllowThreads();
24531 result = wxTimeSpan___mul__(arg1,arg2);
24532
24533 wxPyEndAllowThreads(__tstate);
24534 if (PyErr_Occurred()) SWIG_fail;
24535 }
24536 {
24537 wxTimeSpan * resultptr;
24538 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24540 }
24541 return resultobj;
24542 fail:
24543 return NULL;
24544 }
24545
24546
24547 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24548 PyObject *resultobj;
24549 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24550 int arg2 ;
24551 wxTimeSpan result;
24552 PyObject * obj0 = 0 ;
24553 PyObject * obj1 = 0 ;
24554 char *kwnames[] = {
24555 (char *) "self",(char *) "n", NULL
24556 };
24557
24558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24560 if (SWIG_arg_fail(1)) SWIG_fail;
24561 {
24562 arg2 = (int)(SWIG_As_int(obj1));
24563 if (SWIG_arg_fail(2)) SWIG_fail;
24564 }
24565 {
24566 PyThreadState* __tstate = wxPyBeginAllowThreads();
24567 result = wxTimeSpan___rmul__(arg1,arg2);
24568
24569 wxPyEndAllowThreads(__tstate);
24570 if (PyErr_Occurred()) SWIG_fail;
24571 }
24572 {
24573 wxTimeSpan * resultptr;
24574 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24576 }
24577 return resultobj;
24578 fail:
24579 return NULL;
24580 }
24581
24582
24583 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24584 PyObject *resultobj;
24585 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24586 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24587 bool result;
24588 PyObject * obj0 = 0 ;
24589 PyObject * obj1 = 0 ;
24590 char *kwnames[] = {
24591 (char *) "self",(char *) "other", NULL
24592 };
24593
24594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24596 if (SWIG_arg_fail(1)) SWIG_fail;
24597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24598 if (SWIG_arg_fail(2)) SWIG_fail;
24599 {
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24602
24603 wxPyEndAllowThreads(__tstate);
24604 if (PyErr_Occurred()) SWIG_fail;
24605 }
24606 {
24607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24608 }
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj;
24617 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24618 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24619 bool result;
24620 PyObject * obj0 = 0 ;
24621 PyObject * obj1 = 0 ;
24622 char *kwnames[] = {
24623 (char *) "self",(char *) "other", NULL
24624 };
24625
24626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24628 if (SWIG_arg_fail(1)) SWIG_fail;
24629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24630 if (SWIG_arg_fail(2)) SWIG_fail;
24631 {
24632 PyThreadState* __tstate = wxPyBeginAllowThreads();
24633 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24634
24635 wxPyEndAllowThreads(__tstate);
24636 if (PyErr_Occurred()) SWIG_fail;
24637 }
24638 {
24639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24640 }
24641 return resultobj;
24642 fail:
24643 return NULL;
24644 }
24645
24646
24647 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24648 PyObject *resultobj;
24649 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24650 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24651 bool result;
24652 PyObject * obj0 = 0 ;
24653 PyObject * obj1 = 0 ;
24654 char *kwnames[] = {
24655 (char *) "self",(char *) "other", NULL
24656 };
24657
24658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24660 if (SWIG_arg_fail(1)) SWIG_fail;
24661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24662 if (SWIG_arg_fail(2)) SWIG_fail;
24663 {
24664 PyThreadState* __tstate = wxPyBeginAllowThreads();
24665 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24666
24667 wxPyEndAllowThreads(__tstate);
24668 if (PyErr_Occurred()) SWIG_fail;
24669 }
24670 {
24671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24672 }
24673 return resultobj;
24674 fail:
24675 return NULL;
24676 }
24677
24678
24679 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24680 PyObject *resultobj;
24681 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24682 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24683 bool result;
24684 PyObject * obj0 = 0 ;
24685 PyObject * obj1 = 0 ;
24686 char *kwnames[] = {
24687 (char *) "self",(char *) "other", NULL
24688 };
24689
24690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24692 if (SWIG_arg_fail(1)) SWIG_fail;
24693 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24694 if (SWIG_arg_fail(2)) SWIG_fail;
24695 {
24696 PyThreadState* __tstate = wxPyBeginAllowThreads();
24697 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24698
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 {
24703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24704 }
24705 return resultobj;
24706 fail:
24707 return NULL;
24708 }
24709
24710
24711 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24712 PyObject *resultobj;
24713 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24714 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24715 bool result;
24716 PyObject * obj0 = 0 ;
24717 PyObject * obj1 = 0 ;
24718 char *kwnames[] = {
24719 (char *) "self",(char *) "other", NULL
24720 };
24721
24722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24724 if (SWIG_arg_fail(1)) SWIG_fail;
24725 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24726 if (SWIG_arg_fail(2)) SWIG_fail;
24727 {
24728 PyThreadState* __tstate = wxPyBeginAllowThreads();
24729 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24730
24731 wxPyEndAllowThreads(__tstate);
24732 if (PyErr_Occurred()) SWIG_fail;
24733 }
24734 {
24735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24736 }
24737 return resultobj;
24738 fail:
24739 return NULL;
24740 }
24741
24742
24743 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24744 PyObject *resultobj;
24745 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24746 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24747 bool result;
24748 PyObject * obj0 = 0 ;
24749 PyObject * obj1 = 0 ;
24750 char *kwnames[] = {
24751 (char *) "self",(char *) "other", NULL
24752 };
24753
24754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24756 if (SWIG_arg_fail(1)) SWIG_fail;
24757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24758 if (SWIG_arg_fail(2)) SWIG_fail;
24759 {
24760 PyThreadState* __tstate = wxPyBeginAllowThreads();
24761 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24762
24763 wxPyEndAllowThreads(__tstate);
24764 if (PyErr_Occurred()) SWIG_fail;
24765 }
24766 {
24767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24768 }
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj;
24777 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24778 bool result;
24779 PyObject * obj0 = 0 ;
24780 char *kwnames[] = {
24781 (char *) "self", NULL
24782 };
24783
24784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24786 if (SWIG_arg_fail(1)) SWIG_fail;
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24796 }
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24804 PyObject *resultobj;
24805 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24806 bool result;
24807 PyObject * obj0 = 0 ;
24808 char *kwnames[] = {
24809 (char *) "self", NULL
24810 };
24811
24812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24814 if (SWIG_arg_fail(1)) SWIG_fail;
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24818
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 {
24823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24824 }
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj;
24833 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24834 bool result;
24835 PyObject * obj0 = 0 ;
24836 char *kwnames[] = {
24837 (char *) "self", NULL
24838 };
24839
24840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24842 if (SWIG_arg_fail(1)) SWIG_fail;
24843 {
24844 PyThreadState* __tstate = wxPyBeginAllowThreads();
24845 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24846
24847 wxPyEndAllowThreads(__tstate);
24848 if (PyErr_Occurred()) SWIG_fail;
24849 }
24850 {
24851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24852 }
24853 return resultobj;
24854 fail:
24855 return NULL;
24856 }
24857
24858
24859 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24860 PyObject *resultobj;
24861 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24862 wxTimeSpan *arg2 = 0 ;
24863 bool result;
24864 PyObject * obj0 = 0 ;
24865 PyObject * obj1 = 0 ;
24866 char *kwnames[] = {
24867 (char *) "self",(char *) "ts", NULL
24868 };
24869
24870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24872 if (SWIG_arg_fail(1)) SWIG_fail;
24873 {
24874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24875 if (SWIG_arg_fail(2)) SWIG_fail;
24876 if (arg2 == NULL) {
24877 SWIG_null_ref("wxTimeSpan");
24878 }
24879 if (SWIG_arg_fail(2)) SWIG_fail;
24880 }
24881 {
24882 PyThreadState* __tstate = wxPyBeginAllowThreads();
24883 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24884
24885 wxPyEndAllowThreads(__tstate);
24886 if (PyErr_Occurred()) SWIG_fail;
24887 }
24888 {
24889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24890 }
24891 return resultobj;
24892 fail:
24893 return NULL;
24894 }
24895
24896
24897 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24898 PyObject *resultobj;
24899 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24900 wxTimeSpan *arg2 = 0 ;
24901 bool result;
24902 PyObject * obj0 = 0 ;
24903 PyObject * obj1 = 0 ;
24904 char *kwnames[] = {
24905 (char *) "self",(char *) "ts", NULL
24906 };
24907
24908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24910 if (SWIG_arg_fail(1)) SWIG_fail;
24911 {
24912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24913 if (SWIG_arg_fail(2)) SWIG_fail;
24914 if (arg2 == NULL) {
24915 SWIG_null_ref("wxTimeSpan");
24916 }
24917 if (SWIG_arg_fail(2)) SWIG_fail;
24918 }
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24922
24923 wxPyEndAllowThreads(__tstate);
24924 if (PyErr_Occurred()) SWIG_fail;
24925 }
24926 {
24927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24928 }
24929 return resultobj;
24930 fail:
24931 return NULL;
24932 }
24933
24934
24935 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24936 PyObject *resultobj;
24937 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24938 wxTimeSpan *arg2 = 0 ;
24939 bool result;
24940 PyObject * obj0 = 0 ;
24941 PyObject * obj1 = 0 ;
24942 char *kwnames[] = {
24943 (char *) "self",(char *) "t", NULL
24944 };
24945
24946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24948 if (SWIG_arg_fail(1)) SWIG_fail;
24949 {
24950 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24951 if (SWIG_arg_fail(2)) SWIG_fail;
24952 if (arg2 == NULL) {
24953 SWIG_null_ref("wxTimeSpan");
24954 }
24955 if (SWIG_arg_fail(2)) SWIG_fail;
24956 }
24957 {
24958 PyThreadState* __tstate = wxPyBeginAllowThreads();
24959 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24960
24961 wxPyEndAllowThreads(__tstate);
24962 if (PyErr_Occurred()) SWIG_fail;
24963 }
24964 {
24965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24966 }
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24974 PyObject *resultobj;
24975 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24976 int result;
24977 PyObject * obj0 = 0 ;
24978 char *kwnames[] = {
24979 (char *) "self", NULL
24980 };
24981
24982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24984 if (SWIG_arg_fail(1)) SWIG_fail;
24985 {
24986 PyThreadState* __tstate = wxPyBeginAllowThreads();
24987 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24988
24989 wxPyEndAllowThreads(__tstate);
24990 if (PyErr_Occurred()) SWIG_fail;
24991 }
24992 {
24993 resultobj = SWIG_From_int((int)(result));
24994 }
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25002 PyObject *resultobj;
25003 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25004 int result;
25005 PyObject * obj0 = 0 ;
25006 char *kwnames[] = {
25007 (char *) "self", NULL
25008 };
25009
25010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25012 if (SWIG_arg_fail(1)) SWIG_fail;
25013 {
25014 PyThreadState* __tstate = wxPyBeginAllowThreads();
25015 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25016
25017 wxPyEndAllowThreads(__tstate);
25018 if (PyErr_Occurred()) SWIG_fail;
25019 }
25020 {
25021 resultobj = SWIG_From_int((int)(result));
25022 }
25023 return resultobj;
25024 fail:
25025 return NULL;
25026 }
25027
25028
25029 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25030 PyObject *resultobj;
25031 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25032 int result;
25033 PyObject * obj0 = 0 ;
25034 char *kwnames[] = {
25035 (char *) "self", NULL
25036 };
25037
25038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25040 if (SWIG_arg_fail(1)) SWIG_fail;
25041 {
25042 PyThreadState* __tstate = wxPyBeginAllowThreads();
25043 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25044
25045 wxPyEndAllowThreads(__tstate);
25046 if (PyErr_Occurred()) SWIG_fail;
25047 }
25048 {
25049 resultobj = SWIG_From_int((int)(result));
25050 }
25051 return resultobj;
25052 fail:
25053 return NULL;
25054 }
25055
25056
25057 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25058 PyObject *resultobj;
25059 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25060 int result;
25061 PyObject * obj0 = 0 ;
25062 char *kwnames[] = {
25063 (char *) "self", NULL
25064 };
25065
25066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25068 if (SWIG_arg_fail(1)) SWIG_fail;
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25072
25073 wxPyEndAllowThreads(__tstate);
25074 if (PyErr_Occurred()) SWIG_fail;
25075 }
25076 {
25077 resultobj = SWIG_From_int((int)(result));
25078 }
25079 return resultobj;
25080 fail:
25081 return NULL;
25082 }
25083
25084
25085 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25086 PyObject *resultobj;
25087 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25088 wxLongLong result;
25089 PyObject * obj0 = 0 ;
25090 char *kwnames[] = {
25091 (char *) "self", NULL
25092 };
25093
25094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25096 if (SWIG_arg_fail(1)) SWIG_fail;
25097 {
25098 PyThreadState* __tstate = wxPyBeginAllowThreads();
25099 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25100
25101 wxPyEndAllowThreads(__tstate);
25102 if (PyErr_Occurred()) SWIG_fail;
25103 }
25104 {
25105 PyObject *hi, *lo, *shifter, *shifted;
25106 hi = PyLong_FromLong( (&result)->GetHi() );
25107 lo = PyLong_FromLong( (&result)->GetLo() );
25108 shifter = PyLong_FromLong(32);
25109 shifted = PyNumber_Lshift(hi, shifter);
25110 resultobj = PyNumber_Or(shifted, lo);
25111 Py_DECREF(hi);
25112 Py_DECREF(lo);
25113 Py_DECREF(shifter);
25114 Py_DECREF(shifted);
25115 }
25116 return resultobj;
25117 fail:
25118 return NULL;
25119 }
25120
25121
25122 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25123 PyObject *resultobj;
25124 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25125 wxLongLong result;
25126 PyObject * obj0 = 0 ;
25127 char *kwnames[] = {
25128 (char *) "self", NULL
25129 };
25130
25131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) 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 {
25135 PyThreadState* __tstate = wxPyBeginAllowThreads();
25136 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25137
25138 wxPyEndAllowThreads(__tstate);
25139 if (PyErr_Occurred()) SWIG_fail;
25140 }
25141 {
25142 PyObject *hi, *lo, *shifter, *shifted;
25143 hi = PyLong_FromLong( (&result)->GetHi() );
25144 lo = PyLong_FromLong( (&result)->GetLo() );
25145 shifter = PyLong_FromLong(32);
25146 shifted = PyNumber_Lshift(hi, shifter);
25147 resultobj = PyNumber_Or(shifted, lo);
25148 Py_DECREF(hi);
25149 Py_DECREF(lo);
25150 Py_DECREF(shifter);
25151 Py_DECREF(shifted);
25152 }
25153 return resultobj;
25154 fail:
25155 return NULL;
25156 }
25157
25158
25159 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25160 PyObject *resultobj;
25161 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25162 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25163 wxString *arg2 = (wxString *) &arg2_defvalue ;
25164 wxString result;
25165 bool temp2 = false ;
25166 PyObject * obj0 = 0 ;
25167 PyObject * obj1 = 0 ;
25168 char *kwnames[] = {
25169 (char *) "self",(char *) "format", NULL
25170 };
25171
25172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25174 if (SWIG_arg_fail(1)) SWIG_fail;
25175 if (obj1) {
25176 {
25177 arg2 = wxString_in_helper(obj1);
25178 if (arg2 == NULL) SWIG_fail;
25179 temp2 = true;
25180 }
25181 }
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25185
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 {
25190 #if wxUSE_UNICODE
25191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25192 #else
25193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25194 #endif
25195 }
25196 {
25197 if (temp2)
25198 delete arg2;
25199 }
25200 return resultobj;
25201 fail:
25202 {
25203 if (temp2)
25204 delete arg2;
25205 }
25206 return NULL;
25207 }
25208
25209
25210 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25211 PyObject *obj;
25212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25213 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25214 Py_INCREF(obj);
25215 return Py_BuildValue((char *)"");
25216 }
25217 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25218 PyObject *resultobj;
25219 int arg1 = (int) 0 ;
25220 int arg2 = (int) 0 ;
25221 int arg3 = (int) 0 ;
25222 int arg4 = (int) 0 ;
25223 wxDateSpan *result;
25224 PyObject * obj0 = 0 ;
25225 PyObject * obj1 = 0 ;
25226 PyObject * obj2 = 0 ;
25227 PyObject * obj3 = 0 ;
25228 char *kwnames[] = {
25229 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25230 };
25231
25232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25233 if (obj0) {
25234 {
25235 arg1 = (int)(SWIG_As_int(obj0));
25236 if (SWIG_arg_fail(1)) SWIG_fail;
25237 }
25238 }
25239 if (obj1) {
25240 {
25241 arg2 = (int)(SWIG_As_int(obj1));
25242 if (SWIG_arg_fail(2)) SWIG_fail;
25243 }
25244 }
25245 if (obj2) {
25246 {
25247 arg3 = (int)(SWIG_As_int(obj2));
25248 if (SWIG_arg_fail(3)) SWIG_fail;
25249 }
25250 }
25251 if (obj3) {
25252 {
25253 arg4 = (int)(SWIG_As_int(obj3));
25254 if (SWIG_arg_fail(4)) SWIG_fail;
25255 }
25256 }
25257 {
25258 PyThreadState* __tstate = wxPyBeginAllowThreads();
25259 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25260
25261 wxPyEndAllowThreads(__tstate);
25262 if (PyErr_Occurred()) SWIG_fail;
25263 }
25264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25265 return resultobj;
25266 fail:
25267 return NULL;
25268 }
25269
25270
25271 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25272 PyObject *resultobj;
25273 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25274 PyObject * obj0 = 0 ;
25275 char *kwnames[] = {
25276 (char *) "self", NULL
25277 };
25278
25279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25281 if (SWIG_arg_fail(1)) SWIG_fail;
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 delete arg1;
25285
25286 wxPyEndAllowThreads(__tstate);
25287 if (PyErr_Occurred()) SWIG_fail;
25288 }
25289 Py_INCREF(Py_None); resultobj = Py_None;
25290 return resultobj;
25291 fail:
25292 return NULL;
25293 }
25294
25295
25296 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25297 PyObject *resultobj;
25298 int arg1 ;
25299 wxDateSpan result;
25300 PyObject * obj0 = 0 ;
25301 char *kwnames[] = {
25302 (char *) "days", NULL
25303 };
25304
25305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25306 {
25307 arg1 = (int)(SWIG_As_int(obj0));
25308 if (SWIG_arg_fail(1)) SWIG_fail;
25309 }
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = wxDateSpan::Days(arg1);
25313
25314 wxPyEndAllowThreads(__tstate);
25315 if (PyErr_Occurred()) SWIG_fail;
25316 }
25317 {
25318 wxDateSpan * resultptr;
25319 resultptr = new wxDateSpan((wxDateSpan &)(result));
25320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25321 }
25322 return resultobj;
25323 fail:
25324 return NULL;
25325 }
25326
25327
25328 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25329 PyObject *resultobj;
25330 wxDateSpan result;
25331 char *kwnames[] = {
25332 NULL
25333 };
25334
25335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25336 {
25337 PyThreadState* __tstate = wxPyBeginAllowThreads();
25338 result = wxDateSpan::Day();
25339
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 {
25344 wxDateSpan * resultptr;
25345 resultptr = new wxDateSpan((wxDateSpan &)(result));
25346 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25347 }
25348 return resultobj;
25349 fail:
25350 return NULL;
25351 }
25352
25353
25354 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25355 PyObject *resultobj;
25356 int arg1 ;
25357 wxDateSpan result;
25358 PyObject * obj0 = 0 ;
25359 char *kwnames[] = {
25360 (char *) "weeks", NULL
25361 };
25362
25363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25364 {
25365 arg1 = (int)(SWIG_As_int(obj0));
25366 if (SWIG_arg_fail(1)) SWIG_fail;
25367 }
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 result = wxDateSpan::Weeks(arg1);
25371
25372 wxPyEndAllowThreads(__tstate);
25373 if (PyErr_Occurred()) SWIG_fail;
25374 }
25375 {
25376 wxDateSpan * resultptr;
25377 resultptr = new wxDateSpan((wxDateSpan &)(result));
25378 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25379 }
25380 return resultobj;
25381 fail:
25382 return NULL;
25383 }
25384
25385
25386 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25387 PyObject *resultobj;
25388 wxDateSpan result;
25389 char *kwnames[] = {
25390 NULL
25391 };
25392
25393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25394 {
25395 PyThreadState* __tstate = wxPyBeginAllowThreads();
25396 result = wxDateSpan::Week();
25397
25398 wxPyEndAllowThreads(__tstate);
25399 if (PyErr_Occurred()) SWIG_fail;
25400 }
25401 {
25402 wxDateSpan * resultptr;
25403 resultptr = new wxDateSpan((wxDateSpan &)(result));
25404 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25405 }
25406 return resultobj;
25407 fail:
25408 return NULL;
25409 }
25410
25411
25412 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25413 PyObject *resultobj;
25414 int arg1 ;
25415 wxDateSpan result;
25416 PyObject * obj0 = 0 ;
25417 char *kwnames[] = {
25418 (char *) "mon", NULL
25419 };
25420
25421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25422 {
25423 arg1 = (int)(SWIG_As_int(obj0));
25424 if (SWIG_arg_fail(1)) SWIG_fail;
25425 }
25426 {
25427 PyThreadState* __tstate = wxPyBeginAllowThreads();
25428 result = wxDateSpan::Months(arg1);
25429
25430 wxPyEndAllowThreads(__tstate);
25431 if (PyErr_Occurred()) SWIG_fail;
25432 }
25433 {
25434 wxDateSpan * resultptr;
25435 resultptr = new wxDateSpan((wxDateSpan &)(result));
25436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25437 }
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25445 PyObject *resultobj;
25446 wxDateSpan result;
25447 char *kwnames[] = {
25448 NULL
25449 };
25450
25451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25452 {
25453 PyThreadState* __tstate = wxPyBeginAllowThreads();
25454 result = wxDateSpan::Month();
25455
25456 wxPyEndAllowThreads(__tstate);
25457 if (PyErr_Occurred()) SWIG_fail;
25458 }
25459 {
25460 wxDateSpan * resultptr;
25461 resultptr = new wxDateSpan((wxDateSpan &)(result));
25462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25463 }
25464 return resultobj;
25465 fail:
25466 return NULL;
25467 }
25468
25469
25470 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25471 PyObject *resultobj;
25472 int arg1 ;
25473 wxDateSpan result;
25474 PyObject * obj0 = 0 ;
25475 char *kwnames[] = {
25476 (char *) "years", NULL
25477 };
25478
25479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25480 {
25481 arg1 = (int)(SWIG_As_int(obj0));
25482 if (SWIG_arg_fail(1)) SWIG_fail;
25483 }
25484 {
25485 PyThreadState* __tstate = wxPyBeginAllowThreads();
25486 result = wxDateSpan::Years(arg1);
25487
25488 wxPyEndAllowThreads(__tstate);
25489 if (PyErr_Occurred()) SWIG_fail;
25490 }
25491 {
25492 wxDateSpan * resultptr;
25493 resultptr = new wxDateSpan((wxDateSpan &)(result));
25494 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25495 }
25496 return resultobj;
25497 fail:
25498 return NULL;
25499 }
25500
25501
25502 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25503 PyObject *resultobj;
25504 wxDateSpan result;
25505 char *kwnames[] = {
25506 NULL
25507 };
25508
25509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25510 {
25511 PyThreadState* __tstate = wxPyBeginAllowThreads();
25512 result = wxDateSpan::Year();
25513
25514 wxPyEndAllowThreads(__tstate);
25515 if (PyErr_Occurred()) SWIG_fail;
25516 }
25517 {
25518 wxDateSpan * resultptr;
25519 resultptr = new wxDateSpan((wxDateSpan &)(result));
25520 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25521 }
25522 return resultobj;
25523 fail:
25524 return NULL;
25525 }
25526
25527
25528 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25529 PyObject *resultobj;
25530 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25531 int arg2 ;
25532 wxDateSpan *result;
25533 PyObject * obj0 = 0 ;
25534 PyObject * obj1 = 0 ;
25535 char *kwnames[] = {
25536 (char *) "self",(char *) "n", NULL
25537 };
25538
25539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25541 if (SWIG_arg_fail(1)) SWIG_fail;
25542 {
25543 arg2 = (int)(SWIG_As_int(obj1));
25544 if (SWIG_arg_fail(2)) SWIG_fail;
25545 }
25546 {
25547 PyThreadState* __tstate = wxPyBeginAllowThreads();
25548 {
25549 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25550 result = (wxDateSpan *) &_result_ref;
25551 }
25552
25553 wxPyEndAllowThreads(__tstate);
25554 if (PyErr_Occurred()) SWIG_fail;
25555 }
25556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25557 return resultobj;
25558 fail:
25559 return NULL;
25560 }
25561
25562
25563 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25564 PyObject *resultobj;
25565 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25566 int arg2 ;
25567 wxDateSpan *result;
25568 PyObject * obj0 = 0 ;
25569 PyObject * obj1 = 0 ;
25570 char *kwnames[] = {
25571 (char *) "self",(char *) "n", NULL
25572 };
25573
25574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25576 if (SWIG_arg_fail(1)) SWIG_fail;
25577 {
25578 arg2 = (int)(SWIG_As_int(obj1));
25579 if (SWIG_arg_fail(2)) SWIG_fail;
25580 }
25581 {
25582 PyThreadState* __tstate = wxPyBeginAllowThreads();
25583 {
25584 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25585 result = (wxDateSpan *) &_result_ref;
25586 }
25587
25588 wxPyEndAllowThreads(__tstate);
25589 if (PyErr_Occurred()) SWIG_fail;
25590 }
25591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25592 return resultobj;
25593 fail:
25594 return NULL;
25595 }
25596
25597
25598 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25599 PyObject *resultobj;
25600 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25601 int arg2 ;
25602 wxDateSpan *result;
25603 PyObject * obj0 = 0 ;
25604 PyObject * obj1 = 0 ;
25605 char *kwnames[] = {
25606 (char *) "self",(char *) "n", NULL
25607 };
25608
25609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25611 if (SWIG_arg_fail(1)) SWIG_fail;
25612 {
25613 arg2 = (int)(SWIG_As_int(obj1));
25614 if (SWIG_arg_fail(2)) SWIG_fail;
25615 }
25616 {
25617 PyThreadState* __tstate = wxPyBeginAllowThreads();
25618 {
25619 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25620 result = (wxDateSpan *) &_result_ref;
25621 }
25622
25623 wxPyEndAllowThreads(__tstate);
25624 if (PyErr_Occurred()) SWIG_fail;
25625 }
25626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25627 return resultobj;
25628 fail:
25629 return NULL;
25630 }
25631
25632
25633 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25634 PyObject *resultobj;
25635 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25636 int arg2 ;
25637 wxDateSpan *result;
25638 PyObject * obj0 = 0 ;
25639 PyObject * obj1 = 0 ;
25640 char *kwnames[] = {
25641 (char *) "self",(char *) "n", NULL
25642 };
25643
25644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25646 if (SWIG_arg_fail(1)) SWIG_fail;
25647 {
25648 arg2 = (int)(SWIG_As_int(obj1));
25649 if (SWIG_arg_fail(2)) SWIG_fail;
25650 }
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 {
25654 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25655 result = (wxDateSpan *) &_result_ref;
25656 }
25657
25658 wxPyEndAllowThreads(__tstate);
25659 if (PyErr_Occurred()) SWIG_fail;
25660 }
25661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25662 return resultobj;
25663 fail:
25664 return NULL;
25665 }
25666
25667
25668 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25669 PyObject *resultobj;
25670 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25671 int result;
25672 PyObject * obj0 = 0 ;
25673 char *kwnames[] = {
25674 (char *) "self", NULL
25675 };
25676
25677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25679 if (SWIG_arg_fail(1)) SWIG_fail;
25680 {
25681 PyThreadState* __tstate = wxPyBeginAllowThreads();
25682 result = (int)((wxDateSpan const *)arg1)->GetYears();
25683
25684 wxPyEndAllowThreads(__tstate);
25685 if (PyErr_Occurred()) SWIG_fail;
25686 }
25687 {
25688 resultobj = SWIG_From_int((int)(result));
25689 }
25690 return resultobj;
25691 fail:
25692 return NULL;
25693 }
25694
25695
25696 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25697 PyObject *resultobj;
25698 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25699 int result;
25700 PyObject * obj0 = 0 ;
25701 char *kwnames[] = {
25702 (char *) "self", NULL
25703 };
25704
25705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25707 if (SWIG_arg_fail(1)) SWIG_fail;
25708 {
25709 PyThreadState* __tstate = wxPyBeginAllowThreads();
25710 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25711
25712 wxPyEndAllowThreads(__tstate);
25713 if (PyErr_Occurred()) SWIG_fail;
25714 }
25715 {
25716 resultobj = SWIG_From_int((int)(result));
25717 }
25718 return resultobj;
25719 fail:
25720 return NULL;
25721 }
25722
25723
25724 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25725 PyObject *resultobj;
25726 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25727 int result;
25728 PyObject * obj0 = 0 ;
25729 char *kwnames[] = {
25730 (char *) "self", NULL
25731 };
25732
25733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25735 if (SWIG_arg_fail(1)) SWIG_fail;
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25739
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 {
25744 resultobj = SWIG_From_int((int)(result));
25745 }
25746 return resultobj;
25747 fail:
25748 return NULL;
25749 }
25750
25751
25752 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25753 PyObject *resultobj;
25754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25755 int result;
25756 PyObject * obj0 = 0 ;
25757 char *kwnames[] = {
25758 (char *) "self", NULL
25759 };
25760
25761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25763 if (SWIG_arg_fail(1)) SWIG_fail;
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 result = (int)((wxDateSpan const *)arg1)->GetDays();
25767
25768 wxPyEndAllowThreads(__tstate);
25769 if (PyErr_Occurred()) SWIG_fail;
25770 }
25771 {
25772 resultobj = SWIG_From_int((int)(result));
25773 }
25774 return resultobj;
25775 fail:
25776 return NULL;
25777 }
25778
25779
25780 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25781 PyObject *resultobj;
25782 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25783 int result;
25784 PyObject * obj0 = 0 ;
25785 char *kwnames[] = {
25786 (char *) "self", NULL
25787 };
25788
25789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25791 if (SWIG_arg_fail(1)) SWIG_fail;
25792 {
25793 PyThreadState* __tstate = wxPyBeginAllowThreads();
25794 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25795
25796 wxPyEndAllowThreads(__tstate);
25797 if (PyErr_Occurred()) SWIG_fail;
25798 }
25799 {
25800 resultobj = SWIG_From_int((int)(result));
25801 }
25802 return resultobj;
25803 fail:
25804 return NULL;
25805 }
25806
25807
25808 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25809 PyObject *resultobj;
25810 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25811 wxDateSpan *arg2 = 0 ;
25812 wxDateSpan *result;
25813 PyObject * obj0 = 0 ;
25814 PyObject * obj1 = 0 ;
25815 char *kwnames[] = {
25816 (char *) "self",(char *) "other", NULL
25817 };
25818
25819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25821 if (SWIG_arg_fail(1)) SWIG_fail;
25822 {
25823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25824 if (SWIG_arg_fail(2)) SWIG_fail;
25825 if (arg2 == NULL) {
25826 SWIG_null_ref("wxDateSpan");
25827 }
25828 if (SWIG_arg_fail(2)) SWIG_fail;
25829 }
25830 {
25831 PyThreadState* __tstate = wxPyBeginAllowThreads();
25832 {
25833 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25834 result = (wxDateSpan *) &_result_ref;
25835 }
25836
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25841 return resultobj;
25842 fail:
25843 return NULL;
25844 }
25845
25846
25847 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25848 PyObject *resultobj;
25849 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25850 wxDateSpan *arg2 = 0 ;
25851 wxDateSpan *result;
25852 PyObject * obj0 = 0 ;
25853 PyObject * obj1 = 0 ;
25854 char *kwnames[] = {
25855 (char *) "self",(char *) "other", NULL
25856 };
25857
25858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25860 if (SWIG_arg_fail(1)) SWIG_fail;
25861 {
25862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25863 if (SWIG_arg_fail(2)) SWIG_fail;
25864 if (arg2 == NULL) {
25865 SWIG_null_ref("wxDateSpan");
25866 }
25867 if (SWIG_arg_fail(2)) SWIG_fail;
25868 }
25869 {
25870 PyThreadState* __tstate = wxPyBeginAllowThreads();
25871 {
25872 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25873 result = (wxDateSpan *) &_result_ref;
25874 }
25875
25876 wxPyEndAllowThreads(__tstate);
25877 if (PyErr_Occurred()) SWIG_fail;
25878 }
25879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25880 return resultobj;
25881 fail:
25882 return NULL;
25883 }
25884
25885
25886 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25887 PyObject *resultobj;
25888 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25889 wxDateSpan *result;
25890 PyObject * obj0 = 0 ;
25891 char *kwnames[] = {
25892 (char *) "self", NULL
25893 };
25894
25895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25897 if (SWIG_arg_fail(1)) SWIG_fail;
25898 {
25899 PyThreadState* __tstate = wxPyBeginAllowThreads();
25900 {
25901 wxDateSpan &_result_ref = (arg1)->Neg();
25902 result = (wxDateSpan *) &_result_ref;
25903 }
25904
25905 wxPyEndAllowThreads(__tstate);
25906 if (PyErr_Occurred()) SWIG_fail;
25907 }
25908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25909 return resultobj;
25910 fail:
25911 return NULL;
25912 }
25913
25914
25915 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25916 PyObject *resultobj;
25917 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25918 int arg2 ;
25919 wxDateSpan *result;
25920 PyObject * obj0 = 0 ;
25921 PyObject * obj1 = 0 ;
25922 char *kwnames[] = {
25923 (char *) "self",(char *) "factor", NULL
25924 };
25925
25926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25928 if (SWIG_arg_fail(1)) SWIG_fail;
25929 {
25930 arg2 = (int)(SWIG_As_int(obj1));
25931 if (SWIG_arg_fail(2)) SWIG_fail;
25932 }
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 {
25936 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25937 result = (wxDateSpan *) &_result_ref;
25938 }
25939
25940 wxPyEndAllowThreads(__tstate);
25941 if (PyErr_Occurred()) SWIG_fail;
25942 }
25943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25951 PyObject *resultobj;
25952 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25953 wxDateSpan *arg2 = 0 ;
25954 wxDateSpan *result;
25955 PyObject * obj0 = 0 ;
25956 PyObject * obj1 = 0 ;
25957 char *kwnames[] = {
25958 (char *) "self",(char *) "other", NULL
25959 };
25960
25961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25963 if (SWIG_arg_fail(1)) SWIG_fail;
25964 {
25965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25966 if (SWIG_arg_fail(2)) SWIG_fail;
25967 if (arg2 == NULL) {
25968 SWIG_null_ref("wxDateSpan");
25969 }
25970 if (SWIG_arg_fail(2)) SWIG_fail;
25971 }
25972 {
25973 PyThreadState* __tstate = wxPyBeginAllowThreads();
25974 {
25975 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25976 result = (wxDateSpan *) &_result_ref;
25977 }
25978
25979 wxPyEndAllowThreads(__tstate);
25980 if (PyErr_Occurred()) SWIG_fail;
25981 }
25982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25983 return resultobj;
25984 fail:
25985 return NULL;
25986 }
25987
25988
25989 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25990 PyObject *resultobj;
25991 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25992 wxDateSpan *arg2 = 0 ;
25993 wxDateSpan *result;
25994 PyObject * obj0 = 0 ;
25995 PyObject * obj1 = 0 ;
25996 char *kwnames[] = {
25997 (char *) "self",(char *) "other", NULL
25998 };
25999
26000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26002 if (SWIG_arg_fail(1)) SWIG_fail;
26003 {
26004 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26005 if (SWIG_arg_fail(2)) SWIG_fail;
26006 if (arg2 == NULL) {
26007 SWIG_null_ref("wxDateSpan");
26008 }
26009 if (SWIG_arg_fail(2)) SWIG_fail;
26010 }
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 {
26014 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26015 result = (wxDateSpan *) &_result_ref;
26016 }
26017
26018 wxPyEndAllowThreads(__tstate);
26019 if (PyErr_Occurred()) SWIG_fail;
26020 }
26021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26022 return resultobj;
26023 fail:
26024 return NULL;
26025 }
26026
26027
26028 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26029 PyObject *resultobj;
26030 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26031 wxDateSpan *result;
26032 PyObject * obj0 = 0 ;
26033 char *kwnames[] = {
26034 (char *) "self", NULL
26035 };
26036
26037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26039 if (SWIG_arg_fail(1)) SWIG_fail;
26040 {
26041 PyThreadState* __tstate = wxPyBeginAllowThreads();
26042 {
26043 wxDateSpan &_result_ref = (arg1)->operator -();
26044 result = (wxDateSpan *) &_result_ref;
26045 }
26046
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26058 PyObject *resultobj;
26059 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26060 int arg2 ;
26061 wxDateSpan *result;
26062 PyObject * obj0 = 0 ;
26063 PyObject * obj1 = 0 ;
26064 char *kwnames[] = {
26065 (char *) "self",(char *) "factor", NULL
26066 };
26067
26068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26070 if (SWIG_arg_fail(1)) SWIG_fail;
26071 {
26072 arg2 = (int)(SWIG_As_int(obj1));
26073 if (SWIG_arg_fail(2)) SWIG_fail;
26074 }
26075 {
26076 PyThreadState* __tstate = wxPyBeginAllowThreads();
26077 {
26078 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26079 result = (wxDateSpan *) &_result_ref;
26080 }
26081
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26093 PyObject *resultobj;
26094 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26095 wxDateSpan *arg2 = 0 ;
26096 wxDateSpan result;
26097 PyObject * obj0 = 0 ;
26098 PyObject * obj1 = 0 ;
26099 char *kwnames[] = {
26100 (char *) "self",(char *) "other", NULL
26101 };
26102
26103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26105 if (SWIG_arg_fail(1)) SWIG_fail;
26106 {
26107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26108 if (SWIG_arg_fail(2)) SWIG_fail;
26109 if (arg2 == NULL) {
26110 SWIG_null_ref("wxDateSpan");
26111 }
26112 if (SWIG_arg_fail(2)) SWIG_fail;
26113 }
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26117
26118 wxPyEndAllowThreads(__tstate);
26119 if (PyErr_Occurred()) SWIG_fail;
26120 }
26121 {
26122 wxDateSpan * resultptr;
26123 resultptr = new wxDateSpan((wxDateSpan &)(result));
26124 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26125 }
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26133 PyObject *resultobj;
26134 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26135 wxDateSpan *arg2 = 0 ;
26136 wxDateSpan result;
26137 PyObject * obj0 = 0 ;
26138 PyObject * obj1 = 0 ;
26139 char *kwnames[] = {
26140 (char *) "self",(char *) "other", NULL
26141 };
26142
26143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26145 if (SWIG_arg_fail(1)) SWIG_fail;
26146 {
26147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26148 if (SWIG_arg_fail(2)) SWIG_fail;
26149 if (arg2 == NULL) {
26150 SWIG_null_ref("wxDateSpan");
26151 }
26152 if (SWIG_arg_fail(2)) SWIG_fail;
26153 }
26154 {
26155 PyThreadState* __tstate = wxPyBeginAllowThreads();
26156 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26157
26158 wxPyEndAllowThreads(__tstate);
26159 if (PyErr_Occurred()) SWIG_fail;
26160 }
26161 {
26162 wxDateSpan * resultptr;
26163 resultptr = new wxDateSpan((wxDateSpan &)(result));
26164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26165 }
26166 return resultobj;
26167 fail:
26168 return NULL;
26169 }
26170
26171
26172 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26173 PyObject *resultobj;
26174 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26175 int arg2 ;
26176 wxDateSpan result;
26177 PyObject * obj0 = 0 ;
26178 PyObject * obj1 = 0 ;
26179 char *kwnames[] = {
26180 (char *) "self",(char *) "n", NULL
26181 };
26182
26183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26185 if (SWIG_arg_fail(1)) SWIG_fail;
26186 {
26187 arg2 = (int)(SWIG_As_int(obj1));
26188 if (SWIG_arg_fail(2)) SWIG_fail;
26189 }
26190 {
26191 PyThreadState* __tstate = wxPyBeginAllowThreads();
26192 result = wxDateSpan___mul__(arg1,arg2);
26193
26194 wxPyEndAllowThreads(__tstate);
26195 if (PyErr_Occurred()) SWIG_fail;
26196 }
26197 {
26198 wxDateSpan * resultptr;
26199 resultptr = new wxDateSpan((wxDateSpan &)(result));
26200 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26201 }
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26209 PyObject *resultobj;
26210 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26211 int arg2 ;
26212 wxDateSpan result;
26213 PyObject * obj0 = 0 ;
26214 PyObject * obj1 = 0 ;
26215 char *kwnames[] = {
26216 (char *) "self",(char *) "n", NULL
26217 };
26218
26219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26221 if (SWIG_arg_fail(1)) SWIG_fail;
26222 {
26223 arg2 = (int)(SWIG_As_int(obj1));
26224 if (SWIG_arg_fail(2)) SWIG_fail;
26225 }
26226 {
26227 PyThreadState* __tstate = wxPyBeginAllowThreads();
26228 result = wxDateSpan___rmul__(arg1,arg2);
26229
26230 wxPyEndAllowThreads(__tstate);
26231 if (PyErr_Occurred()) SWIG_fail;
26232 }
26233 {
26234 wxDateSpan * resultptr;
26235 resultptr = new wxDateSpan((wxDateSpan &)(result));
26236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26237 }
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26245 PyObject *resultobj;
26246 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26247 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26248 bool result;
26249 PyObject * obj0 = 0 ;
26250 PyObject * obj1 = 0 ;
26251 char *kwnames[] = {
26252 (char *) "self",(char *) "other", NULL
26253 };
26254
26255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26257 if (SWIG_arg_fail(1)) SWIG_fail;
26258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26259 if (SWIG_arg_fail(2)) SWIG_fail;
26260 {
26261 PyThreadState* __tstate = wxPyBeginAllowThreads();
26262 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26263
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 {
26268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26269 }
26270 return resultobj;
26271 fail:
26272 return NULL;
26273 }
26274
26275
26276 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26277 PyObject *resultobj;
26278 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26279 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26280 bool result;
26281 PyObject * obj0 = 0 ;
26282 PyObject * obj1 = 0 ;
26283 char *kwnames[] = {
26284 (char *) "self",(char *) "other", NULL
26285 };
26286
26287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26289 if (SWIG_arg_fail(1)) SWIG_fail;
26290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26291 if (SWIG_arg_fail(2)) SWIG_fail;
26292 {
26293 PyThreadState* __tstate = wxPyBeginAllowThreads();
26294 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26295
26296 wxPyEndAllowThreads(__tstate);
26297 if (PyErr_Occurred()) SWIG_fail;
26298 }
26299 {
26300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26301 }
26302 return resultobj;
26303 fail:
26304 return NULL;
26305 }
26306
26307
26308 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26309 PyObject *obj;
26310 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26311 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26312 Py_INCREF(obj);
26313 return Py_BuildValue((char *)"");
26314 }
26315 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26316 PyObject *resultobj;
26317 long result;
26318 char *kwnames[] = {
26319 NULL
26320 };
26321
26322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26323 {
26324 PyThreadState* __tstate = wxPyBeginAllowThreads();
26325 result = (long)wxGetLocalTime();
26326
26327 wxPyEndAllowThreads(__tstate);
26328 if (PyErr_Occurred()) SWIG_fail;
26329 }
26330 {
26331 resultobj = SWIG_From_long((long)(result));
26332 }
26333 return resultobj;
26334 fail:
26335 return NULL;
26336 }
26337
26338
26339 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26340 PyObject *resultobj;
26341 long result;
26342 char *kwnames[] = {
26343 NULL
26344 };
26345
26346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26347 {
26348 PyThreadState* __tstate = wxPyBeginAllowThreads();
26349 result = (long)wxGetUTCTime();
26350
26351 wxPyEndAllowThreads(__tstate);
26352 if (PyErr_Occurred()) SWIG_fail;
26353 }
26354 {
26355 resultobj = SWIG_From_long((long)(result));
26356 }
26357 return resultobj;
26358 fail:
26359 return NULL;
26360 }
26361
26362
26363 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26364 PyObject *resultobj;
26365 long result;
26366 char *kwnames[] = {
26367 NULL
26368 };
26369
26370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26371 {
26372 PyThreadState* __tstate = wxPyBeginAllowThreads();
26373 result = (long)wxGetCurrentTime();
26374
26375 wxPyEndAllowThreads(__tstate);
26376 if (PyErr_Occurred()) SWIG_fail;
26377 }
26378 {
26379 resultobj = SWIG_From_long((long)(result));
26380 }
26381 return resultobj;
26382 fail:
26383 return NULL;
26384 }
26385
26386
26387 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26388 PyObject *resultobj;
26389 wxLongLong result;
26390 char *kwnames[] = {
26391 NULL
26392 };
26393
26394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26395 {
26396 PyThreadState* __tstate = wxPyBeginAllowThreads();
26397 result = wxGetLocalTimeMillis();
26398
26399 wxPyEndAllowThreads(__tstate);
26400 if (PyErr_Occurred()) SWIG_fail;
26401 }
26402 {
26403 PyObject *hi, *lo, *shifter, *shifted;
26404 hi = PyLong_FromLong( (&result)->GetHi() );
26405 lo = PyLong_FromLong( (&result)->GetLo() );
26406 shifter = PyLong_FromLong(32);
26407 shifted = PyNumber_Lshift(hi, shifter);
26408 resultobj = PyNumber_Or(shifted, lo);
26409 Py_DECREF(hi);
26410 Py_DECREF(lo);
26411 Py_DECREF(shifter);
26412 Py_DECREF(shifted);
26413 }
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 static int _wrap_DefaultDateTime_set(PyObject *) {
26421 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26422 return 1;
26423 }
26424
26425
26426 static PyObject *_wrap_DefaultDateTime_get(void) {
26427 PyObject *pyobj;
26428
26429 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26430 return pyobj;
26431 }
26432
26433
26434 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26435 PyObject *resultobj;
26436 wxDataFormatId arg1 ;
26437 wxDataFormat *result;
26438 PyObject * obj0 = 0 ;
26439 char *kwnames[] = {
26440 (char *) "type", NULL
26441 };
26442
26443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26444 {
26445 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26446 if (SWIG_arg_fail(1)) SWIG_fail;
26447 }
26448 {
26449 PyThreadState* __tstate = wxPyBeginAllowThreads();
26450 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26451
26452 wxPyEndAllowThreads(__tstate);
26453 if (PyErr_Occurred()) SWIG_fail;
26454 }
26455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26456 return resultobj;
26457 fail:
26458 return NULL;
26459 }
26460
26461
26462 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26463 PyObject *resultobj;
26464 wxString *arg1 = 0 ;
26465 wxDataFormat *result;
26466 bool temp1 = false ;
26467 PyObject * obj0 = 0 ;
26468 char *kwnames[] = {
26469 (char *) "format", NULL
26470 };
26471
26472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26473 {
26474 arg1 = wxString_in_helper(obj0);
26475 if (arg1 == NULL) SWIG_fail;
26476 temp1 = true;
26477 }
26478 {
26479 PyThreadState* __tstate = wxPyBeginAllowThreads();
26480 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26481
26482 wxPyEndAllowThreads(__tstate);
26483 if (PyErr_Occurred()) SWIG_fail;
26484 }
26485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26486 {
26487 if (temp1)
26488 delete arg1;
26489 }
26490 return resultobj;
26491 fail:
26492 {
26493 if (temp1)
26494 delete arg1;
26495 }
26496 return NULL;
26497 }
26498
26499
26500 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26501 PyObject *resultobj;
26502 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26503 PyObject * obj0 = 0 ;
26504 char *kwnames[] = {
26505 (char *) "self", NULL
26506 };
26507
26508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26510 if (SWIG_arg_fail(1)) SWIG_fail;
26511 {
26512 PyThreadState* __tstate = wxPyBeginAllowThreads();
26513 delete arg1;
26514
26515 wxPyEndAllowThreads(__tstate);
26516 if (PyErr_Occurred()) SWIG_fail;
26517 }
26518 Py_INCREF(Py_None); resultobj = Py_None;
26519 return resultobj;
26520 fail:
26521 return NULL;
26522 }
26523
26524
26525 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26526 PyObject *resultobj;
26527 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26528 wxDataFormatId arg2 ;
26529 bool result;
26530 PyObject * obj0 = 0 ;
26531 PyObject * obj1 = 0 ;
26532
26533 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26535 if (SWIG_arg_fail(1)) SWIG_fail;
26536 {
26537 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26538 if (SWIG_arg_fail(2)) SWIG_fail;
26539 }
26540 {
26541 PyThreadState* __tstate = wxPyBeginAllowThreads();
26542 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26543
26544 wxPyEndAllowThreads(__tstate);
26545 if (PyErr_Occurred()) SWIG_fail;
26546 }
26547 {
26548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26549 }
26550 return resultobj;
26551 fail:
26552 return NULL;
26553 }
26554
26555
26556 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26557 PyObject *resultobj;
26558 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26559 wxDataFormatId arg2 ;
26560 bool result;
26561 PyObject * obj0 = 0 ;
26562 PyObject * obj1 = 0 ;
26563
26564 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26566 if (SWIG_arg_fail(1)) SWIG_fail;
26567 {
26568 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26569 if (SWIG_arg_fail(2)) SWIG_fail;
26570 }
26571 {
26572 PyThreadState* __tstate = wxPyBeginAllowThreads();
26573 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26574
26575 wxPyEndAllowThreads(__tstate);
26576 if (PyErr_Occurred()) SWIG_fail;
26577 }
26578 {
26579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26580 }
26581 return resultobj;
26582 fail:
26583 return NULL;
26584 }
26585
26586
26587 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26588 PyObject *resultobj;
26589 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26590 wxDataFormat *arg2 = 0 ;
26591 bool result;
26592 PyObject * obj0 = 0 ;
26593 PyObject * obj1 = 0 ;
26594
26595 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26597 if (SWIG_arg_fail(1)) SWIG_fail;
26598 {
26599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26600 if (SWIG_arg_fail(2)) SWIG_fail;
26601 if (arg2 == NULL) {
26602 SWIG_null_ref("wxDataFormat");
26603 }
26604 if (SWIG_arg_fail(2)) SWIG_fail;
26605 }
26606 {
26607 PyThreadState* __tstate = wxPyBeginAllowThreads();
26608 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26609
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 {
26614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26615 }
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26623 int argc;
26624 PyObject *argv[3];
26625 int ii;
26626
26627 argc = PyObject_Length(args);
26628 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26629 argv[ii] = PyTuple_GetItem(args,ii);
26630 }
26631 if (argc == 2) {
26632 int _v;
26633 {
26634 void *ptr;
26635 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26636 _v = 0;
26637 PyErr_Clear();
26638 } else {
26639 _v = 1;
26640 }
26641 }
26642 if (_v) {
26643 {
26644 void *ptr = 0;
26645 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26646 _v = 0;
26647 PyErr_Clear();
26648 } else {
26649 _v = (ptr != 0);
26650 }
26651 }
26652 if (_v) {
26653 return _wrap_DataFormat___eq____SWIG_1(self,args);
26654 }
26655 }
26656 }
26657 if (argc == 2) {
26658 int _v;
26659 {
26660 void *ptr;
26661 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26662 _v = 0;
26663 PyErr_Clear();
26664 } else {
26665 _v = 1;
26666 }
26667 }
26668 if (_v) {
26669 _v = SWIG_Check_int(argv[1]);
26670 if (_v) {
26671 return _wrap_DataFormat___eq____SWIG_0(self,args);
26672 }
26673 }
26674 }
26675
26676 Py_INCREF(Py_NotImplemented);
26677 return Py_NotImplemented;
26678 }
26679
26680
26681 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26682 PyObject *resultobj;
26683 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26684 wxDataFormat *arg2 = 0 ;
26685 bool result;
26686 PyObject * obj0 = 0 ;
26687 PyObject * obj1 = 0 ;
26688
26689 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26691 if (SWIG_arg_fail(1)) SWIG_fail;
26692 {
26693 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26694 if (SWIG_arg_fail(2)) SWIG_fail;
26695 if (arg2 == NULL) {
26696 SWIG_null_ref("wxDataFormat");
26697 }
26698 if (SWIG_arg_fail(2)) SWIG_fail;
26699 }
26700 {
26701 PyThreadState* __tstate = wxPyBeginAllowThreads();
26702 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26703
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 {
26708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26709 }
26710 return resultobj;
26711 fail:
26712 return NULL;
26713 }
26714
26715
26716 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26717 int argc;
26718 PyObject *argv[3];
26719 int ii;
26720
26721 argc = PyObject_Length(args);
26722 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26723 argv[ii] = PyTuple_GetItem(args,ii);
26724 }
26725 if (argc == 2) {
26726 int _v;
26727 {
26728 void *ptr;
26729 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26730 _v = 0;
26731 PyErr_Clear();
26732 } else {
26733 _v = 1;
26734 }
26735 }
26736 if (_v) {
26737 {
26738 void *ptr = 0;
26739 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26740 _v = 0;
26741 PyErr_Clear();
26742 } else {
26743 _v = (ptr != 0);
26744 }
26745 }
26746 if (_v) {
26747 return _wrap_DataFormat___ne____SWIG_1(self,args);
26748 }
26749 }
26750 }
26751 if (argc == 2) {
26752 int _v;
26753 {
26754 void *ptr;
26755 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26756 _v = 0;
26757 PyErr_Clear();
26758 } else {
26759 _v = 1;
26760 }
26761 }
26762 if (_v) {
26763 _v = SWIG_Check_int(argv[1]);
26764 if (_v) {
26765 return _wrap_DataFormat___ne____SWIG_0(self,args);
26766 }
26767 }
26768 }
26769
26770 Py_INCREF(Py_NotImplemented);
26771 return Py_NotImplemented;
26772 }
26773
26774
26775 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26776 PyObject *resultobj;
26777 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26778 wxDataFormatId arg2 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char *kwnames[] = {
26782 (char *) "self",(char *) "format", NULL
26783 };
26784
26785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26787 if (SWIG_arg_fail(1)) SWIG_fail;
26788 {
26789 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26790 if (SWIG_arg_fail(2)) SWIG_fail;
26791 }
26792 {
26793 PyThreadState* __tstate = wxPyBeginAllowThreads();
26794 (arg1)->SetType((wxDataFormatId )arg2);
26795
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 Py_INCREF(Py_None); resultobj = Py_None;
26800 return resultobj;
26801 fail:
26802 return NULL;
26803 }
26804
26805
26806 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26807 PyObject *resultobj;
26808 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26809 wxDataFormatId result;
26810 PyObject * obj0 = 0 ;
26811 char *kwnames[] = {
26812 (char *) "self", NULL
26813 };
26814
26815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26817 if (SWIG_arg_fail(1)) SWIG_fail;
26818 {
26819 PyThreadState* __tstate = wxPyBeginAllowThreads();
26820 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26821
26822 wxPyEndAllowThreads(__tstate);
26823 if (PyErr_Occurred()) SWIG_fail;
26824 }
26825 resultobj = SWIG_From_int((result));
26826 return resultobj;
26827 fail:
26828 return NULL;
26829 }
26830
26831
26832 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26833 PyObject *resultobj;
26834 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26835 wxString result;
26836 PyObject * obj0 = 0 ;
26837 char *kwnames[] = {
26838 (char *) "self", NULL
26839 };
26840
26841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26843 if (SWIG_arg_fail(1)) SWIG_fail;
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 result = ((wxDataFormat const *)arg1)->GetId();
26847
26848 wxPyEndAllowThreads(__tstate);
26849 if (PyErr_Occurred()) SWIG_fail;
26850 }
26851 {
26852 #if wxUSE_UNICODE
26853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26854 #else
26855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26856 #endif
26857 }
26858 return resultobj;
26859 fail:
26860 return NULL;
26861 }
26862
26863
26864 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26865 PyObject *resultobj;
26866 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26867 wxString *arg2 = 0 ;
26868 bool temp2 = false ;
26869 PyObject * obj0 = 0 ;
26870 PyObject * obj1 = 0 ;
26871 char *kwnames[] = {
26872 (char *) "self",(char *) "format", NULL
26873 };
26874
26875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26877 if (SWIG_arg_fail(1)) SWIG_fail;
26878 {
26879 arg2 = wxString_in_helper(obj1);
26880 if (arg2 == NULL) SWIG_fail;
26881 temp2 = true;
26882 }
26883 {
26884 PyThreadState* __tstate = wxPyBeginAllowThreads();
26885 (arg1)->SetId((wxString const &)*arg2);
26886
26887 wxPyEndAllowThreads(__tstate);
26888 if (PyErr_Occurred()) SWIG_fail;
26889 }
26890 Py_INCREF(Py_None); resultobj = Py_None;
26891 {
26892 if (temp2)
26893 delete arg2;
26894 }
26895 return resultobj;
26896 fail:
26897 {
26898 if (temp2)
26899 delete arg2;
26900 }
26901 return NULL;
26902 }
26903
26904
26905 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26906 PyObject *obj;
26907 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26908 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26909 Py_INCREF(obj);
26910 return Py_BuildValue((char *)"");
26911 }
26912 static int _wrap_FormatInvalid_set(PyObject *) {
26913 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26914 return 1;
26915 }
26916
26917
26918 static PyObject *_wrap_FormatInvalid_get(void) {
26919 PyObject *pyobj;
26920
26921 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26922 return pyobj;
26923 }
26924
26925
26926 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26927 PyObject *resultobj;
26928 wxDataObject *arg1 = (wxDataObject *) 0 ;
26929 PyObject * obj0 = 0 ;
26930 char *kwnames[] = {
26931 (char *) "self", NULL
26932 };
26933
26934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26936 if (SWIG_arg_fail(1)) SWIG_fail;
26937 {
26938 PyThreadState* __tstate = wxPyBeginAllowThreads();
26939 delete arg1;
26940
26941 wxPyEndAllowThreads(__tstate);
26942 if (PyErr_Occurred()) SWIG_fail;
26943 }
26944 Py_INCREF(Py_None); resultobj = Py_None;
26945 return resultobj;
26946 fail:
26947 return NULL;
26948 }
26949
26950
26951 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26952 PyObject *resultobj;
26953 wxDataObject *arg1 = (wxDataObject *) 0 ;
26954 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26955 SwigValueWrapper<wxDataFormat > result;
26956 PyObject * obj0 = 0 ;
26957 PyObject * obj1 = 0 ;
26958 char *kwnames[] = {
26959 (char *) "self",(char *) "dir", NULL
26960 };
26961
26962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26964 if (SWIG_arg_fail(1)) SWIG_fail;
26965 if (obj1) {
26966 {
26967 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26968 if (SWIG_arg_fail(2)) SWIG_fail;
26969 }
26970 }
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26974
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 {
26979 wxDataFormat * resultptr;
26980 resultptr = new wxDataFormat((wxDataFormat &)(result));
26981 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26982 }
26983 return resultobj;
26984 fail:
26985 return NULL;
26986 }
26987
26988
26989 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26990 PyObject *resultobj;
26991 wxDataObject *arg1 = (wxDataObject *) 0 ;
26992 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26993 size_t result;
26994 PyObject * obj0 = 0 ;
26995 PyObject * obj1 = 0 ;
26996 char *kwnames[] = {
26997 (char *) "self",(char *) "dir", NULL
26998 };
26999
27000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27002 if (SWIG_arg_fail(1)) SWIG_fail;
27003 if (obj1) {
27004 {
27005 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27006 if (SWIG_arg_fail(2)) SWIG_fail;
27007 }
27008 }
27009 {
27010 PyThreadState* __tstate = wxPyBeginAllowThreads();
27011 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27012
27013 wxPyEndAllowThreads(__tstate);
27014 if (PyErr_Occurred()) SWIG_fail;
27015 }
27016 {
27017 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27018 }
27019 return resultobj;
27020 fail:
27021 return NULL;
27022 }
27023
27024
27025 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27026 PyObject *resultobj;
27027 wxDataObject *arg1 = (wxDataObject *) 0 ;
27028 wxDataFormat *arg2 = 0 ;
27029 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27030 bool result;
27031 PyObject * obj0 = 0 ;
27032 PyObject * obj1 = 0 ;
27033 PyObject * obj2 = 0 ;
27034 char *kwnames[] = {
27035 (char *) "self",(char *) "format",(char *) "dir", NULL
27036 };
27037
27038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27040 if (SWIG_arg_fail(1)) SWIG_fail;
27041 {
27042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27043 if (SWIG_arg_fail(2)) SWIG_fail;
27044 if (arg2 == NULL) {
27045 SWIG_null_ref("wxDataFormat");
27046 }
27047 if (SWIG_arg_fail(2)) SWIG_fail;
27048 }
27049 if (obj2) {
27050 {
27051 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27052 if (SWIG_arg_fail(3)) SWIG_fail;
27053 }
27054 }
27055 {
27056 PyThreadState* __tstate = wxPyBeginAllowThreads();
27057 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27058
27059 wxPyEndAllowThreads(__tstate);
27060 if (PyErr_Occurred()) SWIG_fail;
27061 }
27062 {
27063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27064 }
27065 return resultobj;
27066 fail:
27067 return NULL;
27068 }
27069
27070
27071 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27072 PyObject *resultobj;
27073 wxDataObject *arg1 = (wxDataObject *) 0 ;
27074 wxDataFormat *arg2 = 0 ;
27075 size_t result;
27076 PyObject * obj0 = 0 ;
27077 PyObject * obj1 = 0 ;
27078 char *kwnames[] = {
27079 (char *) "self",(char *) "format", NULL
27080 };
27081
27082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27084 if (SWIG_arg_fail(1)) SWIG_fail;
27085 {
27086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27087 if (SWIG_arg_fail(2)) SWIG_fail;
27088 if (arg2 == NULL) {
27089 SWIG_null_ref("wxDataFormat");
27090 }
27091 if (SWIG_arg_fail(2)) SWIG_fail;
27092 }
27093 {
27094 PyThreadState* __tstate = wxPyBeginAllowThreads();
27095 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27096
27097 wxPyEndAllowThreads(__tstate);
27098 if (PyErr_Occurred()) SWIG_fail;
27099 }
27100 {
27101 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27102 }
27103 return resultobj;
27104 fail:
27105 return NULL;
27106 }
27107
27108
27109 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27110 PyObject *resultobj;
27111 wxDataObject *arg1 = (wxDataObject *) 0 ;
27112 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27113 PyObject *result;
27114 PyObject * obj0 = 0 ;
27115 PyObject * obj1 = 0 ;
27116 char *kwnames[] = {
27117 (char *) "self",(char *) "dir", NULL
27118 };
27119
27120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27122 if (SWIG_arg_fail(1)) SWIG_fail;
27123 if (obj1) {
27124 {
27125 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27126 if (SWIG_arg_fail(2)) SWIG_fail;
27127 }
27128 }
27129 {
27130 PyThreadState* __tstate = wxPyBeginAllowThreads();
27131 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27132
27133 wxPyEndAllowThreads(__tstate);
27134 if (PyErr_Occurred()) SWIG_fail;
27135 }
27136 resultobj = result;
27137 return resultobj;
27138 fail:
27139 return NULL;
27140 }
27141
27142
27143 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27144 PyObject *resultobj;
27145 wxDataObject *arg1 = (wxDataObject *) 0 ;
27146 wxDataFormat *arg2 = 0 ;
27147 PyObject *result;
27148 PyObject * obj0 = 0 ;
27149 PyObject * obj1 = 0 ;
27150 char *kwnames[] = {
27151 (char *) "self",(char *) "format", NULL
27152 };
27153
27154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27156 if (SWIG_arg_fail(1)) SWIG_fail;
27157 {
27158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27159 if (SWIG_arg_fail(2)) SWIG_fail;
27160 if (arg2 == NULL) {
27161 SWIG_null_ref("wxDataFormat");
27162 }
27163 if (SWIG_arg_fail(2)) SWIG_fail;
27164 }
27165 {
27166 PyThreadState* __tstate = wxPyBeginAllowThreads();
27167 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27168
27169 wxPyEndAllowThreads(__tstate);
27170 if (PyErr_Occurred()) SWIG_fail;
27171 }
27172 resultobj = result;
27173 return resultobj;
27174 fail:
27175 return NULL;
27176 }
27177
27178
27179 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27180 PyObject *resultobj;
27181 wxDataObject *arg1 = (wxDataObject *) 0 ;
27182 wxDataFormat *arg2 = 0 ;
27183 PyObject *arg3 = (PyObject *) 0 ;
27184 bool result;
27185 PyObject * obj0 = 0 ;
27186 PyObject * obj1 = 0 ;
27187 PyObject * obj2 = 0 ;
27188 char *kwnames[] = {
27189 (char *) "self",(char *) "format",(char *) "data", NULL
27190 };
27191
27192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27194 if (SWIG_arg_fail(1)) SWIG_fail;
27195 {
27196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27197 if (SWIG_arg_fail(2)) SWIG_fail;
27198 if (arg2 == NULL) {
27199 SWIG_null_ref("wxDataFormat");
27200 }
27201 if (SWIG_arg_fail(2)) SWIG_fail;
27202 }
27203 arg3 = obj2;
27204 {
27205 PyThreadState* __tstate = wxPyBeginAllowThreads();
27206 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27207
27208 wxPyEndAllowThreads(__tstate);
27209 if (PyErr_Occurred()) SWIG_fail;
27210 }
27211 {
27212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27213 }
27214 return resultobj;
27215 fail:
27216 return NULL;
27217 }
27218
27219
27220 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27221 PyObject *obj;
27222 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27223 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27224 Py_INCREF(obj);
27225 return Py_BuildValue((char *)"");
27226 }
27227 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27228 PyObject *resultobj;
27229 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27230 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27231 wxDataObjectSimple *result;
27232 PyObject * obj0 = 0 ;
27233 char *kwnames[] = {
27234 (char *) "format", NULL
27235 };
27236
27237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27238 if (obj0) {
27239 {
27240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27241 if (SWIG_arg_fail(1)) SWIG_fail;
27242 if (arg1 == NULL) {
27243 SWIG_null_ref("wxDataFormat");
27244 }
27245 if (SWIG_arg_fail(1)) SWIG_fail;
27246 }
27247 }
27248 {
27249 PyThreadState* __tstate = wxPyBeginAllowThreads();
27250 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27251
27252 wxPyEndAllowThreads(__tstate);
27253 if (PyErr_Occurred()) SWIG_fail;
27254 }
27255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27256 return resultobj;
27257 fail:
27258 return NULL;
27259 }
27260
27261
27262 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27263 PyObject *resultobj;
27264 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27265 wxDataFormat *result;
27266 PyObject * obj0 = 0 ;
27267 char *kwnames[] = {
27268 (char *) "self", NULL
27269 };
27270
27271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27273 if (SWIG_arg_fail(1)) SWIG_fail;
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 {
27277 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27278 result = (wxDataFormat *) &_result_ref;
27279 }
27280
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27292 PyObject *resultobj;
27293 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27294 wxDataFormat *arg2 = 0 ;
27295 PyObject * obj0 = 0 ;
27296 PyObject * obj1 = 0 ;
27297 char *kwnames[] = {
27298 (char *) "self",(char *) "format", NULL
27299 };
27300
27301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27303 if (SWIG_arg_fail(1)) SWIG_fail;
27304 {
27305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27306 if (SWIG_arg_fail(2)) SWIG_fail;
27307 if (arg2 == NULL) {
27308 SWIG_null_ref("wxDataFormat");
27309 }
27310 if (SWIG_arg_fail(2)) SWIG_fail;
27311 }
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27315
27316 wxPyEndAllowThreads(__tstate);
27317 if (PyErr_Occurred()) SWIG_fail;
27318 }
27319 Py_INCREF(Py_None); resultobj = Py_None;
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj;
27328 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27329 size_t result;
27330 PyObject * obj0 = 0 ;
27331 char *kwnames[] = {
27332 (char *) "self", NULL
27333 };
27334
27335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27337 if (SWIG_arg_fail(1)) SWIG_fail;
27338 {
27339 PyThreadState* __tstate = wxPyBeginAllowThreads();
27340 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27341
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 {
27346 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27347 }
27348 return resultobj;
27349 fail:
27350 return NULL;
27351 }
27352
27353
27354 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27355 PyObject *resultobj;
27356 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27357 PyObject *result;
27358 PyObject * obj0 = 0 ;
27359 char *kwnames[] = {
27360 (char *) "self", NULL
27361 };
27362
27363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27365 if (SWIG_arg_fail(1)) SWIG_fail;
27366 {
27367 PyThreadState* __tstate = wxPyBeginAllowThreads();
27368 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27369
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 resultobj = result;
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27381 PyObject *resultobj;
27382 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27383 PyObject *arg2 = (PyObject *) 0 ;
27384 bool result;
27385 PyObject * obj0 = 0 ;
27386 PyObject * obj1 = 0 ;
27387 char *kwnames[] = {
27388 (char *) "self",(char *) "data", NULL
27389 };
27390
27391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27393 if (SWIG_arg_fail(1)) SWIG_fail;
27394 arg2 = obj1;
27395 {
27396 PyThreadState* __tstate = wxPyBeginAllowThreads();
27397 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27398
27399 wxPyEndAllowThreads(__tstate);
27400 if (PyErr_Occurred()) SWIG_fail;
27401 }
27402 {
27403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27404 }
27405 return resultobj;
27406 fail:
27407 return NULL;
27408 }
27409
27410
27411 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27412 PyObject *obj;
27413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27414 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27415 Py_INCREF(obj);
27416 return Py_BuildValue((char *)"");
27417 }
27418 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27419 PyObject *resultobj;
27420 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27421 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27422 wxPyDataObjectSimple *result;
27423 PyObject * obj0 = 0 ;
27424 char *kwnames[] = {
27425 (char *) "format", NULL
27426 };
27427
27428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27429 if (obj0) {
27430 {
27431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27432 if (SWIG_arg_fail(1)) SWIG_fail;
27433 if (arg1 == NULL) {
27434 SWIG_null_ref("wxDataFormat");
27435 }
27436 if (SWIG_arg_fail(1)) SWIG_fail;
27437 }
27438 }
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27442
27443 wxPyEndAllowThreads(__tstate);
27444 if (PyErr_Occurred()) SWIG_fail;
27445 }
27446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27447 return resultobj;
27448 fail:
27449 return NULL;
27450 }
27451
27452
27453 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27454 PyObject *resultobj;
27455 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27456 PyObject *arg2 = (PyObject *) 0 ;
27457 PyObject *arg3 = (PyObject *) 0 ;
27458 PyObject * obj0 = 0 ;
27459 PyObject * obj1 = 0 ;
27460 PyObject * obj2 = 0 ;
27461 char *kwnames[] = {
27462 (char *) "self",(char *) "self",(char *) "_class", NULL
27463 };
27464
27465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27467 if (SWIG_arg_fail(1)) SWIG_fail;
27468 arg2 = obj1;
27469 arg3 = obj2;
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 (arg1)->_setCallbackInfo(arg2,arg3);
27473
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 Py_INCREF(Py_None); resultobj = Py_None;
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27485 PyObject *obj;
27486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27487 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27488 Py_INCREF(obj);
27489 return Py_BuildValue((char *)"");
27490 }
27491 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27492 PyObject *resultobj;
27493 wxDataObjectComposite *result;
27494 char *kwnames[] = {
27495 NULL
27496 };
27497
27498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27499 {
27500 PyThreadState* __tstate = wxPyBeginAllowThreads();
27501 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27502
27503 wxPyEndAllowThreads(__tstate);
27504 if (PyErr_Occurred()) SWIG_fail;
27505 }
27506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27507 return resultobj;
27508 fail:
27509 return NULL;
27510 }
27511
27512
27513 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27514 PyObject *resultobj;
27515 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27516 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27517 bool arg3 = (bool) false ;
27518 PyObject * obj0 = 0 ;
27519 PyObject * obj1 = 0 ;
27520 PyObject * obj2 = 0 ;
27521 char *kwnames[] = {
27522 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27523 };
27524
27525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27527 if (SWIG_arg_fail(1)) SWIG_fail;
27528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27529 if (SWIG_arg_fail(2)) SWIG_fail;
27530 if (obj2) {
27531 {
27532 arg3 = (bool)(SWIG_As_bool(obj2));
27533 if (SWIG_arg_fail(3)) SWIG_fail;
27534 }
27535 }
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 (arg1)->Add(arg2,arg3);
27539
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 Py_INCREF(Py_None); resultobj = Py_None;
27544 return resultobj;
27545 fail:
27546 return NULL;
27547 }
27548
27549
27550 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27551 PyObject *obj;
27552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27553 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27554 Py_INCREF(obj);
27555 return Py_BuildValue((char *)"");
27556 }
27557 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27558 PyObject *resultobj;
27559 wxString const &arg1_defvalue = wxPyEmptyString ;
27560 wxString *arg1 = (wxString *) &arg1_defvalue ;
27561 wxTextDataObject *result;
27562 bool temp1 = false ;
27563 PyObject * obj0 = 0 ;
27564 char *kwnames[] = {
27565 (char *) "text", NULL
27566 };
27567
27568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27569 if (obj0) {
27570 {
27571 arg1 = wxString_in_helper(obj0);
27572 if (arg1 == NULL) SWIG_fail;
27573 temp1 = true;
27574 }
27575 }
27576 {
27577 PyThreadState* __tstate = wxPyBeginAllowThreads();
27578 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27579
27580 wxPyEndAllowThreads(__tstate);
27581 if (PyErr_Occurred()) SWIG_fail;
27582 }
27583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27584 {
27585 if (temp1)
27586 delete arg1;
27587 }
27588 return resultobj;
27589 fail:
27590 {
27591 if (temp1)
27592 delete arg1;
27593 }
27594 return NULL;
27595 }
27596
27597
27598 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27599 PyObject *resultobj;
27600 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27601 size_t result;
27602 PyObject * obj0 = 0 ;
27603 char *kwnames[] = {
27604 (char *) "self", NULL
27605 };
27606
27607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27609 if (SWIG_arg_fail(1)) SWIG_fail;
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 result = (size_t)(arg1)->GetTextLength();
27613
27614 wxPyEndAllowThreads(__tstate);
27615 if (PyErr_Occurred()) SWIG_fail;
27616 }
27617 {
27618 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27619 }
27620 return resultobj;
27621 fail:
27622 return NULL;
27623 }
27624
27625
27626 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27627 PyObject *resultobj;
27628 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27629 wxString result;
27630 PyObject * obj0 = 0 ;
27631 char *kwnames[] = {
27632 (char *) "self", NULL
27633 };
27634
27635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27637 if (SWIG_arg_fail(1)) SWIG_fail;
27638 {
27639 PyThreadState* __tstate = wxPyBeginAllowThreads();
27640 result = (arg1)->GetText();
27641
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 {
27646 #if wxUSE_UNICODE
27647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27648 #else
27649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27650 #endif
27651 }
27652 return resultobj;
27653 fail:
27654 return NULL;
27655 }
27656
27657
27658 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27659 PyObject *resultobj;
27660 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27661 wxString *arg2 = 0 ;
27662 bool temp2 = false ;
27663 PyObject * obj0 = 0 ;
27664 PyObject * obj1 = 0 ;
27665 char *kwnames[] = {
27666 (char *) "self",(char *) "text", NULL
27667 };
27668
27669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27671 if (SWIG_arg_fail(1)) SWIG_fail;
27672 {
27673 arg2 = wxString_in_helper(obj1);
27674 if (arg2 == NULL) SWIG_fail;
27675 temp2 = true;
27676 }
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 (arg1)->SetText((wxString const &)*arg2);
27680
27681 wxPyEndAllowThreads(__tstate);
27682 if (PyErr_Occurred()) SWIG_fail;
27683 }
27684 Py_INCREF(Py_None); resultobj = Py_None;
27685 {
27686 if (temp2)
27687 delete arg2;
27688 }
27689 return resultobj;
27690 fail:
27691 {
27692 if (temp2)
27693 delete arg2;
27694 }
27695 return NULL;
27696 }
27697
27698
27699 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27700 PyObject *obj;
27701 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27702 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27703 Py_INCREF(obj);
27704 return Py_BuildValue((char *)"");
27705 }
27706 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27707 PyObject *resultobj;
27708 wxString const &arg1_defvalue = wxPyEmptyString ;
27709 wxString *arg1 = (wxString *) &arg1_defvalue ;
27710 wxPyTextDataObject *result;
27711 bool temp1 = false ;
27712 PyObject * obj0 = 0 ;
27713 char *kwnames[] = {
27714 (char *) "text", NULL
27715 };
27716
27717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27718 if (obj0) {
27719 {
27720 arg1 = wxString_in_helper(obj0);
27721 if (arg1 == NULL) SWIG_fail;
27722 temp1 = true;
27723 }
27724 }
27725 {
27726 PyThreadState* __tstate = wxPyBeginAllowThreads();
27727 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27728
27729 wxPyEndAllowThreads(__tstate);
27730 if (PyErr_Occurred()) SWIG_fail;
27731 }
27732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27733 {
27734 if (temp1)
27735 delete arg1;
27736 }
27737 return resultobj;
27738 fail:
27739 {
27740 if (temp1)
27741 delete arg1;
27742 }
27743 return NULL;
27744 }
27745
27746
27747 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27748 PyObject *resultobj;
27749 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27750 PyObject *arg2 = (PyObject *) 0 ;
27751 PyObject *arg3 = (PyObject *) 0 ;
27752 PyObject * obj0 = 0 ;
27753 PyObject * obj1 = 0 ;
27754 PyObject * obj2 = 0 ;
27755 char *kwnames[] = {
27756 (char *) "self",(char *) "self",(char *) "_class", NULL
27757 };
27758
27759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27761 if (SWIG_arg_fail(1)) SWIG_fail;
27762 arg2 = obj1;
27763 arg3 = obj2;
27764 {
27765 PyThreadState* __tstate = wxPyBeginAllowThreads();
27766 (arg1)->_setCallbackInfo(arg2,arg3);
27767
27768 wxPyEndAllowThreads(__tstate);
27769 if (PyErr_Occurred()) SWIG_fail;
27770 }
27771 Py_INCREF(Py_None); resultobj = Py_None;
27772 return resultobj;
27773 fail:
27774 return NULL;
27775 }
27776
27777
27778 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27779 PyObject *obj;
27780 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27781 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27782 Py_INCREF(obj);
27783 return Py_BuildValue((char *)"");
27784 }
27785 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27786 PyObject *resultobj;
27787 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27788 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27789 wxBitmapDataObject *result;
27790 PyObject * obj0 = 0 ;
27791 char *kwnames[] = {
27792 (char *) "bitmap", NULL
27793 };
27794
27795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27796 if (obj0) {
27797 {
27798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27799 if (SWIG_arg_fail(1)) SWIG_fail;
27800 if (arg1 == NULL) {
27801 SWIG_null_ref("wxBitmap");
27802 }
27803 if (SWIG_arg_fail(1)) SWIG_fail;
27804 }
27805 }
27806 {
27807 PyThreadState* __tstate = wxPyBeginAllowThreads();
27808 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27809
27810 wxPyEndAllowThreads(__tstate);
27811 if (PyErr_Occurred()) SWIG_fail;
27812 }
27813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27814 return resultobj;
27815 fail:
27816 return NULL;
27817 }
27818
27819
27820 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27821 PyObject *resultobj;
27822 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27823 wxBitmap result;
27824 PyObject * obj0 = 0 ;
27825 char *kwnames[] = {
27826 (char *) "self", NULL
27827 };
27828
27829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27831 if (SWIG_arg_fail(1)) SWIG_fail;
27832 {
27833 PyThreadState* __tstate = wxPyBeginAllowThreads();
27834 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27835
27836 wxPyEndAllowThreads(__tstate);
27837 if (PyErr_Occurred()) SWIG_fail;
27838 }
27839 {
27840 wxBitmap * resultptr;
27841 resultptr = new wxBitmap((wxBitmap &)(result));
27842 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27843 }
27844 return resultobj;
27845 fail:
27846 return NULL;
27847 }
27848
27849
27850 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27851 PyObject *resultobj;
27852 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27853 wxBitmap *arg2 = 0 ;
27854 PyObject * obj0 = 0 ;
27855 PyObject * obj1 = 0 ;
27856 char *kwnames[] = {
27857 (char *) "self",(char *) "bitmap", NULL
27858 };
27859
27860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27862 if (SWIG_arg_fail(1)) SWIG_fail;
27863 {
27864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27865 if (SWIG_arg_fail(2)) SWIG_fail;
27866 if (arg2 == NULL) {
27867 SWIG_null_ref("wxBitmap");
27868 }
27869 if (SWIG_arg_fail(2)) SWIG_fail;
27870 }
27871 {
27872 PyThreadState* __tstate = wxPyBeginAllowThreads();
27873 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27874
27875 wxPyEndAllowThreads(__tstate);
27876 if (PyErr_Occurred()) SWIG_fail;
27877 }
27878 Py_INCREF(Py_None); resultobj = Py_None;
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27886 PyObject *obj;
27887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27888 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27889 Py_INCREF(obj);
27890 return Py_BuildValue((char *)"");
27891 }
27892 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27893 PyObject *resultobj;
27894 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27895 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27896 wxPyBitmapDataObject *result;
27897 PyObject * obj0 = 0 ;
27898 char *kwnames[] = {
27899 (char *) "bitmap", NULL
27900 };
27901
27902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27903 if (obj0) {
27904 {
27905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27906 if (SWIG_arg_fail(1)) SWIG_fail;
27907 if (arg1 == NULL) {
27908 SWIG_null_ref("wxBitmap");
27909 }
27910 if (SWIG_arg_fail(1)) SWIG_fail;
27911 }
27912 }
27913 {
27914 PyThreadState* __tstate = wxPyBeginAllowThreads();
27915 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27916
27917 wxPyEndAllowThreads(__tstate);
27918 if (PyErr_Occurred()) SWIG_fail;
27919 }
27920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27921 return resultobj;
27922 fail:
27923 return NULL;
27924 }
27925
27926
27927 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27928 PyObject *resultobj;
27929 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27930 PyObject *arg2 = (PyObject *) 0 ;
27931 PyObject *arg3 = (PyObject *) 0 ;
27932 PyObject * obj0 = 0 ;
27933 PyObject * obj1 = 0 ;
27934 PyObject * obj2 = 0 ;
27935 char *kwnames[] = {
27936 (char *) "self",(char *) "self",(char *) "_class", NULL
27937 };
27938
27939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27941 if (SWIG_arg_fail(1)) SWIG_fail;
27942 arg2 = obj1;
27943 arg3 = obj2;
27944 {
27945 PyThreadState* __tstate = wxPyBeginAllowThreads();
27946 (arg1)->_setCallbackInfo(arg2,arg3);
27947
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 Py_INCREF(Py_None); resultobj = Py_None;
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27959 PyObject *obj;
27960 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27961 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27962 Py_INCREF(obj);
27963 return Py_BuildValue((char *)"");
27964 }
27965 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj;
27967 wxFileDataObject *result;
27968 char *kwnames[] = {
27969 NULL
27970 };
27971
27972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 result = (wxFileDataObject *)new wxFileDataObject();
27976
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27981 return resultobj;
27982 fail:
27983 return NULL;
27984 }
27985
27986
27987 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27988 PyObject *resultobj;
27989 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27990 wxArrayString *result;
27991 PyObject * obj0 = 0 ;
27992 char *kwnames[] = {
27993 (char *) "self", NULL
27994 };
27995
27996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27998 if (SWIG_arg_fail(1)) SWIG_fail;
27999 {
28000 PyThreadState* __tstate = wxPyBeginAllowThreads();
28001 {
28002 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28003 result = (wxArrayString *) &_result_ref;
28004 }
28005
28006 wxPyEndAllowThreads(__tstate);
28007 if (PyErr_Occurred()) SWIG_fail;
28008 }
28009 {
28010 resultobj = wxArrayString2PyList_helper(*result);
28011 }
28012 return resultobj;
28013 fail:
28014 return NULL;
28015 }
28016
28017
28018 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28019 PyObject *resultobj;
28020 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28021 wxString *arg2 = 0 ;
28022 bool temp2 = false ;
28023 PyObject * obj0 = 0 ;
28024 PyObject * obj1 = 0 ;
28025 char *kwnames[] = {
28026 (char *) "self",(char *) "filename", NULL
28027 };
28028
28029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28031 if (SWIG_arg_fail(1)) SWIG_fail;
28032 {
28033 arg2 = wxString_in_helper(obj1);
28034 if (arg2 == NULL) SWIG_fail;
28035 temp2 = true;
28036 }
28037 {
28038 PyThreadState* __tstate = wxPyBeginAllowThreads();
28039 (arg1)->AddFile((wxString const &)*arg2);
28040
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 Py_INCREF(Py_None); resultobj = Py_None;
28045 {
28046 if (temp2)
28047 delete arg2;
28048 }
28049 return resultobj;
28050 fail:
28051 {
28052 if (temp2)
28053 delete arg2;
28054 }
28055 return NULL;
28056 }
28057
28058
28059 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28060 PyObject *obj;
28061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28062 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28063 Py_INCREF(obj);
28064 return Py_BuildValue((char *)"");
28065 }
28066 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28067 PyObject *resultobj;
28068 wxDataFormat *arg1 = 0 ;
28069 wxCustomDataObject *result;
28070 PyObject * obj0 = 0 ;
28071
28072 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28073 {
28074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28075 if (SWIG_arg_fail(1)) SWIG_fail;
28076 if (arg1 == NULL) {
28077 SWIG_null_ref("wxDataFormat");
28078 }
28079 if (SWIG_arg_fail(1)) SWIG_fail;
28080 }
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28084
28085 wxPyEndAllowThreads(__tstate);
28086 if (PyErr_Occurred()) SWIG_fail;
28087 }
28088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28089 return resultobj;
28090 fail:
28091 return NULL;
28092 }
28093
28094
28095 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28096 PyObject *resultobj;
28097 wxString *arg1 = 0 ;
28098 wxCustomDataObject *result;
28099 bool temp1 = false ;
28100 PyObject * obj0 = 0 ;
28101
28102 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28103 {
28104 arg1 = wxString_in_helper(obj0);
28105 if (arg1 == NULL) SWIG_fail;
28106 temp1 = true;
28107 }
28108 {
28109 PyThreadState* __tstate = wxPyBeginAllowThreads();
28110 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28111
28112 wxPyEndAllowThreads(__tstate);
28113 if (PyErr_Occurred()) SWIG_fail;
28114 }
28115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28116 {
28117 if (temp1)
28118 delete arg1;
28119 }
28120 return resultobj;
28121 fail:
28122 {
28123 if (temp1)
28124 delete arg1;
28125 }
28126 return NULL;
28127 }
28128
28129
28130 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28131 PyObject *resultobj;
28132 wxCustomDataObject *result;
28133
28134 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28135 {
28136 PyThreadState* __tstate = wxPyBeginAllowThreads();
28137 result = (wxCustomDataObject *)new wxCustomDataObject();
28138
28139 wxPyEndAllowThreads(__tstate);
28140 if (PyErr_Occurred()) SWIG_fail;
28141 }
28142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28143 return resultobj;
28144 fail:
28145 return NULL;
28146 }
28147
28148
28149 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28150 int argc;
28151 PyObject *argv[2];
28152 int ii;
28153
28154 argc = PyObject_Length(args);
28155 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28156 argv[ii] = PyTuple_GetItem(args,ii);
28157 }
28158 if (argc == 0) {
28159 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28160 }
28161 if (argc == 1) {
28162 int _v;
28163 {
28164 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28165 }
28166 if (_v) {
28167 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28168 }
28169 }
28170 if (argc == 1) {
28171 int _v;
28172 {
28173 void *ptr = 0;
28174 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28175 _v = 0;
28176 PyErr_Clear();
28177 } else {
28178 _v = (ptr != 0);
28179 }
28180 }
28181 if (_v) {
28182 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28183 }
28184 }
28185
28186 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28187 return NULL;
28188 }
28189
28190
28191 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28192 PyObject *resultobj;
28193 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28194 PyObject *arg2 = (PyObject *) 0 ;
28195 bool result;
28196 PyObject * obj0 = 0 ;
28197 PyObject * obj1 = 0 ;
28198 char *kwnames[] = {
28199 (char *) "self",(char *) "data", NULL
28200 };
28201
28202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28204 if (SWIG_arg_fail(1)) SWIG_fail;
28205 arg2 = obj1;
28206 {
28207 PyThreadState* __tstate = wxPyBeginAllowThreads();
28208 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28209
28210 wxPyEndAllowThreads(__tstate);
28211 if (PyErr_Occurred()) SWIG_fail;
28212 }
28213 {
28214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28215 }
28216 return resultobj;
28217 fail:
28218 return NULL;
28219 }
28220
28221
28222 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28223 PyObject *resultobj;
28224 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28225 size_t result;
28226 PyObject * obj0 = 0 ;
28227 char *kwnames[] = {
28228 (char *) "self", NULL
28229 };
28230
28231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28233 if (SWIG_arg_fail(1)) SWIG_fail;
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (size_t)(arg1)->GetSize();
28237
28238 wxPyEndAllowThreads(__tstate);
28239 if (PyErr_Occurred()) SWIG_fail;
28240 }
28241 {
28242 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28243 }
28244 return resultobj;
28245 fail:
28246 return NULL;
28247 }
28248
28249
28250 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28251 PyObject *resultobj;
28252 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28253 PyObject *result;
28254 PyObject * obj0 = 0 ;
28255 char *kwnames[] = {
28256 (char *) "self", NULL
28257 };
28258
28259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28261 if (SWIG_arg_fail(1)) SWIG_fail;
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28265
28266 wxPyEndAllowThreads(__tstate);
28267 if (PyErr_Occurred()) SWIG_fail;
28268 }
28269 resultobj = result;
28270 return resultobj;
28271 fail:
28272 return NULL;
28273 }
28274
28275
28276 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28277 PyObject *obj;
28278 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28279 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28280 Py_INCREF(obj);
28281 return Py_BuildValue((char *)"");
28282 }
28283 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28284 PyObject *resultobj;
28285 wxURLDataObject *result;
28286 char *kwnames[] = {
28287 NULL
28288 };
28289
28290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 result = (wxURLDataObject *)new wxURLDataObject();
28294
28295 wxPyEndAllowThreads(__tstate);
28296 if (PyErr_Occurred()) SWIG_fail;
28297 }
28298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28299 return resultobj;
28300 fail:
28301 return NULL;
28302 }
28303
28304
28305 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28306 PyObject *resultobj;
28307 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28308 wxString result;
28309 PyObject * obj0 = 0 ;
28310 char *kwnames[] = {
28311 (char *) "self", NULL
28312 };
28313
28314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28316 if (SWIG_arg_fail(1)) SWIG_fail;
28317 {
28318 PyThreadState* __tstate = wxPyBeginAllowThreads();
28319 result = (arg1)->GetURL();
28320
28321 wxPyEndAllowThreads(__tstate);
28322 if (PyErr_Occurred()) SWIG_fail;
28323 }
28324 {
28325 #if wxUSE_UNICODE
28326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28327 #else
28328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28329 #endif
28330 }
28331 return resultobj;
28332 fail:
28333 return NULL;
28334 }
28335
28336
28337 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28338 PyObject *resultobj;
28339 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28340 wxString *arg2 = 0 ;
28341 bool temp2 = false ;
28342 PyObject * obj0 = 0 ;
28343 PyObject * obj1 = 0 ;
28344 char *kwnames[] = {
28345 (char *) "self",(char *) "url", NULL
28346 };
28347
28348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28350 if (SWIG_arg_fail(1)) SWIG_fail;
28351 {
28352 arg2 = wxString_in_helper(obj1);
28353 if (arg2 == NULL) SWIG_fail;
28354 temp2 = true;
28355 }
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 (arg1)->SetURL((wxString const &)*arg2);
28359
28360 wxPyEndAllowThreads(__tstate);
28361 if (PyErr_Occurred()) SWIG_fail;
28362 }
28363 Py_INCREF(Py_None); resultobj = Py_None;
28364 {
28365 if (temp2)
28366 delete arg2;
28367 }
28368 return resultobj;
28369 fail:
28370 {
28371 if (temp2)
28372 delete arg2;
28373 }
28374 return NULL;
28375 }
28376
28377
28378 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28379 PyObject *obj;
28380 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28381 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28382 Py_INCREF(obj);
28383 return Py_BuildValue((char *)"");
28384 }
28385 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28386 PyObject *resultobj;
28387 wxMetafileDataObject *result;
28388 char *kwnames[] = {
28389 NULL
28390 };
28391
28392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28396
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28401 return resultobj;
28402 fail:
28403 return NULL;
28404 }
28405
28406
28407 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28408 PyObject *obj;
28409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28410 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28411 Py_INCREF(obj);
28412 return Py_BuildValue((char *)"");
28413 }
28414 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28415 PyObject *resultobj;
28416 wxDragResult arg1 ;
28417 bool result;
28418 PyObject * obj0 = 0 ;
28419 char *kwnames[] = {
28420 (char *) "res", NULL
28421 };
28422
28423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28424 {
28425 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28426 if (SWIG_arg_fail(1)) SWIG_fail;
28427 }
28428 {
28429 PyThreadState* __tstate = wxPyBeginAllowThreads();
28430 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28431
28432 wxPyEndAllowThreads(__tstate);
28433 if (PyErr_Occurred()) SWIG_fail;
28434 }
28435 {
28436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28437 }
28438 return resultobj;
28439 fail:
28440 return NULL;
28441 }
28442
28443
28444 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28445 PyObject *resultobj;
28446 wxWindow *arg1 = (wxWindow *) 0 ;
28447 wxIcon const &arg2_defvalue = wxNullIcon ;
28448 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28449 wxIcon const &arg3_defvalue = wxNullIcon ;
28450 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28451 wxIcon const &arg4_defvalue = wxNullIcon ;
28452 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28453 wxPyDropSource *result;
28454 PyObject * obj0 = 0 ;
28455 PyObject * obj1 = 0 ;
28456 PyObject * obj2 = 0 ;
28457 PyObject * obj3 = 0 ;
28458 char *kwnames[] = {
28459 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28460 };
28461
28462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28464 if (SWIG_arg_fail(1)) SWIG_fail;
28465 if (obj1) {
28466 {
28467 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28468 if (SWIG_arg_fail(2)) SWIG_fail;
28469 if (arg2 == NULL) {
28470 SWIG_null_ref("wxIcon");
28471 }
28472 if (SWIG_arg_fail(2)) SWIG_fail;
28473 }
28474 }
28475 if (obj2) {
28476 {
28477 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28478 if (SWIG_arg_fail(3)) SWIG_fail;
28479 if (arg3 == NULL) {
28480 SWIG_null_ref("wxIcon");
28481 }
28482 if (SWIG_arg_fail(3)) SWIG_fail;
28483 }
28484 }
28485 if (obj3) {
28486 {
28487 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28488 if (SWIG_arg_fail(4)) SWIG_fail;
28489 if (arg4 == NULL) {
28490 SWIG_null_ref("wxIcon");
28491 }
28492 if (SWIG_arg_fail(4)) SWIG_fail;
28493 }
28494 }
28495 {
28496 PyThreadState* __tstate = wxPyBeginAllowThreads();
28497 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28498
28499 wxPyEndAllowThreads(__tstate);
28500 if (PyErr_Occurred()) SWIG_fail;
28501 }
28502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28503 return resultobj;
28504 fail:
28505 return NULL;
28506 }
28507
28508
28509 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28510 PyObject *resultobj;
28511 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28512 PyObject *arg2 = (PyObject *) 0 ;
28513 PyObject *arg3 = (PyObject *) 0 ;
28514 int arg4 ;
28515 PyObject * obj0 = 0 ;
28516 PyObject * obj1 = 0 ;
28517 PyObject * obj2 = 0 ;
28518 PyObject * obj3 = 0 ;
28519 char *kwnames[] = {
28520 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28521 };
28522
28523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28525 if (SWIG_arg_fail(1)) SWIG_fail;
28526 arg2 = obj1;
28527 arg3 = obj2;
28528 {
28529 arg4 = (int)(SWIG_As_int(obj3));
28530 if (SWIG_arg_fail(4)) SWIG_fail;
28531 }
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28535
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 Py_INCREF(Py_None); resultobj = Py_None;
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj;
28548 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28549 PyObject * obj0 = 0 ;
28550 char *kwnames[] = {
28551 (char *) "self", NULL
28552 };
28553
28554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28556 if (SWIG_arg_fail(1)) SWIG_fail;
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 delete arg1;
28560
28561 wxPyEndAllowThreads(__tstate);
28562 if (PyErr_Occurred()) SWIG_fail;
28563 }
28564 Py_INCREF(Py_None); resultobj = Py_None;
28565 return resultobj;
28566 fail:
28567 return NULL;
28568 }
28569
28570
28571 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28572 PyObject *resultobj;
28573 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28574 wxDataObject *arg2 = 0 ;
28575 PyObject * obj0 = 0 ;
28576 PyObject * obj1 = 0 ;
28577 char *kwnames[] = {
28578 (char *) "self",(char *) "data", NULL
28579 };
28580
28581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28583 if (SWIG_arg_fail(1)) SWIG_fail;
28584 {
28585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28586 if (SWIG_arg_fail(2)) SWIG_fail;
28587 if (arg2 == NULL) {
28588 SWIG_null_ref("wxDataObject");
28589 }
28590 if (SWIG_arg_fail(2)) SWIG_fail;
28591 }
28592 {
28593 PyThreadState* __tstate = wxPyBeginAllowThreads();
28594 (arg1)->SetData(*arg2);
28595
28596 wxPyEndAllowThreads(__tstate);
28597 if (PyErr_Occurred()) SWIG_fail;
28598 }
28599 Py_INCREF(Py_None); resultobj = Py_None;
28600 return resultobj;
28601 fail:
28602 return NULL;
28603 }
28604
28605
28606 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28607 PyObject *resultobj;
28608 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28609 wxDataObject *result;
28610 PyObject * obj0 = 0 ;
28611 char *kwnames[] = {
28612 (char *) "self", NULL
28613 };
28614
28615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28617 if (SWIG_arg_fail(1)) SWIG_fail;
28618 {
28619 PyThreadState* __tstate = wxPyBeginAllowThreads();
28620 result = (wxDataObject *)(arg1)->GetDataObject();
28621
28622 wxPyEndAllowThreads(__tstate);
28623 if (PyErr_Occurred()) SWIG_fail;
28624 }
28625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28626 return resultobj;
28627 fail:
28628 return NULL;
28629 }
28630
28631
28632 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28633 PyObject *resultobj;
28634 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28635 wxDragResult arg2 ;
28636 wxCursor *arg3 = 0 ;
28637 PyObject * obj0 = 0 ;
28638 PyObject * obj1 = 0 ;
28639 PyObject * obj2 = 0 ;
28640 char *kwnames[] = {
28641 (char *) "self",(char *) "res",(char *) "cursor", NULL
28642 };
28643
28644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28646 if (SWIG_arg_fail(1)) SWIG_fail;
28647 {
28648 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28649 if (SWIG_arg_fail(2)) SWIG_fail;
28650 }
28651 {
28652 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28653 if (SWIG_arg_fail(3)) SWIG_fail;
28654 if (arg3 == NULL) {
28655 SWIG_null_ref("wxCursor");
28656 }
28657 if (SWIG_arg_fail(3)) SWIG_fail;
28658 }
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28662
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 Py_INCREF(Py_None); resultobj = Py_None;
28667 return resultobj;
28668 fail:
28669 return NULL;
28670 }
28671
28672
28673 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28674 PyObject *resultobj;
28675 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28676 int arg2 = (int) wxDrag_CopyOnly ;
28677 wxDragResult result;
28678 PyObject * obj0 = 0 ;
28679 PyObject * obj1 = 0 ;
28680 char *kwnames[] = {
28681 (char *) "self",(char *) "flags", NULL
28682 };
28683
28684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28686 if (SWIG_arg_fail(1)) SWIG_fail;
28687 if (obj1) {
28688 {
28689 arg2 = (int)(SWIG_As_int(obj1));
28690 if (SWIG_arg_fail(2)) SWIG_fail;
28691 }
28692 }
28693 {
28694 PyThreadState* __tstate = wxPyBeginAllowThreads();
28695 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28696
28697 wxPyEndAllowThreads(__tstate);
28698 if (PyErr_Occurred()) SWIG_fail;
28699 }
28700 resultobj = SWIG_From_int((result));
28701 return resultobj;
28702 fail:
28703 return NULL;
28704 }
28705
28706
28707 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28708 PyObject *resultobj;
28709 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28710 wxDragResult arg2 ;
28711 bool result;
28712 PyObject * obj0 = 0 ;
28713 PyObject * obj1 = 0 ;
28714 char *kwnames[] = {
28715 (char *) "self",(char *) "effect", NULL
28716 };
28717
28718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28720 if (SWIG_arg_fail(1)) SWIG_fail;
28721 {
28722 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28723 if (SWIG_arg_fail(2)) SWIG_fail;
28724 }
28725 {
28726 PyThreadState* __tstate = wxPyBeginAllowThreads();
28727 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28728
28729 wxPyEndAllowThreads(__tstate);
28730 if (PyErr_Occurred()) SWIG_fail;
28731 }
28732 {
28733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28734 }
28735 return resultobj;
28736 fail:
28737 return NULL;
28738 }
28739
28740
28741 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28742 PyObject *obj;
28743 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28744 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28745 Py_INCREF(obj);
28746 return Py_BuildValue((char *)"");
28747 }
28748 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28749 PyObject *resultobj;
28750 wxDataObject *arg1 = (wxDataObject *) NULL ;
28751 wxPyDropTarget *result;
28752 PyObject * obj0 = 0 ;
28753 char *kwnames[] = {
28754 (char *) "dataObject", NULL
28755 };
28756
28757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28758 if (obj0) {
28759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28760 if (SWIG_arg_fail(1)) SWIG_fail;
28761 }
28762 {
28763 PyThreadState* __tstate = wxPyBeginAllowThreads();
28764 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28765
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28770 return resultobj;
28771 fail:
28772 return NULL;
28773 }
28774
28775
28776 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28777 PyObject *resultobj;
28778 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28779 PyObject *arg2 = (PyObject *) 0 ;
28780 PyObject *arg3 = (PyObject *) 0 ;
28781 PyObject * obj0 = 0 ;
28782 PyObject * obj1 = 0 ;
28783 PyObject * obj2 = 0 ;
28784 char *kwnames[] = {
28785 (char *) "self",(char *) "self",(char *) "_class", NULL
28786 };
28787
28788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28790 if (SWIG_arg_fail(1)) SWIG_fail;
28791 arg2 = obj1;
28792 arg3 = obj2;
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 (arg1)->_setCallbackInfo(arg2,arg3);
28796
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 Py_INCREF(Py_None); resultobj = Py_None;
28801 return resultobj;
28802 fail:
28803 return NULL;
28804 }
28805
28806
28807 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28808 PyObject *resultobj;
28809 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28810 PyObject * obj0 = 0 ;
28811 char *kwnames[] = {
28812 (char *) "self", NULL
28813 };
28814
28815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28817 if (SWIG_arg_fail(1)) SWIG_fail;
28818 {
28819 PyThreadState* __tstate = wxPyBeginAllowThreads();
28820 delete arg1;
28821
28822 wxPyEndAllowThreads(__tstate);
28823 if (PyErr_Occurred()) SWIG_fail;
28824 }
28825 Py_INCREF(Py_None); resultobj = Py_None;
28826 return resultobj;
28827 fail:
28828 return NULL;
28829 }
28830
28831
28832 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28833 PyObject *resultobj;
28834 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28835 wxDataObject *result;
28836 PyObject * obj0 = 0 ;
28837 char *kwnames[] = {
28838 (char *) "self", NULL
28839 };
28840
28841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28843 if (SWIG_arg_fail(1)) SWIG_fail;
28844 {
28845 PyThreadState* __tstate = wxPyBeginAllowThreads();
28846 result = (wxDataObject *)(arg1)->GetDataObject();
28847
28848 wxPyEndAllowThreads(__tstate);
28849 if (PyErr_Occurred()) SWIG_fail;
28850 }
28851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28852 return resultobj;
28853 fail:
28854 return NULL;
28855 }
28856
28857
28858 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28859 PyObject *resultobj;
28860 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28861 wxDataObject *arg2 = (wxDataObject *) 0 ;
28862 PyObject * obj0 = 0 ;
28863 PyObject * obj1 = 0 ;
28864 char *kwnames[] = {
28865 (char *) "self",(char *) "dataObject", NULL
28866 };
28867
28868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28870 if (SWIG_arg_fail(1)) SWIG_fail;
28871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28872 if (SWIG_arg_fail(2)) SWIG_fail;
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 (arg1)->SetDataObject(arg2);
28876
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 Py_INCREF(Py_None); resultobj = Py_None;
28881 return resultobj;
28882 fail:
28883 return NULL;
28884 }
28885
28886
28887 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28888 PyObject *resultobj;
28889 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28890 int arg2 ;
28891 int arg3 ;
28892 wxDragResult arg4 ;
28893 wxDragResult result;
28894 PyObject * obj0 = 0 ;
28895 PyObject * obj1 = 0 ;
28896 PyObject * obj2 = 0 ;
28897 PyObject * obj3 = 0 ;
28898 char *kwnames[] = {
28899 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28900 };
28901
28902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28904 if (SWIG_arg_fail(1)) SWIG_fail;
28905 {
28906 arg2 = (int)(SWIG_As_int(obj1));
28907 if (SWIG_arg_fail(2)) SWIG_fail;
28908 }
28909 {
28910 arg3 = (int)(SWIG_As_int(obj2));
28911 if (SWIG_arg_fail(3)) SWIG_fail;
28912 }
28913 {
28914 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28915 if (SWIG_arg_fail(4)) SWIG_fail;
28916 }
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28920
28921 wxPyEndAllowThreads(__tstate);
28922 if (PyErr_Occurred()) SWIG_fail;
28923 }
28924 resultobj = SWIG_From_int((result));
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28932 PyObject *resultobj;
28933 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28934 int arg2 ;
28935 int arg3 ;
28936 wxDragResult arg4 ;
28937 wxDragResult result;
28938 PyObject * obj0 = 0 ;
28939 PyObject * obj1 = 0 ;
28940 PyObject * obj2 = 0 ;
28941 PyObject * obj3 = 0 ;
28942 char *kwnames[] = {
28943 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28944 };
28945
28946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28948 if (SWIG_arg_fail(1)) SWIG_fail;
28949 {
28950 arg2 = (int)(SWIG_As_int(obj1));
28951 if (SWIG_arg_fail(2)) SWIG_fail;
28952 }
28953 {
28954 arg3 = (int)(SWIG_As_int(obj2));
28955 if (SWIG_arg_fail(3)) SWIG_fail;
28956 }
28957 {
28958 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28959 if (SWIG_arg_fail(4)) SWIG_fail;
28960 }
28961 {
28962 PyThreadState* __tstate = wxPyBeginAllowThreads();
28963 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28964
28965 wxPyEndAllowThreads(__tstate);
28966 if (PyErr_Occurred()) SWIG_fail;
28967 }
28968 resultobj = SWIG_From_int((result));
28969 return resultobj;
28970 fail:
28971 return NULL;
28972 }
28973
28974
28975 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28976 PyObject *resultobj;
28977 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28978 PyObject * obj0 = 0 ;
28979 char *kwnames[] = {
28980 (char *) "self", NULL
28981 };
28982
28983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",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 (arg1)->base_OnLeave();
28989
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 Py_INCREF(Py_None); resultobj = Py_None;
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29001 PyObject *resultobj;
29002 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29003 int arg2 ;
29004 int arg3 ;
29005 bool result;
29006 PyObject * obj0 = 0 ;
29007 PyObject * obj1 = 0 ;
29008 PyObject * obj2 = 0 ;
29009 char *kwnames[] = {
29010 (char *) "self",(char *) "x",(char *) "y", NULL
29011 };
29012
29013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29015 if (SWIG_arg_fail(1)) SWIG_fail;
29016 {
29017 arg2 = (int)(SWIG_As_int(obj1));
29018 if (SWIG_arg_fail(2)) SWIG_fail;
29019 }
29020 {
29021 arg3 = (int)(SWIG_As_int(obj2));
29022 if (SWIG_arg_fail(3)) SWIG_fail;
29023 }
29024 {
29025 PyThreadState* __tstate = wxPyBeginAllowThreads();
29026 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29027
29028 wxPyEndAllowThreads(__tstate);
29029 if (PyErr_Occurred()) SWIG_fail;
29030 }
29031 {
29032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29033 }
29034 return resultobj;
29035 fail:
29036 return NULL;
29037 }
29038
29039
29040 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29041 PyObject *resultobj;
29042 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29043 bool result;
29044 PyObject * obj0 = 0 ;
29045 char *kwnames[] = {
29046 (char *) "self", NULL
29047 };
29048
29049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29051 if (SWIG_arg_fail(1)) SWIG_fail;
29052 {
29053 PyThreadState* __tstate = wxPyBeginAllowThreads();
29054 result = (bool)(arg1)->GetData();
29055
29056 wxPyEndAllowThreads(__tstate);
29057 if (PyErr_Occurred()) SWIG_fail;
29058 }
29059 {
29060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29061 }
29062 return resultobj;
29063 fail:
29064 return NULL;
29065 }
29066
29067
29068 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29069 PyObject *obj;
29070 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29071 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29072 Py_INCREF(obj);
29073 return Py_BuildValue((char *)"");
29074 }
29075 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29076 PyObject *resultobj;
29077 wxPyTextDropTarget *result;
29078 char *kwnames[] = {
29079 NULL
29080 };
29081
29082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29083 {
29084 PyThreadState* __tstate = wxPyBeginAllowThreads();
29085 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29086
29087 wxPyEndAllowThreads(__tstate);
29088 if (PyErr_Occurred()) SWIG_fail;
29089 }
29090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29091 return resultobj;
29092 fail:
29093 return NULL;
29094 }
29095
29096
29097 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29098 PyObject *resultobj;
29099 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29100 PyObject *arg2 = (PyObject *) 0 ;
29101 PyObject *arg3 = (PyObject *) 0 ;
29102 PyObject * obj0 = 0 ;
29103 PyObject * obj1 = 0 ;
29104 PyObject * obj2 = 0 ;
29105 char *kwnames[] = {
29106 (char *) "self",(char *) "self",(char *) "_class", NULL
29107 };
29108
29109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29111 if (SWIG_arg_fail(1)) SWIG_fail;
29112 arg2 = obj1;
29113 arg3 = obj2;
29114 {
29115 PyThreadState* __tstate = wxPyBeginAllowThreads();
29116 (arg1)->_setCallbackInfo(arg2,arg3);
29117
29118 wxPyEndAllowThreads(__tstate);
29119 if (PyErr_Occurred()) SWIG_fail;
29120 }
29121 Py_INCREF(Py_None); resultobj = Py_None;
29122 return resultobj;
29123 fail:
29124 return NULL;
29125 }
29126
29127
29128 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29129 PyObject *resultobj;
29130 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29131 int arg2 ;
29132 int arg3 ;
29133 wxDragResult arg4 ;
29134 wxDragResult result;
29135 PyObject * obj0 = 0 ;
29136 PyObject * obj1 = 0 ;
29137 PyObject * obj2 = 0 ;
29138 PyObject * obj3 = 0 ;
29139 char *kwnames[] = {
29140 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29141 };
29142
29143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29145 if (SWIG_arg_fail(1)) SWIG_fail;
29146 {
29147 arg2 = (int)(SWIG_As_int(obj1));
29148 if (SWIG_arg_fail(2)) SWIG_fail;
29149 }
29150 {
29151 arg3 = (int)(SWIG_As_int(obj2));
29152 if (SWIG_arg_fail(3)) SWIG_fail;
29153 }
29154 {
29155 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29156 if (SWIG_arg_fail(4)) SWIG_fail;
29157 }
29158 {
29159 PyThreadState* __tstate = wxPyBeginAllowThreads();
29160 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29161
29162 wxPyEndAllowThreads(__tstate);
29163 if (PyErr_Occurred()) SWIG_fail;
29164 }
29165 resultobj = SWIG_From_int((result));
29166 return resultobj;
29167 fail:
29168 return NULL;
29169 }
29170
29171
29172 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29173 PyObject *resultobj;
29174 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29175 int arg2 ;
29176 int arg3 ;
29177 wxDragResult arg4 ;
29178 wxDragResult result;
29179 PyObject * obj0 = 0 ;
29180 PyObject * obj1 = 0 ;
29181 PyObject * obj2 = 0 ;
29182 PyObject * obj3 = 0 ;
29183 char *kwnames[] = {
29184 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29185 };
29186
29187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29189 if (SWIG_arg_fail(1)) SWIG_fail;
29190 {
29191 arg2 = (int)(SWIG_As_int(obj1));
29192 if (SWIG_arg_fail(2)) SWIG_fail;
29193 }
29194 {
29195 arg3 = (int)(SWIG_As_int(obj2));
29196 if (SWIG_arg_fail(3)) SWIG_fail;
29197 }
29198 {
29199 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29200 if (SWIG_arg_fail(4)) SWIG_fail;
29201 }
29202 {
29203 PyThreadState* __tstate = wxPyBeginAllowThreads();
29204 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29205
29206 wxPyEndAllowThreads(__tstate);
29207 if (PyErr_Occurred()) SWIG_fail;
29208 }
29209 resultobj = SWIG_From_int((result));
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj;
29218 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29219 PyObject * obj0 = 0 ;
29220 char *kwnames[] = {
29221 (char *) "self", NULL
29222 };
29223
29224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29226 if (SWIG_arg_fail(1)) SWIG_fail;
29227 {
29228 PyThreadState* __tstate = wxPyBeginAllowThreads();
29229 (arg1)->base_OnLeave();
29230
29231 wxPyEndAllowThreads(__tstate);
29232 if (PyErr_Occurred()) SWIG_fail;
29233 }
29234 Py_INCREF(Py_None); resultobj = Py_None;
29235 return resultobj;
29236 fail:
29237 return NULL;
29238 }
29239
29240
29241 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29242 PyObject *resultobj;
29243 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29244 int arg2 ;
29245 int arg3 ;
29246 bool result;
29247 PyObject * obj0 = 0 ;
29248 PyObject * obj1 = 0 ;
29249 PyObject * obj2 = 0 ;
29250 char *kwnames[] = {
29251 (char *) "self",(char *) "x",(char *) "y", NULL
29252 };
29253
29254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29256 if (SWIG_arg_fail(1)) SWIG_fail;
29257 {
29258 arg2 = (int)(SWIG_As_int(obj1));
29259 if (SWIG_arg_fail(2)) SWIG_fail;
29260 }
29261 {
29262 arg3 = (int)(SWIG_As_int(obj2));
29263 if (SWIG_arg_fail(3)) SWIG_fail;
29264 }
29265 {
29266 PyThreadState* __tstate = wxPyBeginAllowThreads();
29267 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29268
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 {
29273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29274 }
29275 return resultobj;
29276 fail:
29277 return NULL;
29278 }
29279
29280
29281 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29282 PyObject *resultobj;
29283 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29284 int arg2 ;
29285 int arg3 ;
29286 wxDragResult arg4 ;
29287 wxDragResult result;
29288 PyObject * obj0 = 0 ;
29289 PyObject * obj1 = 0 ;
29290 PyObject * obj2 = 0 ;
29291 PyObject * obj3 = 0 ;
29292 char *kwnames[] = {
29293 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29294 };
29295
29296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29298 if (SWIG_arg_fail(1)) SWIG_fail;
29299 {
29300 arg2 = (int)(SWIG_As_int(obj1));
29301 if (SWIG_arg_fail(2)) SWIG_fail;
29302 }
29303 {
29304 arg3 = (int)(SWIG_As_int(obj2));
29305 if (SWIG_arg_fail(3)) SWIG_fail;
29306 }
29307 {
29308 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29309 if (SWIG_arg_fail(4)) SWIG_fail;
29310 }
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29314
29315 wxPyEndAllowThreads(__tstate);
29316 if (PyErr_Occurred()) SWIG_fail;
29317 }
29318 resultobj = SWIG_From_int((result));
29319 return resultobj;
29320 fail:
29321 return NULL;
29322 }
29323
29324
29325 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29326 PyObject *obj;
29327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29328 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29329 Py_INCREF(obj);
29330 return Py_BuildValue((char *)"");
29331 }
29332 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29333 PyObject *resultobj;
29334 wxPyFileDropTarget *result;
29335 char *kwnames[] = {
29336 NULL
29337 };
29338
29339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29340 {
29341 PyThreadState* __tstate = wxPyBeginAllowThreads();
29342 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29343
29344 wxPyEndAllowThreads(__tstate);
29345 if (PyErr_Occurred()) SWIG_fail;
29346 }
29347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29348 return resultobj;
29349 fail:
29350 return NULL;
29351 }
29352
29353
29354 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29355 PyObject *resultobj;
29356 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29357 PyObject *arg2 = (PyObject *) 0 ;
29358 PyObject *arg3 = (PyObject *) 0 ;
29359 PyObject * obj0 = 0 ;
29360 PyObject * obj1 = 0 ;
29361 PyObject * obj2 = 0 ;
29362 char *kwnames[] = {
29363 (char *) "self",(char *) "self",(char *) "_class", NULL
29364 };
29365
29366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29368 if (SWIG_arg_fail(1)) SWIG_fail;
29369 arg2 = obj1;
29370 arg3 = obj2;
29371 {
29372 PyThreadState* __tstate = wxPyBeginAllowThreads();
29373 (arg1)->_setCallbackInfo(arg2,arg3);
29374
29375 wxPyEndAllowThreads(__tstate);
29376 if (PyErr_Occurred()) SWIG_fail;
29377 }
29378 Py_INCREF(Py_None); resultobj = Py_None;
29379 return resultobj;
29380 fail:
29381 return NULL;
29382 }
29383
29384
29385 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29386 PyObject *resultobj;
29387 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29388 int arg2 ;
29389 int arg3 ;
29390 wxDragResult arg4 ;
29391 wxDragResult result;
29392 PyObject * obj0 = 0 ;
29393 PyObject * obj1 = 0 ;
29394 PyObject * obj2 = 0 ;
29395 PyObject * obj3 = 0 ;
29396 char *kwnames[] = {
29397 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29398 };
29399
29400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29402 if (SWIG_arg_fail(1)) SWIG_fail;
29403 {
29404 arg2 = (int)(SWIG_As_int(obj1));
29405 if (SWIG_arg_fail(2)) SWIG_fail;
29406 }
29407 {
29408 arg3 = (int)(SWIG_As_int(obj2));
29409 if (SWIG_arg_fail(3)) SWIG_fail;
29410 }
29411 {
29412 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29413 if (SWIG_arg_fail(4)) SWIG_fail;
29414 }
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29418
29419 wxPyEndAllowThreads(__tstate);
29420 if (PyErr_Occurred()) SWIG_fail;
29421 }
29422 resultobj = SWIG_From_int((result));
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29430 PyObject *resultobj;
29431 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29432 int arg2 ;
29433 int arg3 ;
29434 wxDragResult arg4 ;
29435 wxDragResult result;
29436 PyObject * obj0 = 0 ;
29437 PyObject * obj1 = 0 ;
29438 PyObject * obj2 = 0 ;
29439 PyObject * obj3 = 0 ;
29440 char *kwnames[] = {
29441 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29442 };
29443
29444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29446 if (SWIG_arg_fail(1)) SWIG_fail;
29447 {
29448 arg2 = (int)(SWIG_As_int(obj1));
29449 if (SWIG_arg_fail(2)) SWIG_fail;
29450 }
29451 {
29452 arg3 = (int)(SWIG_As_int(obj2));
29453 if (SWIG_arg_fail(3)) SWIG_fail;
29454 }
29455 {
29456 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29457 if (SWIG_arg_fail(4)) SWIG_fail;
29458 }
29459 {
29460 PyThreadState* __tstate = wxPyBeginAllowThreads();
29461 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29462
29463 wxPyEndAllowThreads(__tstate);
29464 if (PyErr_Occurred()) SWIG_fail;
29465 }
29466 resultobj = SWIG_From_int((result));
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29474 PyObject *resultobj;
29475 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29476 PyObject * obj0 = 0 ;
29477 char *kwnames[] = {
29478 (char *) "self", NULL
29479 };
29480
29481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29483 if (SWIG_arg_fail(1)) SWIG_fail;
29484 {
29485 PyThreadState* __tstate = wxPyBeginAllowThreads();
29486 (arg1)->base_OnLeave();
29487
29488 wxPyEndAllowThreads(__tstate);
29489 if (PyErr_Occurred()) SWIG_fail;
29490 }
29491 Py_INCREF(Py_None); resultobj = Py_None;
29492 return resultobj;
29493 fail:
29494 return NULL;
29495 }
29496
29497
29498 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29499 PyObject *resultobj;
29500 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29501 int arg2 ;
29502 int arg3 ;
29503 bool result;
29504 PyObject * obj0 = 0 ;
29505 PyObject * obj1 = 0 ;
29506 PyObject * obj2 = 0 ;
29507 char *kwnames[] = {
29508 (char *) "self",(char *) "x",(char *) "y", NULL
29509 };
29510
29511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29513 if (SWIG_arg_fail(1)) SWIG_fail;
29514 {
29515 arg2 = (int)(SWIG_As_int(obj1));
29516 if (SWIG_arg_fail(2)) SWIG_fail;
29517 }
29518 {
29519 arg3 = (int)(SWIG_As_int(obj2));
29520 if (SWIG_arg_fail(3)) SWIG_fail;
29521 }
29522 {
29523 PyThreadState* __tstate = wxPyBeginAllowThreads();
29524 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29525
29526 wxPyEndAllowThreads(__tstate);
29527 if (PyErr_Occurred()) SWIG_fail;
29528 }
29529 {
29530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29531 }
29532 return resultobj;
29533 fail:
29534 return NULL;
29535 }
29536
29537
29538 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29539 PyObject *resultobj;
29540 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29541 int arg2 ;
29542 int arg3 ;
29543 wxDragResult arg4 ;
29544 wxDragResult result;
29545 PyObject * obj0 = 0 ;
29546 PyObject * obj1 = 0 ;
29547 PyObject * obj2 = 0 ;
29548 PyObject * obj3 = 0 ;
29549 char *kwnames[] = {
29550 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29551 };
29552
29553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29555 if (SWIG_arg_fail(1)) SWIG_fail;
29556 {
29557 arg2 = (int)(SWIG_As_int(obj1));
29558 if (SWIG_arg_fail(2)) SWIG_fail;
29559 }
29560 {
29561 arg3 = (int)(SWIG_As_int(obj2));
29562 if (SWIG_arg_fail(3)) SWIG_fail;
29563 }
29564 {
29565 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29566 if (SWIG_arg_fail(4)) SWIG_fail;
29567 }
29568 {
29569 PyThreadState* __tstate = wxPyBeginAllowThreads();
29570 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29571
29572 wxPyEndAllowThreads(__tstate);
29573 if (PyErr_Occurred()) SWIG_fail;
29574 }
29575 resultobj = SWIG_From_int((result));
29576 return resultobj;
29577 fail:
29578 return NULL;
29579 }
29580
29581
29582 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29583 PyObject *obj;
29584 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29585 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29586 Py_INCREF(obj);
29587 return Py_BuildValue((char *)"");
29588 }
29589 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29590 PyObject *resultobj;
29591 wxClipboard *result;
29592 char *kwnames[] = {
29593 NULL
29594 };
29595
29596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29597 {
29598 PyThreadState* __tstate = wxPyBeginAllowThreads();
29599 result = (wxClipboard *)new wxClipboard();
29600
29601 wxPyEndAllowThreads(__tstate);
29602 if (PyErr_Occurred()) SWIG_fail;
29603 }
29604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29605 return resultobj;
29606 fail:
29607 return NULL;
29608 }
29609
29610
29611 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29612 PyObject *resultobj;
29613 wxClipboard *arg1 = (wxClipboard *) 0 ;
29614 PyObject * obj0 = 0 ;
29615 char *kwnames[] = {
29616 (char *) "self", NULL
29617 };
29618
29619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29621 if (SWIG_arg_fail(1)) SWIG_fail;
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 delete arg1;
29625
29626 wxPyEndAllowThreads(__tstate);
29627 if (PyErr_Occurred()) SWIG_fail;
29628 }
29629 Py_INCREF(Py_None); resultobj = Py_None;
29630 return resultobj;
29631 fail:
29632 return NULL;
29633 }
29634
29635
29636 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29637 PyObject *resultobj;
29638 wxClipboard *arg1 = (wxClipboard *) 0 ;
29639 bool result;
29640 PyObject * obj0 = 0 ;
29641 char *kwnames[] = {
29642 (char *) "self", NULL
29643 };
29644
29645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29647 if (SWIG_arg_fail(1)) SWIG_fail;
29648 {
29649 PyThreadState* __tstate = wxPyBeginAllowThreads();
29650 result = (bool)(arg1)->Open();
29651
29652 wxPyEndAllowThreads(__tstate);
29653 if (PyErr_Occurred()) SWIG_fail;
29654 }
29655 {
29656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29657 }
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29665 PyObject *resultobj;
29666 wxClipboard *arg1 = (wxClipboard *) 0 ;
29667 PyObject * obj0 = 0 ;
29668 char *kwnames[] = {
29669 (char *) "self", NULL
29670 };
29671
29672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29674 if (SWIG_arg_fail(1)) SWIG_fail;
29675 {
29676 PyThreadState* __tstate = wxPyBeginAllowThreads();
29677 (arg1)->Close();
29678
29679 wxPyEndAllowThreads(__tstate);
29680 if (PyErr_Occurred()) SWIG_fail;
29681 }
29682 Py_INCREF(Py_None); resultobj = Py_None;
29683 return resultobj;
29684 fail:
29685 return NULL;
29686 }
29687
29688
29689 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29690 PyObject *resultobj;
29691 wxClipboard *arg1 = (wxClipboard *) 0 ;
29692 bool result;
29693 PyObject * obj0 = 0 ;
29694 char *kwnames[] = {
29695 (char *) "self", NULL
29696 };
29697
29698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29700 if (SWIG_arg_fail(1)) SWIG_fail;
29701 {
29702 PyThreadState* __tstate = wxPyBeginAllowThreads();
29703 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29704
29705 wxPyEndAllowThreads(__tstate);
29706 if (PyErr_Occurred()) SWIG_fail;
29707 }
29708 {
29709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29710 }
29711 return resultobj;
29712 fail:
29713 return NULL;
29714 }
29715
29716
29717 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29718 PyObject *resultobj;
29719 wxClipboard *arg1 = (wxClipboard *) 0 ;
29720 wxDataObject *arg2 = (wxDataObject *) 0 ;
29721 bool result;
29722 PyObject * obj0 = 0 ;
29723 PyObject * obj1 = 0 ;
29724 char *kwnames[] = {
29725 (char *) "self",(char *) "data", NULL
29726 };
29727
29728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29730 if (SWIG_arg_fail(1)) SWIG_fail;
29731 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29732 if (SWIG_arg_fail(2)) SWIG_fail;
29733 {
29734 PyThreadState* __tstate = wxPyBeginAllowThreads();
29735 result = (bool)(arg1)->AddData(arg2);
29736
29737 wxPyEndAllowThreads(__tstate);
29738 if (PyErr_Occurred()) SWIG_fail;
29739 }
29740 {
29741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29742 }
29743 return resultobj;
29744 fail:
29745 return NULL;
29746 }
29747
29748
29749 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29750 PyObject *resultobj;
29751 wxClipboard *arg1 = (wxClipboard *) 0 ;
29752 wxDataObject *arg2 = (wxDataObject *) 0 ;
29753 bool result;
29754 PyObject * obj0 = 0 ;
29755 PyObject * obj1 = 0 ;
29756 char *kwnames[] = {
29757 (char *) "self",(char *) "data", NULL
29758 };
29759
29760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29762 if (SWIG_arg_fail(1)) SWIG_fail;
29763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29764 if (SWIG_arg_fail(2)) SWIG_fail;
29765 {
29766 PyThreadState* __tstate = wxPyBeginAllowThreads();
29767 result = (bool)(arg1)->SetData(arg2);
29768
29769 wxPyEndAllowThreads(__tstate);
29770 if (PyErr_Occurred()) SWIG_fail;
29771 }
29772 {
29773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29774 }
29775 return resultobj;
29776 fail:
29777 return NULL;
29778 }
29779
29780
29781 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29782 PyObject *resultobj;
29783 wxClipboard *arg1 = (wxClipboard *) 0 ;
29784 wxDataFormat *arg2 = 0 ;
29785 bool result;
29786 PyObject * obj0 = 0 ;
29787 PyObject * obj1 = 0 ;
29788 char *kwnames[] = {
29789 (char *) "self",(char *) "format", NULL
29790 };
29791
29792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29794 if (SWIG_arg_fail(1)) SWIG_fail;
29795 {
29796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29797 if (SWIG_arg_fail(2)) SWIG_fail;
29798 if (arg2 == NULL) {
29799 SWIG_null_ref("wxDataFormat");
29800 }
29801 if (SWIG_arg_fail(2)) SWIG_fail;
29802 }
29803 {
29804 PyThreadState* __tstate = wxPyBeginAllowThreads();
29805 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29806
29807 wxPyEndAllowThreads(__tstate);
29808 if (PyErr_Occurred()) SWIG_fail;
29809 }
29810 {
29811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29812 }
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29820 PyObject *resultobj;
29821 wxClipboard *arg1 = (wxClipboard *) 0 ;
29822 wxDataObject *arg2 = 0 ;
29823 bool result;
29824 PyObject * obj0 = 0 ;
29825 PyObject * obj1 = 0 ;
29826 char *kwnames[] = {
29827 (char *) "self",(char *) "data", NULL
29828 };
29829
29830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29832 if (SWIG_arg_fail(1)) SWIG_fail;
29833 {
29834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29835 if (SWIG_arg_fail(2)) SWIG_fail;
29836 if (arg2 == NULL) {
29837 SWIG_null_ref("wxDataObject");
29838 }
29839 if (SWIG_arg_fail(2)) SWIG_fail;
29840 }
29841 {
29842 PyThreadState* __tstate = wxPyBeginAllowThreads();
29843 result = (bool)(arg1)->GetData(*arg2);
29844
29845 wxPyEndAllowThreads(__tstate);
29846 if (PyErr_Occurred()) SWIG_fail;
29847 }
29848 {
29849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29850 }
29851 return resultobj;
29852 fail:
29853 return NULL;
29854 }
29855
29856
29857 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29858 PyObject *resultobj;
29859 wxClipboard *arg1 = (wxClipboard *) 0 ;
29860 PyObject * obj0 = 0 ;
29861 char *kwnames[] = {
29862 (char *) "self", NULL
29863 };
29864
29865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29867 if (SWIG_arg_fail(1)) SWIG_fail;
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 (arg1)->Clear();
29871
29872 wxPyEndAllowThreads(__tstate);
29873 if (PyErr_Occurred()) SWIG_fail;
29874 }
29875 Py_INCREF(Py_None); resultobj = Py_None;
29876 return resultobj;
29877 fail:
29878 return NULL;
29879 }
29880
29881
29882 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29883 PyObject *resultobj;
29884 wxClipboard *arg1 = (wxClipboard *) 0 ;
29885 bool result;
29886 PyObject * obj0 = 0 ;
29887 char *kwnames[] = {
29888 (char *) "self", NULL
29889 };
29890
29891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29893 if (SWIG_arg_fail(1)) SWIG_fail;
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 result = (bool)(arg1)->Flush();
29897
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 {
29902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29903 }
29904 return resultobj;
29905 fail:
29906 return NULL;
29907 }
29908
29909
29910 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29911 PyObject *resultobj;
29912 wxClipboard *arg1 = (wxClipboard *) 0 ;
29913 bool arg2 = (bool) true ;
29914 PyObject * obj0 = 0 ;
29915 PyObject * obj1 = 0 ;
29916 char *kwnames[] = {
29917 (char *) "self",(char *) "primary", NULL
29918 };
29919
29920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29922 if (SWIG_arg_fail(1)) SWIG_fail;
29923 if (obj1) {
29924 {
29925 arg2 = (bool)(SWIG_As_bool(obj1));
29926 if (SWIG_arg_fail(2)) SWIG_fail;
29927 }
29928 }
29929 {
29930 PyThreadState* __tstate = wxPyBeginAllowThreads();
29931 (arg1)->UsePrimarySelection(arg2);
29932
29933 wxPyEndAllowThreads(__tstate);
29934 if (PyErr_Occurred()) SWIG_fail;
29935 }
29936 Py_INCREF(Py_None); resultobj = Py_None;
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29944 PyObject *resultobj;
29945 wxClipboard *result;
29946 char *kwnames[] = {
29947 NULL
29948 };
29949
29950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29951 {
29952 PyThreadState* __tstate = wxPyBeginAllowThreads();
29953 result = (wxClipboard *)wxClipboard::Get();
29954
29955 wxPyEndAllowThreads(__tstate);
29956 if (PyErr_Occurred()) SWIG_fail;
29957 }
29958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29959 return resultobj;
29960 fail:
29961 return NULL;
29962 }
29963
29964
29965 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29966 PyObject *obj;
29967 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29968 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29969 Py_INCREF(obj);
29970 return Py_BuildValue((char *)"");
29971 }
29972 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29973 PyObject *resultobj;
29974 wxClipboard *arg1 = (wxClipboard *) NULL ;
29975 wxClipboardLocker *result;
29976 PyObject * obj0 = 0 ;
29977 char *kwnames[] = {
29978 (char *) "clipboard", NULL
29979 };
29980
29981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29982 if (obj0) {
29983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29984 if (SWIG_arg_fail(1)) SWIG_fail;
29985 }
29986 {
29987 PyThreadState* __tstate = wxPyBeginAllowThreads();
29988 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29989
29990 wxPyEndAllowThreads(__tstate);
29991 if (PyErr_Occurred()) SWIG_fail;
29992 }
29993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29994 return resultobj;
29995 fail:
29996 return NULL;
29997 }
29998
29999
30000 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30001 PyObject *resultobj;
30002 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30003 PyObject * obj0 = 0 ;
30004 char *kwnames[] = {
30005 (char *) "self", NULL
30006 };
30007
30008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30010 if (SWIG_arg_fail(1)) SWIG_fail;
30011 {
30012 PyThreadState* __tstate = wxPyBeginAllowThreads();
30013 delete arg1;
30014
30015 wxPyEndAllowThreads(__tstate);
30016 if (PyErr_Occurred()) SWIG_fail;
30017 }
30018 Py_INCREF(Py_None); resultobj = Py_None;
30019 return resultobj;
30020 fail:
30021 return NULL;
30022 }
30023
30024
30025 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30026 PyObject *resultobj;
30027 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30028 bool result;
30029 PyObject * obj0 = 0 ;
30030 char *kwnames[] = {
30031 (char *) "self", NULL
30032 };
30033
30034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30036 if (SWIG_arg_fail(1)) SWIG_fail;
30037 {
30038 PyThreadState* __tstate = wxPyBeginAllowThreads();
30039 result = (bool)wxClipboardLocker___nonzero__(arg1);
30040
30041 wxPyEndAllowThreads(__tstate);
30042 if (PyErr_Occurred()) SWIG_fail;
30043 }
30044 {
30045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30046 }
30047 return resultobj;
30048 fail:
30049 return NULL;
30050 }
30051
30052
30053 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30054 PyObject *obj;
30055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30056 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30057 Py_INCREF(obj);
30058 return Py_BuildValue((char *)"");
30059 }
30060 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30061 PyObject *resultobj;
30062 int arg1 = (int) 0 ;
30063 int arg2 = (int) 0 ;
30064 int arg3 = (int) 0 ;
30065 int arg4 = (int) 0 ;
30066 wxVideoMode *result;
30067 PyObject * obj0 = 0 ;
30068 PyObject * obj1 = 0 ;
30069 PyObject * obj2 = 0 ;
30070 PyObject * obj3 = 0 ;
30071 char *kwnames[] = {
30072 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30073 };
30074
30075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30076 if (obj0) {
30077 {
30078 arg1 = (int)(SWIG_As_int(obj0));
30079 if (SWIG_arg_fail(1)) SWIG_fail;
30080 }
30081 }
30082 if (obj1) {
30083 {
30084 arg2 = (int)(SWIG_As_int(obj1));
30085 if (SWIG_arg_fail(2)) SWIG_fail;
30086 }
30087 }
30088 if (obj2) {
30089 {
30090 arg3 = (int)(SWIG_As_int(obj2));
30091 if (SWIG_arg_fail(3)) SWIG_fail;
30092 }
30093 }
30094 if (obj3) {
30095 {
30096 arg4 = (int)(SWIG_As_int(obj3));
30097 if (SWIG_arg_fail(4)) SWIG_fail;
30098 }
30099 }
30100 {
30101 PyThreadState* __tstate = wxPyBeginAllowThreads();
30102 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30103
30104 wxPyEndAllowThreads(__tstate);
30105 if (PyErr_Occurred()) SWIG_fail;
30106 }
30107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30108 return resultobj;
30109 fail:
30110 return NULL;
30111 }
30112
30113
30114 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30115 PyObject *resultobj;
30116 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30117 PyObject * obj0 = 0 ;
30118 char *kwnames[] = {
30119 (char *) "self", NULL
30120 };
30121
30122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30124 if (SWIG_arg_fail(1)) SWIG_fail;
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 delete arg1;
30128
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 Py_INCREF(Py_None); resultobj = Py_None;
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30140 PyObject *resultobj;
30141 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30142 wxVideoMode *arg2 = 0 ;
30143 bool result;
30144 PyObject * obj0 = 0 ;
30145 PyObject * obj1 = 0 ;
30146 char *kwnames[] = {
30147 (char *) "self",(char *) "other", NULL
30148 };
30149
30150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30152 if (SWIG_arg_fail(1)) SWIG_fail;
30153 {
30154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30155 if (SWIG_arg_fail(2)) SWIG_fail;
30156 if (arg2 == NULL) {
30157 SWIG_null_ref("wxVideoMode");
30158 }
30159 if (SWIG_arg_fail(2)) SWIG_fail;
30160 }
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30164
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 {
30169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30170 }
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30178 PyObject *resultobj;
30179 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30180 int result;
30181 PyObject * obj0 = 0 ;
30182 char *kwnames[] = {
30183 (char *) "self", NULL
30184 };
30185
30186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30188 if (SWIG_arg_fail(1)) SWIG_fail;
30189 {
30190 PyThreadState* __tstate = wxPyBeginAllowThreads();
30191 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30192
30193 wxPyEndAllowThreads(__tstate);
30194 if (PyErr_Occurred()) SWIG_fail;
30195 }
30196 {
30197 resultobj = SWIG_From_int((int)(result));
30198 }
30199 return resultobj;
30200 fail:
30201 return NULL;
30202 }
30203
30204
30205 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj;
30207 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30208 int result;
30209 PyObject * obj0 = 0 ;
30210 char *kwnames[] = {
30211 (char *) "self", NULL
30212 };
30213
30214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30216 if (SWIG_arg_fail(1)) SWIG_fail;
30217 {
30218 PyThreadState* __tstate = wxPyBeginAllowThreads();
30219 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30220
30221 wxPyEndAllowThreads(__tstate);
30222 if (PyErr_Occurred()) SWIG_fail;
30223 }
30224 {
30225 resultobj = SWIG_From_int((int)(result));
30226 }
30227 return resultobj;
30228 fail:
30229 return NULL;
30230 }
30231
30232
30233 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30234 PyObject *resultobj;
30235 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30236 int result;
30237 PyObject * obj0 = 0 ;
30238 char *kwnames[] = {
30239 (char *) "self", NULL
30240 };
30241
30242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30244 if (SWIG_arg_fail(1)) SWIG_fail;
30245 {
30246 PyThreadState* __tstate = wxPyBeginAllowThreads();
30247 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30248
30249 wxPyEndAllowThreads(__tstate);
30250 if (PyErr_Occurred()) SWIG_fail;
30251 }
30252 {
30253 resultobj = SWIG_From_int((int)(result));
30254 }
30255 return resultobj;
30256 fail:
30257 return NULL;
30258 }
30259
30260
30261 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30262 PyObject *resultobj;
30263 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30264 bool result;
30265 PyObject * obj0 = 0 ;
30266 char *kwnames[] = {
30267 (char *) "self", NULL
30268 };
30269
30270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30272 if (SWIG_arg_fail(1)) SWIG_fail;
30273 {
30274 PyThreadState* __tstate = wxPyBeginAllowThreads();
30275 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30276
30277 wxPyEndAllowThreads(__tstate);
30278 if (PyErr_Occurred()) SWIG_fail;
30279 }
30280 {
30281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30282 }
30283 return resultobj;
30284 fail:
30285 return NULL;
30286 }
30287
30288
30289 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30290 PyObject *resultobj;
30291 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30292 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30293 bool result;
30294 PyObject * obj0 = 0 ;
30295 PyObject * obj1 = 0 ;
30296 char *kwnames[] = {
30297 (char *) "self",(char *) "other", NULL
30298 };
30299
30300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30302 if (SWIG_arg_fail(1)) SWIG_fail;
30303 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30304 if (SWIG_arg_fail(2)) SWIG_fail;
30305 {
30306 PyThreadState* __tstate = wxPyBeginAllowThreads();
30307 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30308
30309 wxPyEndAllowThreads(__tstate);
30310 if (PyErr_Occurred()) SWIG_fail;
30311 }
30312 {
30313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30314 }
30315 return resultobj;
30316 fail:
30317 return NULL;
30318 }
30319
30320
30321 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30322 PyObject *resultobj;
30323 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30324 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30325 bool result;
30326 PyObject * obj0 = 0 ;
30327 PyObject * obj1 = 0 ;
30328 char *kwnames[] = {
30329 (char *) "self",(char *) "other", NULL
30330 };
30331
30332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30334 if (SWIG_arg_fail(1)) SWIG_fail;
30335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30336 if (SWIG_arg_fail(2)) SWIG_fail;
30337 {
30338 PyThreadState* __tstate = wxPyBeginAllowThreads();
30339 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30340
30341 wxPyEndAllowThreads(__tstate);
30342 if (PyErr_Occurred()) SWIG_fail;
30343 }
30344 {
30345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30346 }
30347 return resultobj;
30348 fail:
30349 return NULL;
30350 }
30351
30352
30353 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30354 PyObject *resultobj;
30355 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30356 int arg2 ;
30357 PyObject * obj0 = 0 ;
30358 PyObject * obj1 = 0 ;
30359 char *kwnames[] = {
30360 (char *) "self",(char *) "w", NULL
30361 };
30362
30363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30365 if (SWIG_arg_fail(1)) SWIG_fail;
30366 {
30367 arg2 = (int)(SWIG_As_int(obj1));
30368 if (SWIG_arg_fail(2)) SWIG_fail;
30369 }
30370 if (arg1) (arg1)->w = arg2;
30371
30372 Py_INCREF(Py_None); resultobj = Py_None;
30373 return resultobj;
30374 fail:
30375 return NULL;
30376 }
30377
30378
30379 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30380 PyObject *resultobj;
30381 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30382 int result;
30383 PyObject * obj0 = 0 ;
30384 char *kwnames[] = {
30385 (char *) "self", NULL
30386 };
30387
30388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30390 if (SWIG_arg_fail(1)) SWIG_fail;
30391 result = (int) ((arg1)->w);
30392
30393 {
30394 resultobj = SWIG_From_int((int)(result));
30395 }
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30403 PyObject *resultobj;
30404 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30405 int arg2 ;
30406 PyObject * obj0 = 0 ;
30407 PyObject * obj1 = 0 ;
30408 char *kwnames[] = {
30409 (char *) "self",(char *) "h", NULL
30410 };
30411
30412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30414 if (SWIG_arg_fail(1)) SWIG_fail;
30415 {
30416 arg2 = (int)(SWIG_As_int(obj1));
30417 if (SWIG_arg_fail(2)) SWIG_fail;
30418 }
30419 if (arg1) (arg1)->h = arg2;
30420
30421 Py_INCREF(Py_None); resultobj = Py_None;
30422 return resultobj;
30423 fail:
30424 return NULL;
30425 }
30426
30427
30428 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30429 PyObject *resultobj;
30430 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30431 int result;
30432 PyObject * obj0 = 0 ;
30433 char *kwnames[] = {
30434 (char *) "self", NULL
30435 };
30436
30437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30439 if (SWIG_arg_fail(1)) SWIG_fail;
30440 result = (int) ((arg1)->h);
30441
30442 {
30443 resultobj = SWIG_From_int((int)(result));
30444 }
30445 return resultobj;
30446 fail:
30447 return NULL;
30448 }
30449
30450
30451 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30452 PyObject *resultobj;
30453 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30454 int arg2 ;
30455 PyObject * obj0 = 0 ;
30456 PyObject * obj1 = 0 ;
30457 char *kwnames[] = {
30458 (char *) "self",(char *) "bpp", NULL
30459 };
30460
30461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30463 if (SWIG_arg_fail(1)) SWIG_fail;
30464 {
30465 arg2 = (int)(SWIG_As_int(obj1));
30466 if (SWIG_arg_fail(2)) SWIG_fail;
30467 }
30468 if (arg1) (arg1)->bpp = arg2;
30469
30470 Py_INCREF(Py_None); resultobj = Py_None;
30471 return resultobj;
30472 fail:
30473 return NULL;
30474 }
30475
30476
30477 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30478 PyObject *resultobj;
30479 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30480 int result;
30481 PyObject * obj0 = 0 ;
30482 char *kwnames[] = {
30483 (char *) "self", NULL
30484 };
30485
30486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30488 if (SWIG_arg_fail(1)) SWIG_fail;
30489 result = (int) ((arg1)->bpp);
30490
30491 {
30492 resultobj = SWIG_From_int((int)(result));
30493 }
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30501 PyObject *resultobj;
30502 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30503 int arg2 ;
30504 PyObject * obj0 = 0 ;
30505 PyObject * obj1 = 0 ;
30506 char *kwnames[] = {
30507 (char *) "self",(char *) "refresh", NULL
30508 };
30509
30510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30512 if (SWIG_arg_fail(1)) SWIG_fail;
30513 {
30514 arg2 = (int)(SWIG_As_int(obj1));
30515 if (SWIG_arg_fail(2)) SWIG_fail;
30516 }
30517 if (arg1) (arg1)->refresh = arg2;
30518
30519 Py_INCREF(Py_None); resultobj = Py_None;
30520 return resultobj;
30521 fail:
30522 return NULL;
30523 }
30524
30525
30526 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30527 PyObject *resultobj;
30528 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30529 int result;
30530 PyObject * obj0 = 0 ;
30531 char *kwnames[] = {
30532 (char *) "self", NULL
30533 };
30534
30535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30537 if (SWIG_arg_fail(1)) SWIG_fail;
30538 result = (int) ((arg1)->refresh);
30539
30540 {
30541 resultobj = SWIG_From_int((int)(result));
30542 }
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30550 PyObject *obj;
30551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30552 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30553 Py_INCREF(obj);
30554 return Py_BuildValue((char *)"");
30555 }
30556 static int _wrap_DefaultVideoMode_set(PyObject *) {
30557 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30558 return 1;
30559 }
30560
30561
30562 static PyObject *_wrap_DefaultVideoMode_get(void) {
30563 PyObject *pyobj;
30564
30565 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30566 return pyobj;
30567 }
30568
30569
30570 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30571 PyObject *resultobj;
30572 size_t arg1 = (size_t) 0 ;
30573 wxDisplay *result;
30574 PyObject * obj0 = 0 ;
30575 char *kwnames[] = {
30576 (char *) "index", NULL
30577 };
30578
30579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30580 if (obj0) {
30581 {
30582 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30583 if (SWIG_arg_fail(1)) SWIG_fail;
30584 }
30585 }
30586 {
30587 PyThreadState* __tstate = wxPyBeginAllowThreads();
30588 result = (wxDisplay *)new wxDisplay(arg1);
30589
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30594 return resultobj;
30595 fail:
30596 return NULL;
30597 }
30598
30599
30600 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30601 PyObject *resultobj;
30602 wxDisplay *arg1 = (wxDisplay *) 0 ;
30603 PyObject * obj0 = 0 ;
30604 char *kwnames[] = {
30605 (char *) "self", NULL
30606 };
30607
30608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30610 if (SWIG_arg_fail(1)) SWIG_fail;
30611 {
30612 PyThreadState* __tstate = wxPyBeginAllowThreads();
30613 delete arg1;
30614
30615 wxPyEndAllowThreads(__tstate);
30616 if (PyErr_Occurred()) SWIG_fail;
30617 }
30618 Py_INCREF(Py_None); resultobj = Py_None;
30619 return resultobj;
30620 fail:
30621 return NULL;
30622 }
30623
30624
30625 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30626 PyObject *resultobj;
30627 size_t result;
30628 char *kwnames[] = {
30629 NULL
30630 };
30631
30632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30633 {
30634 PyThreadState* __tstate = wxPyBeginAllowThreads();
30635 result = (size_t)wxDisplay::GetCount();
30636
30637 wxPyEndAllowThreads(__tstate);
30638 if (PyErr_Occurred()) SWIG_fail;
30639 }
30640 {
30641 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30642 }
30643 return resultobj;
30644 fail:
30645 return NULL;
30646 }
30647
30648
30649 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30650 PyObject *resultobj;
30651 wxPoint *arg1 = 0 ;
30652 int result;
30653 wxPoint temp1 ;
30654 PyObject * obj0 = 0 ;
30655 char *kwnames[] = {
30656 (char *) "pt", NULL
30657 };
30658
30659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30660 {
30661 arg1 = &temp1;
30662 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30663 }
30664 {
30665 PyThreadState* __tstate = wxPyBeginAllowThreads();
30666 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30667
30668 wxPyEndAllowThreads(__tstate);
30669 if (PyErr_Occurred()) SWIG_fail;
30670 }
30671 {
30672 resultobj = SWIG_From_int((int)(result));
30673 }
30674 return resultobj;
30675 fail:
30676 return NULL;
30677 }
30678
30679
30680 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30681 PyObject *resultobj;
30682 wxWindow *arg1 = (wxWindow *) 0 ;
30683 int result;
30684 PyObject * obj0 = 0 ;
30685 char *kwnames[] = {
30686 (char *) "window", NULL
30687 };
30688
30689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30691 if (SWIG_arg_fail(1)) SWIG_fail;
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 result = (int)Display_GetFromWindow(arg1);
30695
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 {
30700 resultobj = SWIG_From_int((int)(result));
30701 }
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj;
30710 wxDisplay *arg1 = (wxDisplay *) 0 ;
30711 bool result;
30712 PyObject * obj0 = 0 ;
30713 char *kwnames[] = {
30714 (char *) "self", NULL
30715 };
30716
30717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30719 if (SWIG_arg_fail(1)) SWIG_fail;
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = (bool)((wxDisplay const *)arg1)->IsOk();
30723
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 {
30728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30729 }
30730 return resultobj;
30731 fail:
30732 return NULL;
30733 }
30734
30735
30736 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30737 PyObject *resultobj;
30738 wxDisplay *arg1 = (wxDisplay *) 0 ;
30739 wxRect result;
30740 PyObject * obj0 = 0 ;
30741 char *kwnames[] = {
30742 (char *) "self", NULL
30743 };
30744
30745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30747 if (SWIG_arg_fail(1)) SWIG_fail;
30748 {
30749 PyThreadState* __tstate = wxPyBeginAllowThreads();
30750 result = ((wxDisplay const *)arg1)->GetGeometry();
30751
30752 wxPyEndAllowThreads(__tstate);
30753 if (PyErr_Occurred()) SWIG_fail;
30754 }
30755 {
30756 wxRect * resultptr;
30757 resultptr = new wxRect((wxRect &)(result));
30758 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30759 }
30760 return resultobj;
30761 fail:
30762 return NULL;
30763 }
30764
30765
30766 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30767 PyObject *resultobj;
30768 wxDisplay *arg1 = (wxDisplay *) 0 ;
30769 wxString result;
30770 PyObject * obj0 = 0 ;
30771 char *kwnames[] = {
30772 (char *) "self", NULL
30773 };
30774
30775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30777 if (SWIG_arg_fail(1)) SWIG_fail;
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 result = ((wxDisplay const *)arg1)->GetName();
30781
30782 wxPyEndAllowThreads(__tstate);
30783 if (PyErr_Occurred()) SWIG_fail;
30784 }
30785 {
30786 #if wxUSE_UNICODE
30787 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30788 #else
30789 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30790 #endif
30791 }
30792 return resultobj;
30793 fail:
30794 return NULL;
30795 }
30796
30797
30798 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30799 PyObject *resultobj;
30800 wxDisplay *arg1 = (wxDisplay *) 0 ;
30801 bool result;
30802 PyObject * obj0 = 0 ;
30803 char *kwnames[] = {
30804 (char *) "self", NULL
30805 };
30806
30807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30809 if (SWIG_arg_fail(1)) SWIG_fail;
30810 {
30811 PyThreadState* __tstate = wxPyBeginAllowThreads();
30812 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30813
30814 wxPyEndAllowThreads(__tstate);
30815 if (PyErr_Occurred()) SWIG_fail;
30816 }
30817 {
30818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30819 }
30820 return resultobj;
30821 fail:
30822 return NULL;
30823 }
30824
30825
30826 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30827 PyObject *resultobj;
30828 wxDisplay *arg1 = (wxDisplay *) 0 ;
30829 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30830 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30831 PyObject *result;
30832 PyObject * obj0 = 0 ;
30833 PyObject * obj1 = 0 ;
30834 char *kwnames[] = {
30835 (char *) "self",(char *) "mode", NULL
30836 };
30837
30838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30840 if (SWIG_arg_fail(1)) SWIG_fail;
30841 if (obj1) {
30842 {
30843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30844 if (SWIG_arg_fail(2)) SWIG_fail;
30845 if (arg2 == NULL) {
30846 SWIG_null_ref("wxVideoMode");
30847 }
30848 if (SWIG_arg_fail(2)) SWIG_fail;
30849 }
30850 }
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30854
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 resultobj = result;
30859 return resultobj;
30860 fail:
30861 return NULL;
30862 }
30863
30864
30865 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30866 PyObject *resultobj;
30867 wxDisplay *arg1 = (wxDisplay *) 0 ;
30868 wxVideoMode result;
30869 PyObject * obj0 = 0 ;
30870 char *kwnames[] = {
30871 (char *) "self", NULL
30872 };
30873
30874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30876 if (SWIG_arg_fail(1)) SWIG_fail;
30877 {
30878 PyThreadState* __tstate = wxPyBeginAllowThreads();
30879 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30880
30881 wxPyEndAllowThreads(__tstate);
30882 if (PyErr_Occurred()) SWIG_fail;
30883 }
30884 {
30885 wxVideoMode * resultptr;
30886 resultptr = new wxVideoMode((wxVideoMode &)(result));
30887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30888 }
30889 return resultobj;
30890 fail:
30891 return NULL;
30892 }
30893
30894
30895 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30896 PyObject *resultobj;
30897 wxDisplay *arg1 = (wxDisplay *) 0 ;
30898 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30899 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30900 bool result;
30901 PyObject * obj0 = 0 ;
30902 PyObject * obj1 = 0 ;
30903 char *kwnames[] = {
30904 (char *) "self",(char *) "mode", NULL
30905 };
30906
30907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30909 if (SWIG_arg_fail(1)) SWIG_fail;
30910 if (obj1) {
30911 {
30912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30913 if (SWIG_arg_fail(2)) SWIG_fail;
30914 if (arg2 == NULL) {
30915 SWIG_null_ref("wxVideoMode");
30916 }
30917 if (SWIG_arg_fail(2)) SWIG_fail;
30918 }
30919 }
30920 {
30921 PyThreadState* __tstate = wxPyBeginAllowThreads();
30922 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30923
30924 wxPyEndAllowThreads(__tstate);
30925 if (PyErr_Occurred()) SWIG_fail;
30926 }
30927 {
30928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30929 }
30930 return resultobj;
30931 fail:
30932 return NULL;
30933 }
30934
30935
30936 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30937 PyObject *resultobj;
30938 wxDisplay *arg1 = (wxDisplay *) 0 ;
30939 PyObject * obj0 = 0 ;
30940 char *kwnames[] = {
30941 (char *) "self", NULL
30942 };
30943
30944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30946 if (SWIG_arg_fail(1)) SWIG_fail;
30947 {
30948 PyThreadState* __tstate = wxPyBeginAllowThreads();
30949 (arg1)->ResetMode();
30950
30951 wxPyEndAllowThreads(__tstate);
30952 if (PyErr_Occurred()) SWIG_fail;
30953 }
30954 Py_INCREF(Py_None); resultobj = Py_None;
30955 return resultobj;
30956 fail:
30957 return NULL;
30958 }
30959
30960
30961 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30962 PyObject *obj;
30963 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30964 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30965 Py_INCREF(obj);
30966 return Py_BuildValue((char *)"");
30967 }
30968 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30969 PyObject *resultobj;
30970 wxStandardPaths *result;
30971 char *kwnames[] = {
30972 NULL
30973 };
30974
30975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30976 {
30977 PyThreadState* __tstate = wxPyBeginAllowThreads();
30978 result = (wxStandardPaths *)StandardPaths_Get();
30979
30980 wxPyEndAllowThreads(__tstate);
30981 if (PyErr_Occurred()) SWIG_fail;
30982 }
30983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30984 return resultobj;
30985 fail:
30986 return NULL;
30987 }
30988
30989
30990 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30991 PyObject *resultobj;
30992 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30993 wxString result;
30994 PyObject * obj0 = 0 ;
30995 char *kwnames[] = {
30996 (char *) "self", NULL
30997 };
30998
30999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31001 if (SWIG_arg_fail(1)) SWIG_fail;
31002 {
31003 PyThreadState* __tstate = wxPyBeginAllowThreads();
31004 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31005
31006 wxPyEndAllowThreads(__tstate);
31007 if (PyErr_Occurred()) SWIG_fail;
31008 }
31009 {
31010 #if wxUSE_UNICODE
31011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31012 #else
31013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31014 #endif
31015 }
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31023 PyObject *resultobj;
31024 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31025 wxString result;
31026 PyObject * obj0 = 0 ;
31027 char *kwnames[] = {
31028 (char *) "self", NULL
31029 };
31030
31031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31033 if (SWIG_arg_fail(1)) SWIG_fail;
31034 {
31035 PyThreadState* __tstate = wxPyBeginAllowThreads();
31036 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31037
31038 wxPyEndAllowThreads(__tstate);
31039 if (PyErr_Occurred()) SWIG_fail;
31040 }
31041 {
31042 #if wxUSE_UNICODE
31043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31044 #else
31045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31046 #endif
31047 }
31048 return resultobj;
31049 fail:
31050 return NULL;
31051 }
31052
31053
31054 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31055 PyObject *resultobj;
31056 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31057 wxString result;
31058 PyObject * obj0 = 0 ;
31059 char *kwnames[] = {
31060 (char *) "self", NULL
31061 };
31062
31063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31065 if (SWIG_arg_fail(1)) SWIG_fail;
31066 {
31067 PyThreadState* __tstate = wxPyBeginAllowThreads();
31068 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31069
31070 wxPyEndAllowThreads(__tstate);
31071 if (PyErr_Occurred()) SWIG_fail;
31072 }
31073 {
31074 #if wxUSE_UNICODE
31075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31076 #else
31077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31078 #endif
31079 }
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj;
31088 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31089 wxString result;
31090 PyObject * obj0 = 0 ;
31091 char *kwnames[] = {
31092 (char *) "self", NULL
31093 };
31094
31095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31097 if (SWIG_arg_fail(1)) SWIG_fail;
31098 {
31099 PyThreadState* __tstate = wxPyBeginAllowThreads();
31100 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31101
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 {
31106 #if wxUSE_UNICODE
31107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31108 #else
31109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31110 #endif
31111 }
31112 return resultobj;
31113 fail:
31114 return NULL;
31115 }
31116
31117
31118 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31119 PyObject *resultobj;
31120 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31121 wxString result;
31122 PyObject * obj0 = 0 ;
31123 char *kwnames[] = {
31124 (char *) "self", NULL
31125 };
31126
31127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31129 if (SWIG_arg_fail(1)) SWIG_fail;
31130 {
31131 PyThreadState* __tstate = wxPyBeginAllowThreads();
31132 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31133
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 {
31138 #if wxUSE_UNICODE
31139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31140 #else
31141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31142 #endif
31143 }
31144 return resultobj;
31145 fail:
31146 return NULL;
31147 }
31148
31149
31150 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31151 PyObject *resultobj;
31152 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31153 wxString result;
31154 PyObject * obj0 = 0 ;
31155 char *kwnames[] = {
31156 (char *) "self", NULL
31157 };
31158
31159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
31164 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31165
31166 wxPyEndAllowThreads(__tstate);
31167 if (PyErr_Occurred()) SWIG_fail;
31168 }
31169 {
31170 #if wxUSE_UNICODE
31171 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31172 #else
31173 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31174 #endif
31175 }
31176 return resultobj;
31177 fail:
31178 return NULL;
31179 }
31180
31181
31182 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31183 PyObject *resultobj;
31184 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31185 wxString result;
31186 PyObject * obj0 = 0 ;
31187 char *kwnames[] = {
31188 (char *) "self", NULL
31189 };
31190
31191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31193 if (SWIG_arg_fail(1)) SWIG_fail;
31194 {
31195 PyThreadState* __tstate = wxPyBeginAllowThreads();
31196 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31197
31198 wxPyEndAllowThreads(__tstate);
31199 if (PyErr_Occurred()) SWIG_fail;
31200 }
31201 {
31202 #if wxUSE_UNICODE
31203 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31204 #else
31205 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31206 #endif
31207 }
31208 return resultobj;
31209 fail:
31210 return NULL;
31211 }
31212
31213
31214 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31215 PyObject *resultobj;
31216 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31217 wxString *arg2 = 0 ;
31218 bool temp2 = false ;
31219 PyObject * obj0 = 0 ;
31220 PyObject * obj1 = 0 ;
31221 char *kwnames[] = {
31222 (char *) "self",(char *) "prefix", NULL
31223 };
31224
31225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31227 if (SWIG_arg_fail(1)) SWIG_fail;
31228 {
31229 arg2 = wxString_in_helper(obj1);
31230 if (arg2 == NULL) SWIG_fail;
31231 temp2 = true;
31232 }
31233 {
31234 PyThreadState* __tstate = wxPyBeginAllowThreads();
31235 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31236
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 Py_INCREF(Py_None); resultobj = Py_None;
31241 {
31242 if (temp2)
31243 delete arg2;
31244 }
31245 return resultobj;
31246 fail:
31247 {
31248 if (temp2)
31249 delete arg2;
31250 }
31251 return NULL;
31252 }
31253
31254
31255 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31256 PyObject *resultobj;
31257 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31258 wxString result;
31259 PyObject * obj0 = 0 ;
31260 char *kwnames[] = {
31261 (char *) "self", NULL
31262 };
31263
31264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31266 if (SWIG_arg_fail(1)) SWIG_fail;
31267 {
31268 PyThreadState* __tstate = wxPyBeginAllowThreads();
31269 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31270
31271 wxPyEndAllowThreads(__tstate);
31272 if (PyErr_Occurred()) SWIG_fail;
31273 }
31274 {
31275 #if wxUSE_UNICODE
31276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31277 #else
31278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31279 #endif
31280 }
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31288 PyObject *obj;
31289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31290 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31291 Py_INCREF(obj);
31292 return Py_BuildValue((char *)"");
31293 }
31294 static PyMethodDef SwigMethods[] = {
31295 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31302 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31309 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31373 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31381 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31399 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31402 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31405 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31408 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31414 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31428 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31434 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31440 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31443 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31457 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31460 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31461 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31464 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31491 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31493 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31495 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31497 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31504 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31510 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31524 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31528 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31531 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31548 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31556 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31603 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31621 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31631 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31647 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31663 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31677 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31686 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31729 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31732 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31735 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31739 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31832 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31833 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31834 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31835 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31852 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31897 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31931 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31939 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31940 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31945 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31954 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31961 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31964 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31967 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31972 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31975 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31979 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31982 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31986 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
31987 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31991 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31995 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31997 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32007 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32018 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32026 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32034 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32048 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32052 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32070 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32084 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32095 { NULL, NULL, 0, NULL }
32096 };
32097
32098
32099 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32100
32101 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32102 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32103 }
32104 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32105 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32106 }
32107 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32108 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32109 }
32110 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32111 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32112 }
32113 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32114 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32115 }
32116 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32117 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32118 }
32119 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32120 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32121 }
32122 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32123 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32124 }
32125 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32126 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32127 }
32128 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32129 return (void *)((wxEvent *) ((wxPyEvent *) x));
32130 }
32131 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32132 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32133 }
32134 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32135 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32136 }
32137 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32138 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32139 }
32140 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32141 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32142 }
32143 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32144 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32145 }
32146 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32147 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32148 }
32149 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32150 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32151 }
32152 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32153 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32154 }
32155 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32156 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32157 }
32158 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32159 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32160 }
32161 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32162 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32163 }
32164 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32165 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32166 }
32167 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32168 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32169 }
32170 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32171 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32172 }
32173 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32174 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32175 }
32176 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32177 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32178 }
32179 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32180 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32181 }
32182 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32183 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32184 }
32185 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32186 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32187 }
32188 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32189 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32190 }
32191 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32192 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32193 }
32194 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32195 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32196 }
32197 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32198 return (void *)((wxEvent *) ((wxShowEvent *) x));
32199 }
32200 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32201 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32202 }
32203 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32204 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32205 }
32206 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32207 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32208 }
32209 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32210 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32211 }
32212 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32213 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32214 }
32215 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32216 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32217 }
32218 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32219 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32220 }
32221 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32222 return (void *)((wxConfigBase *) ((wxConfig *) x));
32223 }
32224 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32225 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32226 }
32227 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32228 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32229 }
32230 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32231 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32232 }
32233 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32234 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32235 }
32236 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32237 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32238 }
32239 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32240 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32241 }
32242 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32243 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32244 }
32245 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32246 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32247 }
32248 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32249 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32250 }
32251 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32252 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32253 }
32254 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32255 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32256 }
32257 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32258 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32259 }
32260 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32261 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32262 }
32263 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32264 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32265 }
32266 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32267 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32268 }
32269 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32270 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32271 }
32272 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32273 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32274 }
32275 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32276 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32277 }
32278 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32279 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32280 }
32281 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32282 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32283 }
32284 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32285 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32286 }
32287 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32288 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32289 }
32290 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32291 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32292 }
32293 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32294 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32295 }
32296 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32297 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32298 }
32299 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32300 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32301 }
32302 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32303 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32304 }
32305 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32306 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32307 }
32308 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32309 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32310 }
32311 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32312 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32313 }
32314 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32315 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32316 }
32317 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32318 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32319 }
32320 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32321 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32322 }
32323 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32324 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32325 }
32326 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32327 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32328 }
32329 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32330 return (void *)((wxObject *) ((wxSizerItem *) x));
32331 }
32332 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32333 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32334 }
32335 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32336 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32337 }
32338 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32339 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32340 }
32341 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32342 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32343 }
32344 static void *_p_wxSizerTo_p_wxObject(void *x) {
32345 return (void *)((wxObject *) ((wxSizer *) x));
32346 }
32347 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32348 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32349 }
32350 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32351 return (void *)((wxObject *) ((wxFileHistory *) x));
32352 }
32353 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32354 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32355 }
32356 static void *_p_wxEventTo_p_wxObject(void *x) {
32357 return (void *)((wxObject *) ((wxEvent *) x));
32358 }
32359 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32360 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32361 }
32362 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32363 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32364 }
32365 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32366 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32367 }
32368 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32369 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32370 }
32371 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32372 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32373 }
32374 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32375 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32376 }
32377 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32378 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32379 }
32380 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32381 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32382 }
32383 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32384 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32385 }
32386 static void *_p_wxControlTo_p_wxObject(void *x) {
32387 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32388 }
32389 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32390 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32391 }
32392 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32393 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32394 }
32395 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32396 return (void *)((wxObject *) ((wxFSFile *) x));
32397 }
32398 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32399 return (void *)((wxObject *) ((wxClipboard *) x));
32400 }
32401 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32402 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32403 }
32404 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32405 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32406 }
32407 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32408 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32409 }
32410 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32411 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32412 }
32413 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32414 return (void *)((wxObject *) ((wxToolTip *) x));
32415 }
32416 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32417 return (void *)((wxObject *) ((wxMenuItem *) x));
32418 }
32419 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32420 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32421 }
32422 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32423 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32424 }
32425 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32426 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32427 }
32428 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32429 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32430 }
32431 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32432 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32433 }
32434 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32435 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32436 }
32437 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32438 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32439 }
32440 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32441 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32442 }
32443 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32444 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32445 }
32446 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32447 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32448 }
32449 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32450 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32451 }
32452 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32453 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32454 }
32455 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32456 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32457 }
32458 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32459 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32460 }
32461 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32462 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32463 }
32464 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32465 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32466 }
32467 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32468 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32469 }
32470 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32471 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32472 }
32473 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32474 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32475 }
32476 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32477 return (void *)((wxObject *) ((wxImageHandler *) x));
32478 }
32479 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32480 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32481 }
32482 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32483 return (void *)((wxObject *) ((wxEvtHandler *) x));
32484 }
32485 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32486 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32487 }
32488 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32489 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32490 }
32491 static void *_p_wxImageTo_p_wxObject(void *x) {
32492 return (void *)((wxObject *) ((wxImage *) x));
32493 }
32494 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32495 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32496 }
32497 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32498 return (void *)((wxObject *) ((wxSystemOptions *) x));
32499 }
32500 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32501 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32502 }
32503 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32504 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32505 }
32506 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32507 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32508 }
32509 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32510 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32511 }
32512 static void *_p_wxWindowTo_p_wxObject(void *x) {
32513 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32514 }
32515 static void *_p_wxMenuTo_p_wxObject(void *x) {
32516 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32517 }
32518 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32519 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32520 }
32521 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32522 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32523 }
32524 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32525 return (void *)((wxObject *) ((wxFileSystem *) x));
32526 }
32527 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32528 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32529 }
32530 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32531 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32532 }
32533 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32534 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32535 }
32536 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32537 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32538 }
32539 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32540 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32541 }
32542 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32543 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32544 }
32545 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32546 return (void *)((wxObject *) ((wxBusyInfo *) x));
32547 }
32548 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32549 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32550 }
32551 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32552 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32553 }
32554 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32555 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32556 }
32557 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32558 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32559 }
32560 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32561 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32562 }
32563 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32564 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32565 }
32566 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32567 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32568 }
32569 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32570 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32571 }
32572 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32573 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32574 }
32575 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32576 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32577 }
32578 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32579 return (void *)((wxLog *) ((wxLogStderr *) x));
32580 }
32581 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32582 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32583 }
32584 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32585 return (void *)((wxLog *) ((wxLogWindow *) x));
32586 }
32587 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32588 return (void *)((wxLog *) ((wxLogChain *) x));
32589 }
32590 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32591 return (void *)((wxLog *) ((wxLogGui *) x));
32592 }
32593 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32594 return (void *)((wxLog *) ((wxPyLog *) x));
32595 }
32596 static void *_p_wxControlTo_p_wxWindow(void *x) {
32597 return (void *)((wxWindow *) ((wxControl *) x));
32598 }
32599 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32600 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32601 }
32602 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32603 return (void *)((wxWindow *) ((wxMenuBar *) x));
32604 }
32605 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32606 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32607 }
32608 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32609 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32610 }
32611 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}};
32612 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}};
32613 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}};
32614 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}};
32615 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}};
32616 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32617 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}};
32618 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}};
32619 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}};
32620 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}};
32621 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}};
32622 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}};
32623 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}};
32624 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}};
32625 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}};
32626 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}};
32627 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}};
32628 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}};
32629 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}};
32630 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}};
32631 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}};
32632 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}};
32633 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}};
32634 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}};
32635 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}};
32636 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}};
32637 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}};
32638 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}};
32639 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}};
32640 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}};
32641 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}};
32642 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}};
32643 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}};
32644 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}};
32645 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}};
32646 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}};
32647 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}};
32648 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}};
32649 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}};
32650 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}};
32651 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}};
32652 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}};
32653 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}};
32654 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}};
32655 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}};
32656 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}};
32657 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}};
32658 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}};
32659 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}};
32660 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}};
32661 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}};
32662 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}};
32663 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}};
32664 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}};
32665 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}};
32666 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}};
32667 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}};
32668 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}};
32669 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}};
32670 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}};
32671 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}};
32672 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}};
32673 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}};
32674 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}};
32675 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}};
32676 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}};
32677 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}};
32678 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}};
32679 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}};
32680 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}};
32681 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32682 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}};
32683 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}};
32684 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}};
32685 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}};
32686 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}};
32687 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}};
32688 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}};
32689 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}};
32690 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}};
32691 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}};
32692 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}};
32693 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}};
32694 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}};
32695 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}};
32696 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}};
32697 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}};
32698 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}};
32699 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}};
32700 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}};
32701 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}};
32702 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}};
32703 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}};
32704 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}};
32705 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}};
32706 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}};
32707
32708 static swig_type_info *swig_types_initial[] = {
32709 _swigt__p_wxLogChain,
32710 _swigt__p_wxMutexGuiLocker,
32711 _swigt__p_wxFileHistory,
32712 _swigt__p_wxLog,
32713 _swigt__p_wxMenu,
32714 _swigt__p_wxEvent,
32715 _swigt__p_wxDateTime__TimeZone,
32716 _swigt__p_wxConfigBase,
32717 _swigt__p_wxDisplay,
32718 _swigt__p_wxFileType,
32719 _swigt__p_wxLogGui,
32720 _swigt__p_wxFont,
32721 _swigt__p_wxDataFormat,
32722 _swigt__p_wxTimerEvent,
32723 _swigt__p_wxCaret,
32724 _swigt__ptrdiff_t,
32725 _swigt__std__ptrdiff_t,
32726 _swigt__p_int,
32727 _swigt__p_wxSize,
32728 _swigt__p_wxClipboard,
32729 _swigt__p_wxStopWatch,
32730 _swigt__p_wxDC,
32731 _swigt__p_wxClipboardLocker,
32732 _swigt__p_wxIcon,
32733 _swigt__p_wxLogStderr,
32734 _swigt__p_wxLogTextCtrl,
32735 _swigt__p_wxTextCtrl,
32736 _swigt__p_wxBusyCursor,
32737 _swigt__p_wxBitmapDataObject,
32738 _swigt__p_wxTextDataObject,
32739 _swigt__p_wxDataObject,
32740 _swigt__p_wxPyTextDataObject,
32741 _swigt__p_wxPyBitmapDataObject,
32742 _swigt__p_wxFileDataObject,
32743 _swigt__p_wxCustomDataObject,
32744 _swigt__p_wxURLDataObject,
32745 _swigt__p_wxMetafileDataObject,
32746 _swigt__p_wxSound,
32747 _swigt__p_wxTimerRunner,
32748 _swigt__p_wxLogWindow,
32749 _swigt__p_wxTimeSpan,
32750 _swigt__p_wxArrayString,
32751 _swigt__p_wxWindowDisabler,
32752 _swigt__p_form_ops_t,
32753 _swigt__p_wxToolTip,
32754 _swigt__p_wxDataObjectComposite,
32755 _swigt__p_wxSystemSettings,
32756 _swigt__p_wxFileConfig,
32757 _swigt__p_wxVideoMode,
32758 _swigt__p_wxDataObjectSimple,
32759 _swigt__p_wxPyDataObjectSimple,
32760 _swigt__p_wxDuplexMode,
32761 _swigt__p_wxEvtHandler,
32762 _swigt__p_wxRect,
32763 _swigt__p_char,
32764 _swigt__p_wxSingleInstanceChecker,
32765 _swigt__p_wxStandardPaths,
32766 _swigt__p_wxFileTypeInfo,
32767 _swigt__p_wxFrame,
32768 _swigt__p_wxTimer,
32769 _swigt__p_wxPaperSize,
32770 _swigt__p_wxMimeTypesManager,
32771 _swigt__p_wxPyArtProvider,
32772 _swigt__p_wxPyTipProvider,
32773 _swigt__p_wxTipProvider,
32774 _swigt__p_wxJoystick,
32775 _swigt__p_wxSystemOptions,
32776 _swigt__p_wxPoint,
32777 _swigt__p_wxJoystickEvent,
32778 _swigt__p_wxCursor,
32779 _swigt__p_wxObject,
32780 _swigt__p_wxOutputStream,
32781 _swigt__p_wxDateTime,
32782 _swigt__p_wxPyDropSource,
32783 _swigt__p_unsigned_long,
32784 _swigt__p_wxKillError,
32785 _swigt__p_wxWindow,
32786 _swigt__p_wxString,
32787 _swigt__p_wxPyProcess,
32788 _swigt__p_wxBitmap,
32789 _swigt__p_wxConfig,
32790 _swigt__unsigned_int,
32791 _swigt__p_unsigned_int,
32792 _swigt__p_unsigned_char,
32793 _swigt__p_wxChar,
32794 _swigt__p_wxBusyInfo,
32795 _swigt__p_wxPyDropTarget,
32796 _swigt__p_wxPyTextDropTarget,
32797 _swigt__p_wxPyFileDropTarget,
32798 _swigt__p_wxProcessEvent,
32799 _swigt__p_wxPyLog,
32800 _swigt__p_wxLogNull,
32801 _swigt__p_wxColour,
32802 _swigt__p_wxPyTimer,
32803 _swigt__p_wxConfigPathChanger,
32804 _swigt__p_wxDateSpan,
32805 0
32806 };
32807
32808
32809 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32810
32811 static swig_const_info swig_const_table[] = {
32812 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32813 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32814 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32815 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32816 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32817 {0, 0, 0, 0.0, 0, 0}};
32818
32819 #ifdef __cplusplus
32820 }
32821 #endif
32822
32823
32824 #ifdef __cplusplus
32825 extern "C" {
32826 #endif
32827
32828 /* Python-specific SWIG API */
32829 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32830 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32831 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32832
32833 /* -----------------------------------------------------------------------------
32834 * global variable support code.
32835 * ----------------------------------------------------------------------------- */
32836
32837 typedef struct swig_globalvar {
32838 char *name; /* Name of global variable */
32839 PyObject *(*get_attr)(); /* Return the current value */
32840 int (*set_attr)(PyObject *); /* Set the value */
32841 struct swig_globalvar *next;
32842 } swig_globalvar;
32843
32844 typedef struct swig_varlinkobject {
32845 PyObject_HEAD
32846 swig_globalvar *vars;
32847 } swig_varlinkobject;
32848
32849 static PyObject *
32850 swig_varlink_repr(swig_varlinkobject *v) {
32851 v = v;
32852 return PyString_FromString("<Swig global variables>");
32853 }
32854
32855 static int
32856 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32857 swig_globalvar *var;
32858 flags = flags;
32859 fprintf(fp,"Swig global variables { ");
32860 for (var = v->vars; var; var=var->next) {
32861 fprintf(fp,"%s", var->name);
32862 if (var->next) fprintf(fp,", ");
32863 }
32864 fprintf(fp," }\n");
32865 return 0;
32866 }
32867
32868 static PyObject *
32869 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32870 swig_globalvar *var = v->vars;
32871 while (var) {
32872 if (strcmp(var->name,n) == 0) {
32873 return (*var->get_attr)();
32874 }
32875 var = var->next;
32876 }
32877 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32878 return NULL;
32879 }
32880
32881 static int
32882 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32883 swig_globalvar *var = v->vars;
32884 while (var) {
32885 if (strcmp(var->name,n) == 0) {
32886 return (*var->set_attr)(p);
32887 }
32888 var = var->next;
32889 }
32890 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32891 return 1;
32892 }
32893
32894 static PyTypeObject varlinktype = {
32895 PyObject_HEAD_INIT(0)
32896 0, /* Number of items in variable part (ob_size) */
32897 (char *)"swigvarlink", /* Type name (tp_name) */
32898 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32899 0, /* Itemsize (tp_itemsize) */
32900 0, /* Deallocator (tp_dealloc) */
32901 (printfunc) swig_varlink_print, /* Print (tp_print) */
32902 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32903 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32904 0, /* tp_compare */
32905 (reprfunc) swig_varlink_repr, /* tp_repr */
32906 0, /* tp_as_number */
32907 0, /* tp_as_sequence */
32908 0, /* tp_as_mapping */
32909 0, /* tp_hash */
32910 0, /* tp_call */
32911 0, /* tp_str */
32912 0, /* tp_getattro */
32913 0, /* tp_setattro */
32914 0, /* tp_as_buffer */
32915 0, /* tp_flags */
32916 0, /* tp_doc */
32917 #if PY_VERSION_HEX >= 0x02000000
32918 0, /* tp_traverse */
32919 0, /* tp_clear */
32920 #endif
32921 #if PY_VERSION_HEX >= 0x02010000
32922 0, /* tp_richcompare */
32923 0, /* tp_weaklistoffset */
32924 #endif
32925 #if PY_VERSION_HEX >= 0x02020000
32926 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32927 #endif
32928 #if PY_VERSION_HEX >= 0x02030000
32929 0, /* tp_del */
32930 #endif
32931 #ifdef COUNT_ALLOCS
32932 0,0,0,0 /* tp_alloc -> tp_next */
32933 #endif
32934 };
32935
32936 /* Create a variable linking object for use later */
32937 static PyObject *
32938 SWIG_Python_newvarlink(void) {
32939 swig_varlinkobject *result = 0;
32940 result = PyMem_NEW(swig_varlinkobject,1);
32941 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32942 result->ob_type = &varlinktype;
32943 result->vars = 0;
32944 result->ob_refcnt = 0;
32945 Py_XINCREF((PyObject *) result);
32946 return ((PyObject*) result);
32947 }
32948
32949 static void
32950 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32951 swig_varlinkobject *v;
32952 swig_globalvar *gv;
32953 v= (swig_varlinkobject *) p;
32954 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32955 gv->name = (char *) malloc(strlen(name)+1);
32956 strcpy(gv->name,name);
32957 gv->get_attr = get_attr;
32958 gv->set_attr = set_attr;
32959 gv->next = v->vars;
32960 v->vars = gv;
32961 }
32962
32963 /* -----------------------------------------------------------------------------
32964 * constants/methods manipulation
32965 * ----------------------------------------------------------------------------- */
32966
32967 /* Install Constants */
32968 static void
32969 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32970 PyObject *obj = 0;
32971 size_t i;
32972 for (i = 0; constants[i].type; i++) {
32973 switch(constants[i].type) {
32974 case SWIG_PY_INT:
32975 obj = PyInt_FromLong(constants[i].lvalue);
32976 break;
32977 case SWIG_PY_FLOAT:
32978 obj = PyFloat_FromDouble(constants[i].dvalue);
32979 break;
32980 case SWIG_PY_STRING:
32981 if (constants[i].pvalue) {
32982 obj = PyString_FromString((char *) constants[i].pvalue);
32983 } else {
32984 Py_INCREF(Py_None);
32985 obj = Py_None;
32986 }
32987 break;
32988 case SWIG_PY_POINTER:
32989 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32990 break;
32991 case SWIG_PY_BINARY:
32992 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32993 break;
32994 default:
32995 obj = 0;
32996 break;
32997 }
32998 if (obj) {
32999 PyDict_SetItemString(d,constants[i].name,obj);
33000 Py_DECREF(obj);
33001 }
33002 }
33003 }
33004
33005 /* -----------------------------------------------------------------------------*/
33006 /* Fix SwigMethods to carry the callback ptrs when needed */
33007 /* -----------------------------------------------------------------------------*/
33008
33009 static void
33010 SWIG_Python_FixMethods(PyMethodDef *methods,
33011 swig_const_info *const_table,
33012 swig_type_info **types,
33013 swig_type_info **types_initial) {
33014 size_t i;
33015 for (i = 0; methods[i].ml_name; ++i) {
33016 char *c = methods[i].ml_doc;
33017 if (c && (c = strstr(c, "swig_ptr: "))) {
33018 int j;
33019 swig_const_info *ci = 0;
33020 char *name = c + 10;
33021 for (j = 0; const_table[j].type; j++) {
33022 if (strncmp(const_table[j].name, name,
33023 strlen(const_table[j].name)) == 0) {
33024 ci = &(const_table[j]);
33025 break;
33026 }
33027 }
33028 if (ci) {
33029 size_t shift = (ci->ptype) - types;
33030 swig_type_info *ty = types_initial[shift];
33031 size_t ldoc = (c - methods[i].ml_doc);
33032 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33033 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33034 char *buff = ndoc;
33035 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33036 strncpy(buff, methods[i].ml_doc, ldoc);
33037 buff += ldoc;
33038 strncpy(buff, "swig_ptr: ", 10);
33039 buff += 10;
33040 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33041 methods[i].ml_doc = ndoc;
33042 }
33043 }
33044 }
33045 }
33046
33047 /* -----------------------------------------------------------------------------*
33048 * Initialize type list
33049 * -----------------------------------------------------------------------------*/
33050
33051 #if PY_MAJOR_VERSION < 2
33052 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33053 is copied out of Python/modsupport.c in python version 2.3.4 */
33054 static int
33055 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33056 {
33057 PyObject *dict;
33058 if (!PyModule_Check(m)) {
33059 PyErr_SetString(PyExc_TypeError,
33060 "PyModule_AddObject() needs module as first arg");
33061 return -1;
33062 }
33063 if (!o) {
33064 PyErr_SetString(PyExc_TypeError,
33065 "PyModule_AddObject() needs non-NULL value");
33066 return -1;
33067 }
33068
33069 dict = PyModule_GetDict(m);
33070 if (dict == NULL) {
33071 /* Internal error -- modules must have a dict! */
33072 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33073 PyModule_GetName(m));
33074 return -1;
33075 }
33076 if (PyDict_SetItemString(dict, name, o))
33077 return -1;
33078 Py_DECREF(o);
33079 return 0;
33080 }
33081 #endif
33082
33083 static swig_type_info **
33084 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33085 static PyMethodDef swig_empty_runtime_method_table[] = {
33086 {
33087 NULL, NULL, 0, NULL
33088 }
33089 };/* Sentinel */
33090
33091 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33092 swig_empty_runtime_method_table);
33093 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33094 if (pointer && module) {
33095 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33096 }
33097 return type_list_handle;
33098 }
33099
33100 static swig_type_info **
33101 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33102 swig_type_info **type_pointer;
33103
33104 /* first check if module already created */
33105 type_pointer = SWIG_Python_GetTypeListHandle();
33106 if (type_pointer) {
33107 return type_pointer;
33108 } else {
33109 /* create a new module and variable */
33110 return SWIG_Python_SetTypeListHandle(type_list_handle);
33111 }
33112 }
33113
33114 #ifdef __cplusplus
33115 }
33116 #endif
33117
33118 /* -----------------------------------------------------------------------------*
33119 * Partial Init method
33120 * -----------------------------------------------------------------------------*/
33121
33122 #ifdef SWIG_LINK_RUNTIME
33123 #ifdef __cplusplus
33124 extern "C"
33125 #endif
33126 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33127 #endif
33128
33129 #ifdef __cplusplus
33130 extern "C"
33131 #endif
33132 SWIGEXPORT(void) SWIG_init(void) {
33133 static PyObject *SWIG_globals = 0;
33134 static int typeinit = 0;
33135 PyObject *m, *d;
33136 int i;
33137 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33138
33139 /* Fix SwigMethods to carry the callback ptrs when needed */
33140 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33141
33142 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33143 d = PyModule_GetDict(m);
33144
33145 if (!typeinit) {
33146 #ifdef SWIG_LINK_RUNTIME
33147 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33148 #else
33149 # ifndef SWIG_STATIC_RUNTIME
33150 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33151 # endif
33152 #endif
33153 for (i = 0; swig_types_initial[i]; i++) {
33154 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33155 }
33156 typeinit = 1;
33157 }
33158 SWIG_InstallConstants(d,swig_const_table);
33159
33160 {
33161 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33162 }
33163 {
33164 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33165 }
33166 {
33167 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33168 }
33169 {
33170 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33171 }
33172 {
33173 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33174 }
33175 {
33176 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33177 }
33178 {
33179 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33180 }
33181 {
33182 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33183 }
33184 {
33185 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33186 }
33187 {
33188 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33189 }
33190 {
33191 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33192 }
33193 {
33194 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33195 }
33196 {
33197 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33198 }
33199 {
33200 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33201 }
33202 {
33203 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33204 }
33205 {
33206 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33207 }
33208 {
33209 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33210 }
33211 {
33212 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33213 }
33214 {
33215 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33216 }
33217 {
33218 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33219 }
33220 {
33221 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33222 }
33223 {
33224 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33225 }
33226 {
33227 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33228 }
33229 {
33230 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33231 }
33232 {
33233 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33234 }
33235 {
33236 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33237 }
33238 {
33239 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33240 }
33241 {
33242 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33243 }
33244 {
33245 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33246 }
33247 {
33248 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33249 }
33250 {
33251 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33252 }
33253 {
33254 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33255 }
33256 {
33257 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33258 }
33259 {
33260 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33261 }
33262 {
33263 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33264 }
33265 {
33266 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33267 }
33268 {
33269 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33270 }
33271 {
33272 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33273 }
33274 {
33275 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33276 }
33277 {
33278 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33279 }
33280 {
33281 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33282 }
33283 {
33284 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33285 }
33286 {
33287 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33288 }
33289 {
33290 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33291 }
33292 {
33293 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33294 }
33295 {
33296 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33297 }
33298 {
33299 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33300 }
33301 {
33302 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33303 }
33304 {
33305 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33306 }
33307 {
33308 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33309 }
33310 {
33311 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33312 }
33313 {
33314 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33315 }
33316 {
33317 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33318 }
33319 {
33320 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33321 }
33322 {
33323 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33324 }
33325 {
33326 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33327 }
33328 {
33329 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33330 }
33331 {
33332 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33333 }
33334 {
33335 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33336 }
33337 {
33338 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33339 }
33340 {
33341 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33342 }
33343 {
33344 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33345 }
33346 {
33347 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33348 }
33349 {
33350 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33351 }
33352 {
33353 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33354 }
33355 {
33356 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33357 }
33358 {
33359 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33360 }
33361 {
33362 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33363 }
33364 {
33365 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33366 }
33367 {
33368 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33369 }
33370 {
33371 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33372 }
33373 {
33374 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33375 }
33376 {
33377 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33378 }
33379 {
33380 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33381 }
33382 {
33383 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33384 }
33385 {
33386 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33387 }
33388 {
33389 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33390 }
33391 {
33392 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33393 }
33394 {
33395 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33396 }
33397 {
33398 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33399 }
33400 {
33401 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33402 }
33403 {
33404 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33405 }
33406 {
33407 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33408 }
33409 {
33410 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33411 }
33412 {
33413 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33414 }
33415 {
33416 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33417 }
33418 {
33419 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33420 }
33421 {
33422 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33423 }
33424 {
33425 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33426 }
33427 {
33428 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33429 }
33430 {
33431 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33432 }
33433 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33434 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33435 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33436 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33437 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33438 {
33439 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33449 }
33450 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33451
33452 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33453
33454 {
33455 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33456 }
33457 {
33458 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33459 }
33460 {
33461 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33462 }
33463 {
33464 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33465 }
33466 {
33467 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33468 }
33469 {
33470 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33486 }
33487 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33488 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33489 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33490 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33491 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33492 {
33493 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33584 }
33585 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33586 {
33587 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33600 }
33601
33602 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33603
33604 {
33605 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33624 }
33625 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33626 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33627 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33628 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33629 {
33630 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33652 }
33653 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33654 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33655 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33656 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33657 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33658 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33659 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33660 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33661 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33662 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33663 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33664 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33665 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33666 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33667 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33668 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33669 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33670 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33671 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33672 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33673 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33674 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33675 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33676 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33677 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33678 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33679 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33680 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33681 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33682 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33683 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33684 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33685 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33686 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33687 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33688 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33689 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33690 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33691 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33692 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33693 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33694 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33695 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33696 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33697 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33698 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33699 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33700 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33701 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33702 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33703 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33704 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33705 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33706 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33707 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33708 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33709
33710 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33711
33712 {
33713 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33717 }
33718 {
33719 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33720 }
33721 {
33722 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33726 }
33727 {
33728 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33738 }
33739 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33740 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33741 {
33742 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33782 }
33783 {
33784 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33974 }
33975 {
33976 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33977 }
33978 {
33979 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33980 }
33981 {
33982 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34073 }
34074 {
34075 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34205 }
34206 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34207 {
34208 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34245 }
34246 {
34247 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34248 }
34249 {
34250 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34251 }
34252 {
34253 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34254 }
34255 {
34256 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34257 }
34258 {
34259 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34266 }
34267 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34268 {
34269 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34297 }
34298 {
34299 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34300 }
34301 {
34302 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34303 }
34304
34305 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34306 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34307 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34308 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34309
34310 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34311 }
34312
wxWidgets (Impactor)