]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxCheckListBox doesn't require wxUSE_OWNER_DRAWN when using WXUNIVERSAL
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLogChain swig_types[0]
1343 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1344 #define SWIGTYPE_p_wxMetafile swig_types[2]
1345 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1346 #define SWIGTYPE_p_wxLog swig_types[4]
1347 #define SWIGTYPE_p_wxMenu swig_types[5]
1348 #define SWIGTYPE_p_wxEvent swig_types[6]
1349 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1350 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1351 #define SWIGTYPE_p_wxDisplay swig_types[9]
1352 #define SWIGTYPE_p_wxFileType swig_types[10]
1353 #define SWIGTYPE_p_wxLogGui swig_types[11]
1354 #define SWIGTYPE_p_wxFont swig_types[12]
1355 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1356 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1357 #define SWIGTYPE_p_wxCaret swig_types[15]
1358 #define SWIGTYPE_ptrdiff_t swig_types[16]
1359 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1360 #define SWIGTYPE_p_void swig_types[18]
1361 #define SWIGTYPE_p_int swig_types[19]
1362 #define SWIGTYPE_p_wxSize swig_types[20]
1363 #define SWIGTYPE_p_wxClipboard swig_types[21]
1364 #define SWIGTYPE_p_wxStopWatch swig_types[22]
1365 #define SWIGTYPE_p_wxDC swig_types[23]
1366 #define SWIGTYPE_p_wxClipboardLocker swig_types[24]
1367 #define SWIGTYPE_p_wxIcon swig_types[25]
1368 #define SWIGTYPE_p_wxLogStderr swig_types[26]
1369 #define SWIGTYPE_p_wxLogTextCtrl swig_types[27]
1370 #define SWIGTYPE_p_wxTextCtrl swig_types[28]
1371 #define SWIGTYPE_p_wxBusyCursor swig_types[29]
1372 #define SWIGTYPE_p_wxBitmapDataObject swig_types[30]
1373 #define SWIGTYPE_p_wxTextDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxPyTextDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxFileDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxCustomDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxURLDataObject swig_types[37]
1380 #define SWIGTYPE_p_wxMetafileDataObject swig_types[38]
1381 #define SWIGTYPE_p_wxSound swig_types[39]
1382 #define SWIGTYPE_p_wxTimerRunner swig_types[40]
1383 #define SWIGTYPE_p_wxLogWindow swig_types[41]
1384 #define SWIGTYPE_p_wxTimeSpan swig_types[42]
1385 #define SWIGTYPE_p_wxArrayString swig_types[43]
1386 #define SWIGTYPE_p_wxWindowDisabler swig_types[44]
1387 #define SWIGTYPE_p_form_ops_t swig_types[45]
1388 #define SWIGTYPE_p_wxToolTip swig_types[46]
1389 #define SWIGTYPE_p_wxDataObjectComposite swig_types[47]
1390 #define SWIGTYPE_p_wxSystemSettings swig_types[48]
1391 #define SWIGTYPE_p_wxFileConfig swig_types[49]
1392 #define SWIGTYPE_p_wxVideoMode swig_types[50]
1393 #define SWIGTYPE_p_wxDataObjectSimple swig_types[51]
1394 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[52]
1395 #define SWIGTYPE_p_wxDuplexMode swig_types[53]
1396 #define SWIGTYPE_p_wxEvtHandler swig_types[54]
1397 #define SWIGTYPE_p_wxRect swig_types[55]
1398 #define SWIGTYPE_p_char swig_types[56]
1399 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[57]
1400 #define SWIGTYPE_p_wxStandardPaths swig_types[58]
1401 #define SWIGTYPE_p_wxFileTypeInfo swig_types[59]
1402 #define SWIGTYPE_p_wxFrame swig_types[60]
1403 #define SWIGTYPE_p_wxTimer swig_types[61]
1404 #define SWIGTYPE_p_wxPaperSize swig_types[62]
1405 #define SWIGTYPE_p_wxMimeTypesManager swig_types[63]
1406 #define SWIGTYPE_p_wxPyArtProvider swig_types[64]
1407 #define SWIGTYPE_p_wxPyTipProvider swig_types[65]
1408 #define SWIGTYPE_p_wxTipProvider swig_types[66]
1409 #define SWIGTYPE_p_wxJoystick swig_types[67]
1410 #define SWIGTYPE_p_wxSystemOptions swig_types[68]
1411 #define SWIGTYPE_p_wxPoint swig_types[69]
1412 #define SWIGTYPE_p_wxJoystickEvent swig_types[70]
1413 #define SWIGTYPE_p_wxCursor swig_types[71]
1414 #define SWIGTYPE_p_wxObject swig_types[72]
1415 #define SWIGTYPE_p_wxOutputStream swig_types[73]
1416 #define SWIGTYPE_p_wxDateTime swig_types[74]
1417 #define SWIGTYPE_p_wxPyDropSource swig_types[75]
1418 #define SWIGTYPE_p_unsigned_long swig_types[76]
1419 #define SWIGTYPE_p_wxKillError swig_types[77]
1420 #define SWIGTYPE_p_wxWindow swig_types[78]
1421 #define SWIGTYPE_p_wxString swig_types[79]
1422 #define SWIGTYPE_p_wxPyProcess swig_types[80]
1423 #define SWIGTYPE_p_wxBitmap swig_types[81]
1424 #define SWIGTYPE_unsigned_int swig_types[82]
1425 #define SWIGTYPE_p_unsigned_int swig_types[83]
1426 #define SWIGTYPE_p_wxConfig swig_types[84]
1427 #define SWIGTYPE_p_unsigned_char swig_types[85]
1428 #define SWIGTYPE_p_wxChar swig_types[86]
1429 #define SWIGTYPE_p_wxBusyInfo swig_types[87]
1430 #define SWIGTYPE_p_wxPyDropTarget swig_types[88]
1431 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[89]
1432 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[90]
1433 #define SWIGTYPE_p_wxProcessEvent swig_types[91]
1434 #define SWIGTYPE_p_wxPyLog swig_types[92]
1435 #define SWIGTYPE_p_wxLogNull swig_types[93]
1436 #define SWIGTYPE_p_wxColour swig_types[94]
1437 #define SWIGTYPE_p_wxPyTimer swig_types[95]
1438 #define SWIGTYPE_p_wxConfigPathChanger swig_types[96]
1439 #define SWIGTYPE_p_wxDateSpan swig_types[97]
1440 static swig_type_info *swig_types[99];
1441
1442 /* -------- TYPES TABLE (END) -------- */
1443
1444
1445 /*-----------------------------------------------
1446 @(target):= _misc_.so
1447 ------------------------------------------------*/
1448 #define SWIG_init init_misc_
1449
1450 #define SWIG_name "_misc_"
1451
1452 #include "wx/wxPython/wxPython.h"
1453 #include "wx/wxPython/pyclasses.h"
1454 #include "wx/wxPython/pyistream.h"
1455
1456 static const wxString wxPyEmptyString(wxEmptyString);
1457
1458
1459
1460 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1461 #define SWIG_From_int PyInt_FromLong
1462 /*@@*/
1463
1464
1465 #include <limits.h>
1466
1467
1468 SWIGINTERN int
1469 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1470 const char *errmsg)
1471 {
1472 if (value < min_value) {
1473 if (errmsg) {
1474 PyErr_Format(PyExc_OverflowError,
1475 "value %ld is less than '%s' minimum %ld",
1476 value, errmsg, min_value);
1477 }
1478 return 0;
1479 } else if (value > max_value) {
1480 if (errmsg) {
1481 PyErr_Format(PyExc_OverflowError,
1482 "value %ld is greater than '%s' maximum %ld",
1483 value, errmsg, max_value);
1484 }
1485 return 0;
1486 }
1487 return 1;
1488 }
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_long(PyObject* obj, long* val)
1493 {
1494 if (PyNumber_Check(obj)) {
1495 if (val) *val = PyInt_AsLong(obj);
1496 return 1;
1497 }
1498 else {
1499 SWIG_type_error("number", obj);
1500 }
1501 return 0;
1502 }
1503
1504
1505 #if INT_MAX != LONG_MAX
1506 SWIGINTERN int
1507 SWIG_AsVal_int(PyObject *obj, int *val)
1508 {
1509 const char* errmsg = val ? "int" : (char*)0;
1510 long v;
1511 if (SWIG_AsVal_long(obj, &v)) {
1512 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1513 if (val) *val = (int)(v);
1514 return 1;
1515 } else {
1516 return 0;
1517 }
1518 } else {
1519 PyErr_Clear();
1520 }
1521 if (val) {
1522 SWIG_type_error(errmsg, obj);
1523 }
1524 return 0;
1525 }
1526 #else
1527 SWIGINTERNSHORT int
1528 SWIG_AsVal_int(PyObject *obj, int *val)
1529 {
1530 return SWIG_AsVal_long(obj,(long*)val);
1531 }
1532 #endif
1533
1534
1535 SWIGINTERNSHORT int
1536 SWIG_As_int(PyObject* obj)
1537 {
1538 int v;
1539 if (!SWIG_AsVal_int(obj, &v)) {
1540 /*
1541 this is needed to make valgrind/purify happier.
1542 */
1543 memset((void*)&v, 0, sizeof(int));
1544 }
1545 return v;
1546 }
1547
1548
1549 SWIGINTERNSHORT int
1550 SWIG_Check_int(PyObject* obj)
1551 {
1552 return SWIG_AsVal_int(obj, (int*)0);
1553 }
1554
1555 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1556
1557 #include <wx/stockitem.h>
1558
1559 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1560 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1561 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1562
1563 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1564 #define SWIG_From_long PyInt_FromLong
1565 /*@@*/
1566
1567
1568 SWIGINTERNSHORT long
1569 SWIG_As_long(PyObject* obj)
1570 {
1571 long v;
1572 if (!SWIG_AsVal_long(obj, &v)) {
1573 /*
1574 this is needed to make valgrind/purify happier.
1575 */
1576 memset((void*)&v, 0, sizeof(long));
1577 }
1578 return v;
1579 }
1580
1581
1582 SWIGINTERNSHORT int
1583 SWIG_Check_long(PyObject* obj)
1584 {
1585 return SWIG_AsVal_long(obj, (long*)0);
1586 }
1587
1588
1589 SWIGINTERN int
1590 SWIG_AsVal_bool(PyObject *obj, bool *val)
1591 {
1592 if (obj == Py_True) {
1593 if (val) *val = true;
1594 return 1;
1595 }
1596 if (obj == Py_False) {
1597 if (val) *val = false;
1598 return 1;
1599 }
1600 int res = 0;
1601 if (SWIG_AsVal_int(obj, &res)) {
1602 if (val) *val = res ? true : false;
1603 return 1;
1604 } else {
1605 PyErr_Clear();
1606 }
1607 if (val) {
1608 SWIG_type_error("bool", obj);
1609 }
1610 return 0;
1611 }
1612
1613
1614 SWIGINTERNSHORT bool
1615 SWIG_As_bool(PyObject* obj)
1616 {
1617 bool v;
1618 if (!SWIG_AsVal_bool(obj, &v)) {
1619 /*
1620 this is needed to make valgrind/purify happier.
1621 */
1622 memset((void*)&v, 0, sizeof(bool));
1623 }
1624 return v;
1625 }
1626
1627
1628 SWIGINTERNSHORT int
1629 SWIG_Check_bool(PyObject* obj)
1630 {
1631 return SWIG_AsVal_bool(obj, (bool*)0);
1632 }
1633
1634
1635 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1636 PyObject* o2;
1637 PyObject* o3;
1638
1639 if (!target) {
1640 target = o;
1641 } else if (target == Py_None) {
1642 Py_DECREF(Py_None);
1643 target = o;
1644 } else {
1645 if (!PyTuple_Check(target)) {
1646 o2 = target;
1647 target = PyTuple_New(1);
1648 PyTuple_SetItem(target, 0, o2);
1649 }
1650 o3 = PyTuple_New(1);
1651 PyTuple_SetItem(o3, 0, o);
1652
1653 o2 = target;
1654 target = PySequence_Concat(o2, o3);
1655 Py_DECREF(o2);
1656 Py_DECREF(o3);
1657 }
1658 return target;
1659 }
1660
1661
1662
1663 SWIGINTERN int
1664 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1665 {
1666 long v = 0;
1667 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1668 SWIG_type_error("unsigned number", obj);
1669 }
1670 else if (val)
1671 *val = (unsigned long)v;
1672 return 1;
1673 }
1674
1675
1676 SWIGINTERNSHORT unsigned long
1677 SWIG_As_unsigned_SS_long(PyObject* obj)
1678 {
1679 unsigned long v;
1680 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1681 /*
1682 this is needed to make valgrind/purify happier.
1683 */
1684 memset((void*)&v, 0, sizeof(unsigned long));
1685 }
1686 return v;
1687 }
1688
1689
1690 SWIGINTERNSHORT int
1691 SWIG_Check_unsigned_SS_long(PyObject* obj)
1692 {
1693 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1694 }
1695
1696
1697 SWIGINTERNSHORT PyObject*
1698 SWIG_From_unsigned_SS_long(unsigned long value)
1699 {
1700 return (value > LONG_MAX) ?
1701 PyLong_FromUnsignedLong(value)
1702 : PyInt_FromLong((long)(value));
1703 }
1704
1705
1706 void* wxGetXDisplay()
1707 {
1708 #ifdef __WXGTK__
1709 return wxGetDisplay();
1710 #else
1711 return NULL;
1712 #endif
1713 }
1714
1715
1716 bool wxThread_IsMain() {
1717 #ifdef WXP_WITH_THREAD
1718 return wxThread::IsMain();
1719 #else
1720 return true;
1721 #endif
1722 }
1723
1724 static void wxCaret_Destroy(wxCaret *self){
1725 delete self;
1726 }
1727
1728 #include <wx/snglinst.h>
1729
1730
1731 #ifdef __WXMSW__
1732 #include <wx/msw/private.h>
1733 #include <wx/dynload.h>
1734 #endif
1735
1736
1737
1738 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1739 #if 0
1740 , int method
1741 #endif
1742 )
1743 {
1744 #ifdef __WXMSW__
1745 #if 0
1746 switch (method)
1747 {
1748 case 1:
1749 // This one only partially works. Appears to be an undocumented
1750 // "standard" convention that not all widgets adhear to. For
1751 // example, for some widgets backgrounds or non-client areas may
1752 // not be painted.
1753 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1754 break;
1755
1756 case 2:
1757 #endif
1758 // This one works much better, nearly all widgets and their
1759 // children are captured correctly[**]. Prior to the big
1760 // background erase changes that Vadim did in 2004-2005 this
1761 // method failed badly on XP with Themes activated, most native
1762 // widgets draw only partially, if at all. Without themes it
1763 // worked just like on Win2k. After those changes this method
1764 // works very well.
1765 //
1766 // ** For example the radio buttons in a wxRadioBox are not its
1767 // children by default, but you can capture it via the panel
1768 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1769 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1770 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1771 PRF_ERASEBKGND | PRF_OWNED );
1772 return true;
1773 #if 0
1774 break;
1775
1776 case 3:
1777 // This one is only defined in the latest SDK and is only
1778 // available on XP. MSDN says it is similar to sending WM_PRINT
1779 // so I expect that it will work similar to the above. Since it
1780 // is avaialble only on XP, it can't be compiled like this and
1781 // will have to be loaded dynamically.
1782 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1783
1784 // fall through
1785
1786 case 4:
1787 // Use PrintWindow if available, or fallback to WM_PRINT
1788 // otherwise. Unfortunately using PrintWindow is even worse than
1789 // WM_PRINT. For most native widgets nothing is drawn to the dc
1790 // at all, with or without Themes.
1791 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1792 static bool s_triedToLoad = false;
1793 static PrintWindow_t pfnPrintWindow = NULL;
1794 if ( !s_triedToLoad )
1795 {
1796
1797 s_triedToLoad = true;
1798 wxDynamicLibrary dllUser32(_T("user32.dll"));
1799 if ( dllUser32.IsLoaded() )
1800 {
1801 wxLogNull nolog; // Don't report errors here
1802 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1803 }
1804 }
1805 if (pfnPrintWindow)
1806 {
1807 //printf("Using PrintWindow\n");
1808 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1809 }
1810 else
1811 {
1812 //printf("Using WM_PRINT\n");
1813 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1814 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1815 PRF_ERASEBKGND | PRF_OWNED );
1816 }
1817 }
1818 #endif // 0
1819 #else
1820 return false;
1821 #endif // __WXMSW__
1822 }
1823
1824
1825
1826 #include <wx/tipdlg.h>
1827
1828
1829 class wxPyTipProvider : public wxTipProvider {
1830 public:
1831 wxPyTipProvider(size_t currentTip)
1832 : wxTipProvider(currentTip) {}
1833
1834 DEC_PYCALLBACK_STRING__pure(GetTip);
1835 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1836 PYPRIVATE;
1837 };
1838
1839 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1840 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1841
1842
1843 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1844
1845 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1846
1847 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1848 : wxTimer(owner, id)
1849 {
1850 if (owner == NULL) SetOwner(this);
1851 }
1852
1853
1854 void wxPyTimer::Notify() {
1855 bool found;
1856 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1857 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1858 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1859 wxPyEndBlockThreads(blocked);
1860 if (! found)
1861 wxTimer::Notify();
1862 }
1863 void wxPyTimer::base_Notify() {
1864 wxTimer::Notify();
1865 }
1866
1867
1868
1869 SWIGINTERN PyObject *
1870 SWIG_FromCharPtr(const char* cptr)
1871 {
1872 if (cptr) {
1873 size_t size = strlen(cptr);
1874 if (size > INT_MAX) {
1875 return SWIG_NewPointerObj((char*)(cptr),
1876 SWIG_TypeQuery("char *"), 0);
1877 } else {
1878 if (size != 0) {
1879 return PyString_FromStringAndSize(cptr, size);
1880 } else {
1881 return PyString_FromString(cptr);
1882 }
1883 }
1884 }
1885 Py_INCREF(Py_None);
1886 return Py_None;
1887 }
1888
1889
1890 SWIGINTERNSHORT int
1891 SWIG_CheckUnsignedLongInRange(unsigned long value,
1892 unsigned long max_value,
1893 const char *errmsg)
1894 {
1895 if (value > max_value) {
1896 if (errmsg) {
1897 PyErr_Format(PyExc_OverflowError,
1898 "value %lu is greater than '%s' minimum %lu",
1899 value, errmsg, max_value);
1900 }
1901 return 0;
1902 }
1903 return 1;
1904 }
1905
1906
1907 #if UINT_MAX != ULONG_MAX
1908 SWIGINTERN int
1909 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1910 {
1911 const char* errmsg = val ? "unsigned int" : (char*)0;
1912 unsigned long v;
1913 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1914 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1915 if (val) *val = (unsigned int)(v);
1916 return 1;
1917 }
1918 } else {
1919 PyErr_Clear();
1920 }
1921 if (val) {
1922 SWIG_type_error(errmsg, obj);
1923 }
1924 return 0;
1925 }
1926 #else
1927 SWIGINTERNSHORT unsigned int
1928 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1929 {
1930 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1931 }
1932 #endif
1933
1934
1935 SWIGINTERNSHORT unsigned int
1936 SWIG_As_unsigned_SS_int(PyObject* obj)
1937 {
1938 unsigned int v;
1939 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1940 /*
1941 this is needed to make valgrind/purify happier.
1942 */
1943 memset((void*)&v, 0, sizeof(unsigned int));
1944 }
1945 return v;
1946 }
1947
1948
1949 SWIGINTERNSHORT int
1950 SWIG_Check_unsigned_SS_int(PyObject* obj)
1951 {
1952 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1953 }
1954
1955 static wxString Log_TimeStamp(){
1956 wxString msg;
1957 wxLog::TimeStamp(&msg);
1958 return msg;
1959 }
1960 static void wxLog_Destroy(wxLog *self){ delete self; }
1961 // Make somce wrappers that double any % signs so they are 'escaped'
1962 void wxPyLogFatalError(const wxString& msg)
1963 {
1964 wxString m(msg);
1965 m.Replace(wxT("%"), wxT("%%"));
1966 wxLogFatalError(m);
1967 }
1968
1969 void wxPyLogError(const wxString& msg)
1970 {
1971 wxString m(msg);
1972 m.Replace(wxT("%"), wxT("%%"));
1973 wxLogError(m);
1974 }
1975
1976 void wxPyLogWarning(const wxString& msg)
1977 {
1978 wxString m(msg);
1979 m.Replace(wxT("%"), wxT("%%"));
1980 wxLogWarning(m);
1981 }
1982
1983 void wxPyLogMessage(const wxString& msg)
1984 {
1985 wxString m(msg);
1986 m.Replace(wxT("%"), wxT("%%"));
1987 wxLogMessage(m);
1988 }
1989
1990 void wxPyLogInfo(const wxString& msg)
1991 {
1992 wxString m(msg);
1993 m.Replace(wxT("%"), wxT("%%"));
1994 wxLogInfo(m);
1995 }
1996
1997 void wxPyLogDebug(const wxString& msg)
1998 {
1999 wxString m(msg);
2000 m.Replace(wxT("%"), wxT("%%"));
2001 wxLogDebug(m);
2002 }
2003
2004 void wxPyLogVerbose(const wxString& msg)
2005 {
2006 wxString m(msg);
2007 m.Replace(wxT("%"), wxT("%%"));
2008 wxLogVerbose(m);
2009 }
2010
2011 void wxPyLogStatus(const wxString& msg)
2012 {
2013 wxString m(msg);
2014 m.Replace(wxT("%"), wxT("%%"));
2015 wxLogStatus(m);
2016 }
2017
2018 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2019 {
2020 wxString m(msg);
2021 m.Replace(wxT("%"), wxT("%%"));
2022 wxLogStatus(pFrame, m);
2023 }
2024
2025 void wxPyLogSysError(const wxString& msg)
2026 {
2027 wxString m(msg);
2028 m.Replace(wxT("%"), wxT("%%"));
2029 wxLogSysError(m);
2030 }
2031
2032 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2033 {
2034 wxString m(msg);
2035 m.Replace(wxT("%"), wxT("%%"));
2036 wxLogGeneric(level, m);
2037 }
2038
2039 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2040 {
2041 wxString m(msg);
2042 m.Replace(wxT("%"), wxT("%%"));
2043 wxLogTrace(mask, m);
2044 }
2045
2046 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2047 {
2048 wxString m(msg);
2049 m.Replace(wxT("%"), wxT("%%"));
2050 wxLogTrace(mask, m);
2051 }
2052
2053
2054
2055 // A wxLog class that can be derived from in wxPython
2056 class wxPyLog : public wxLog {
2057 public:
2058 wxPyLog() : wxLog() {}
2059
2060 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2061 bool found;
2062 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2063 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2064 PyObject* s = wx2PyString(szString);
2065 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2066 Py_DECREF(s);
2067 }
2068 wxPyEndBlockThreads(blocked);
2069 if (! found)
2070 wxLog::DoLog(level, szString, t);
2071 }
2072
2073 virtual void DoLogString(const wxChar *szString, time_t t) {
2074 bool found;
2075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2076 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2077 PyObject* s = wx2PyString(szString);
2078 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2079 Py_DECREF(s);
2080 }
2081 wxPyEndBlockThreads(blocked);
2082 if (! found)
2083 wxLog::DoLogString(szString, t);
2084 }
2085
2086 PYPRIVATE;
2087 };
2088
2089
2090
2091
2092 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2093
2094
2095 #include <wx/joystick.h>
2096
2097
2098 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2099 // A C++ stub class for wxJoystick for platforms that don't have it.
2100 class wxJoystick : public wxObject {
2101 public:
2102 wxJoystick(int joystick = wxJOYSTICK1) {
2103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2104 PyErr_SetString(PyExc_NotImplementedError,
2105 "wxJoystick is not available on this platform.");
2106 wxPyEndBlockThreads(blocked);
2107 }
2108 wxPoint GetPosition() { return wxPoint(-1,-1); }
2109 int GetZPosition() { return -1; }
2110 int GetButtonState() { return -1; }
2111 int GetPOVPosition() { return -1; }
2112 int GetPOVCTSPosition() { return -1; }
2113 int GetRudderPosition() { return -1; }
2114 int GetUPosition() { return -1; }
2115 int GetVPosition() { return -1; }
2116 int GetMovementThreshold() { return -1; }
2117 void SetMovementThreshold(int threshold) {}
2118
2119 bool IsOk(void) { return false; }
2120 int GetNumberJoysticks() { return -1; }
2121 int GetManufacturerId() { return -1; }
2122 int GetProductId() { return -1; }
2123 wxString GetProductName() { return wxEmptyString; }
2124 int GetXMin() { return -1; }
2125 int GetYMin() { return -1; }
2126 int GetZMin() { return -1; }
2127 int GetXMax() { return -1; }
2128 int GetYMax() { return -1; }
2129 int GetZMax() { return -1; }
2130 int GetNumberButtons() { return -1; }
2131 int GetNumberAxes() { return -1; }
2132 int GetMaxButtons() { return -1; }
2133 int GetMaxAxes() { return -1; }
2134 int GetPollingMin() { return -1; }
2135 int GetPollingMax() { return -1; }
2136 int GetRudderMin() { return -1; }
2137 int GetRudderMax() { return -1; }
2138 int GetUMin() { return -1; }
2139 int GetUMax() { return -1; }
2140 int GetVMin() { return -1; }
2141 int GetVMax() { return -1; }
2142
2143 bool HasRudder() { return false; }
2144 bool HasZ() { return false; }
2145 bool HasU() { return false; }
2146 bool HasV() { return false; }
2147 bool HasPOV() { return false; }
2148 bool HasPOV4Dir() { return false; }
2149 bool HasPOVCTS() { return false; }
2150
2151 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2152 bool ReleaseCapture() { return false; }
2153 };
2154 #endif
2155
2156
2157 #include <wx/sound.h>
2158
2159
2160 #if !wxUSE_SOUND
2161 // A C++ stub class for wxWave for platforms that don't have it.
2162 class wxSound : public wxObject
2163 {
2164 public:
2165 wxSound() {
2166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171 wxSound(const wxString&/*, bool*/) {
2172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2173 PyErr_SetString(PyExc_NotImplementedError,
2174 "wxSound is not available on this platform.");
2175 wxPyEndBlockThreads(blocked);
2176 }
2177 wxSound(int, const wxByte*) {
2178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2179 PyErr_SetString(PyExc_NotImplementedError,
2180 "wxSound is not available on this platform.");
2181 wxPyEndBlockThreads(blocked);
2182 }
2183
2184 ~wxSound() {};
2185
2186 bool Create(const wxString&/*, bool*/) { return false; }
2187 bool Create(int, const wxByte*) { return false; };
2188 bool IsOk() { return false; };
2189 bool Play(unsigned) const { return false; }
2190 static bool Play(const wxString&, unsigned) { return false; }
2191 static void Stop() {}
2192 };
2193
2194 #endif
2195
2196 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2197 if (fileName.Length() == 0)
2198 return new wxSound;
2199 else
2200 return new wxSound(fileName);
2201 }
2202 static wxSound *new_wxSound(PyObject *data){
2203 unsigned char* buffer; int size;
2204 wxSound *sound = NULL;
2205
2206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2207 if (!PyArg_Parse(data, "t#", &buffer, &size))
2208 goto done;
2209 sound = new wxSound(size, buffer);
2210 done:
2211 wxPyEndBlockThreads(blocked);
2212 return sound;
2213 }
2214 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2215 #ifndef __WXMAC__
2216 unsigned char* buffer;
2217 int size;
2218 bool rv = false;
2219
2220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2221 if (!PyArg_Parse(data, "t#", &buffer, &size))
2222 goto done;
2223 rv = self->Create(size, buffer);
2224 done:
2225 wxPyEndBlockThreads(blocked);
2226 return rv;
2227 #else
2228 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2229 PyErr_SetString(PyExc_NotImplementedError,
2230 "Create from data is not available on this platform.");
2231 wxPyEndBlockThreads(blocked);
2232 return false;
2233 #endif
2234 }
2235
2236 #include <wx/mimetype.h>
2237
2238 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2239 wxString str;
2240 if (self->GetMimeType(&str))
2241 return wx2PyString(str);
2242 else
2243 RETURN_NONE();
2244 }
2245 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2246 wxArrayString arr;
2247 if (self->GetMimeTypes(arr))
2248 return wxArrayString2PyList_helper(arr);
2249 else
2250 RETURN_NONE();
2251 }
2252 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2253 wxArrayString arr;
2254 if (self->GetExtensions(arr))
2255 return wxArrayString2PyList_helper(arr);
2256 else
2257 RETURN_NONE();
2258 }
2259 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2260 wxIconLocation loc;
2261 if (self->GetIcon(&loc))
2262 return new wxIcon(loc);
2263 else
2264 return NULL;
2265 }
2266 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2267 wxIconLocation loc;
2268 if (self->GetIcon(&loc)) {
2269 wxString iconFile = loc.GetFileName();
2270 int iconIndex = -1;
2271
2272 iconIndex = loc.GetIndex();
2273
2274 // Make a tuple and put the values in it
2275 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2276 PyObject* tuple = PyTuple_New(3);
2277 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2278 wxT("wxIcon"), true));
2279 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2280 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2281 wxPyEndBlockThreads(blocked);
2282 return tuple;
2283 }
2284 else
2285 RETURN_NONE();
2286 }
2287 static PyObject *wxFileType_GetDescription(wxFileType *self){
2288 wxString str;
2289 if (self->GetDescription(&str))
2290 return wx2PyString(str);
2291 else
2292 RETURN_NONE();
2293 }
2294 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2295 wxString str;
2296 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2297 return wx2PyString(str);
2298 else
2299 RETURN_NONE();
2300 }
2301 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2302 wxString str;
2303 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2304 return wx2PyString(str);
2305 else
2306 RETURN_NONE();
2307 }
2308 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2309 wxArrayString verbs;
2310 wxArrayString commands;
2311 if (self->GetAllCommands(&verbs, &commands,
2312 wxFileType::MessageParameters(filename, mimetype))) {
2313 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2314 PyObject* tuple = PyTuple_New(2);
2315 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2316 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2317 wxPyEndBlockThreads(blocked);
2318 return tuple;
2319 }
2320 else
2321 RETURN_NONE();
2322 }
2323 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2324 return wxFileType::ExpandCommand(command,
2325 wxFileType::MessageParameters(filename, mimetype));
2326 }
2327 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2328 wxArrayString arr;
2329 self->EnumAllFileTypes(arr);
2330 return wxArrayString2PyList_helper(arr);
2331 }
2332
2333 #include <wx/artprov.h>
2334
2335 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2336 static const wxString wxPyART_MENU(wxART_MENU);
2337 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2338 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2339 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2340 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2341 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2342 static const wxString wxPyART_OTHER(wxART_OTHER);
2343 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2344 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2345 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2346 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2347 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2348 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2349 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2350 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2351 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2352 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2353 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2354 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2355 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2356 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2357 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2358 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2359 static const wxString wxPyART_PRINT(wxART_PRINT);
2360 static const wxString wxPyART_HELP(wxART_HELP);
2361 static const wxString wxPyART_TIP(wxART_TIP);
2362 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2363 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2364 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2365 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2366 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2367 static const wxString wxPyART_CDROM(wxART_CDROM);
2368 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2369 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2370 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2371 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2372 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2373 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2374 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2375 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2376 static const wxString wxPyART_ERROR(wxART_ERROR);
2377 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2378 static const wxString wxPyART_WARNING(wxART_WARNING);
2379 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2380 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2381 static const wxString wxPyART_COPY(wxART_COPY);
2382 static const wxString wxPyART_CUT(wxART_CUT);
2383 static const wxString wxPyART_PASTE(wxART_PASTE);
2384 static const wxString wxPyART_DELETE(wxART_DELETE);
2385 static const wxString wxPyART_UNDO(wxART_UNDO);
2386 static const wxString wxPyART_REDO(wxART_REDO);
2387 static const wxString wxPyART_QUIT(wxART_QUIT);
2388 static const wxString wxPyART_FIND(wxART_FIND);
2389 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2390 // Python aware wxArtProvider
2391 class wxPyArtProvider : public wxArtProvider {
2392 public:
2393
2394 virtual wxBitmap CreateBitmap(const wxArtID& id,
2395 const wxArtClient& client,
2396 const wxSize& size) {
2397 wxBitmap rval = wxNullBitmap;
2398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2399 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2400 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2401 PyObject* ro;
2402 wxBitmap* ptr;
2403 PyObject* s1, *s2;
2404 s1 = wx2PyString(id);
2405 s2 = wx2PyString(client);
2406 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2407 Py_DECREF(so);
2408 Py_DECREF(s1);
2409 Py_DECREF(s2);
2410 if (ro) {
2411 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2412 rval = *ptr;
2413 Py_DECREF(ro);
2414 }
2415 }
2416 wxPyEndBlockThreads(blocked);
2417 return rval;
2418 }
2419
2420 PYPRIVATE;
2421 };
2422
2423 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2424
2425
2426
2427 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2428 PyObject* ret = PyTuple_New(3);
2429 if (ret) {
2430 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2431 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2432 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2433 }
2434 return ret;
2435 }
2436
2437 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2438 bool cont;
2439 long index = 0;
2440 wxString value;
2441
2442 cont = self->GetFirstGroup(value, index);
2443 return __EnumerationHelper(cont, value, index);
2444 }
2445 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2446 bool cont;
2447 wxString value;
2448
2449 cont = self->GetNextGroup(value, index);
2450 return __EnumerationHelper(cont, value, index);
2451 }
2452 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2453 bool cont;
2454 long index = 0;
2455 wxString value;
2456
2457 cont = self->GetFirstEntry(value, index);
2458 return __EnumerationHelper(cont, value, index);
2459 }
2460 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2461 bool cont;
2462 wxString value;
2463
2464 cont = self->GetNextEntry(value, index);
2465 return __EnumerationHelper(cont, value, index);
2466 }
2467 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2468 long rv;
2469 self->Read(key, &rv, defaultVal);
2470 return rv;
2471 }
2472
2473 SWIGINTERN int
2474 SWIG_AsVal_double(PyObject *obj, double* val)
2475 {
2476 if (PyNumber_Check(obj)) {
2477 if (val) *val = PyFloat_AsDouble(obj);
2478 return 1;
2479 }
2480 else {
2481 SWIG_type_error("number", obj);
2482 }
2483 return 0;
2484 }
2485
2486
2487 SWIGINTERNSHORT double
2488 SWIG_As_double(PyObject* obj)
2489 {
2490 double v;
2491 if (!SWIG_AsVal_double(obj, &v)) {
2492 /*
2493 this is needed to make valgrind/purify happier.
2494 */
2495 memset((void*)&v, 0, sizeof(double));
2496 }
2497 return v;
2498 }
2499
2500
2501 SWIGINTERNSHORT int
2502 SWIG_Check_double(PyObject* obj)
2503 {
2504 return SWIG_AsVal_double(obj, (double*)0);
2505 }
2506
2507 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2508 double rv;
2509 self->Read(key, &rv, defaultVal);
2510 return rv;
2511 }
2512
2513 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2514 #define SWIG_From_double PyFloat_FromDouble
2515 /*@@*/
2516
2517 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2518 bool rv;
2519 self->Read(key, &rv, defaultVal);
2520 return rv;
2521 }
2522
2523 #include <wx/datetime.h>
2524
2525 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2526 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2527
2528 #define LOCAL_TZ wxDateTime::Local
2529
2530 static PyObject *DateTime_GetAmPmStrings(){
2531 wxString am;
2532 wxString pm;
2533 wxDateTime::GetAmPmStrings(&am, &pm);
2534 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2535 PyObject* tup = PyTuple_New(2);
2536 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2537 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2538 wxPyEndBlockThreads(blocked);
2539 return tup;
2540 }
2541
2542 #if UINT_MAX < LONG_MAX
2543 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2544 #define SWIG_From_unsigned_SS_int SWIG_From_long
2545 /*@@*/
2546 #else
2547 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2548 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2549 /*@@*/
2550 #endif
2551
2552 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2553 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2554 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2555 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2556 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2557 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2558 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2559 return (*self < *other);
2560 }
2561 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2562 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2563 return (*self <= *other);
2564 }
2565 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2566 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2567 return (*self > *other);
2568 }
2569 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2570 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2571 return (*self >= *other);
2572 }
2573 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2574 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2575 return (*self == *other);
2576 }
2577 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2578 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2579 return (*self != *other);
2580 }
2581 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2582 const wxChar* rv;
2583 const wxChar* _date = date;
2584 rv = self->ParseRfc822Date(_date);
2585 if (rv == NULL) return -1;
2586 return rv - _date;
2587 }
2588 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2589 const wxChar* rv;
2590 const wxChar* _date = date;
2591 rv = self->ParseFormat(_date, format, dateDef);
2592 if (rv == NULL) return -1;
2593 return rv - _date;
2594 }
2595 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2596 const wxChar* rv;
2597 const wxChar* _datetime = datetime;
2598 rv = self->ParseDateTime(_datetime);
2599 if (rv == NULL) return -1;
2600 return rv - _datetime;
2601 }
2602 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2603 const wxChar* rv;
2604 const wxChar* _date = date;
2605 rv = self->ParseDate(_date);
2606 if (rv == NULL) return -1;
2607 return rv - _date;
2608 }
2609 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2610 const wxChar* rv;
2611 const wxChar* _time = time;
2612 rv = self->ParseTime(_time);
2613 if (rv == NULL) return -1;
2614 return rv - _time;
2615 }
2616 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2617 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2618 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2619 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2620 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2621 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2622 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2623 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2624 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2625 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2626 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2627 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2628 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2629 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2630 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2631 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2632
2633 #include <wx/dataobj.h>
2634
2635 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2636 size_t count = self->GetFormatCount(dir);
2637 wxDataFormat* formats = new wxDataFormat[count];
2638 self->GetAllFormats(formats, dir);
2639
2640 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2641 PyObject* list = PyList_New(count);
2642 for (size_t i=0; i<count; i++) {
2643 wxDataFormat* format = new wxDataFormat(formats[i]);
2644 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2645 PyList_Append(list, obj);
2646 Py_DECREF(obj);
2647 }
2648 wxPyEndBlockThreads(blocked);
2649 delete [] formats;
2650 return list;
2651 }
2652 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2653 PyObject* rval = NULL;
2654 size_t size = self->GetDataSize(format);
2655 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2656 if (size) {
2657 char* buf = new char[size];
2658 if (self->GetDataHere(format, buf))
2659 rval = PyString_FromStringAndSize(buf, size);
2660 delete [] buf;
2661 }
2662 if (! rval) {
2663 rval = Py_None;
2664 Py_INCREF(rval);
2665 }
2666 wxPyEndBlockThreads(blocked);
2667 return rval;
2668 }
2669 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2670 bool rval;
2671 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2672 if (PyString_Check(data)) {
2673 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2674 }
2675 else {
2676 // raise a TypeError if not a string
2677 PyErr_SetString(PyExc_TypeError, "String expected.");
2678 rval = false;
2679 }
2680 wxPyEndBlockThreads(blocked);
2681 return rval;
2682 }
2683 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2684 PyObject* rval = NULL;
2685 size_t size = self->GetDataSize();
2686 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2687 if (size) {
2688 char* buf = new char[size];
2689 if (self->GetDataHere(buf))
2690 rval = PyString_FromStringAndSize(buf, size);
2691 delete [] buf;
2692 }
2693 if (! rval) {
2694 rval = Py_None;
2695 Py_INCREF(rval);
2696 }
2697 wxPyEndBlockThreads(blocked);
2698 return rval;
2699 }
2700 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2701 bool rval;
2702 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2703 if (PyString_Check(data)) {
2704 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2705 }
2706 else {
2707 // raise a TypeError if not a string
2708 PyErr_SetString(PyExc_TypeError, "String expected.");
2709 rval = false;
2710 }
2711 wxPyEndBlockThreads(blocked);
2712 return rval;
2713 }
2714 // Create a new class for wxPython to use
2715 class wxPyDataObjectSimple : public wxDataObjectSimple {
2716 public:
2717 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2718 : wxDataObjectSimple(format) {}
2719
2720 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2721 bool GetDataHere(void *buf) const;
2722 bool SetData(size_t len, const void *buf) const;
2723 PYPRIVATE;
2724 };
2725
2726 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2727
2728 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2729 // We need to get the data for this object and write it to buf. I think
2730 // the best way to do this for wxPython is to have the Python method
2731 // return either a string or None and then act appropriately with the
2732 // C++ version.
2733
2734 bool rval = false;
2735 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2736 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2737 PyObject* ro;
2738 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2739 if (ro) {
2740 rval = (ro != Py_None && PyString_Check(ro));
2741 if (rval)
2742 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2743 Py_DECREF(ro);
2744 }
2745 }
2746 wxPyEndBlockThreads(blocked);
2747 return rval;
2748 }
2749
2750 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2751 // For this one we simply need to make a string from buf and len
2752 // and send it to the Python method.
2753 bool rval = false;
2754 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2755 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2756 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2757 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2758 Py_DECREF(data);
2759 }
2760 wxPyEndBlockThreads(blocked);
2761 return rval;
2762 }
2763
2764 // Create a new class for wxPython to use
2765 class wxPyTextDataObject : public wxTextDataObject {
2766 public:
2767 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2768 : wxTextDataObject(text) {}
2769
2770 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2771 DEC_PYCALLBACK_STRING__const(GetText);
2772 DEC_PYCALLBACK__STRING(SetText);
2773 PYPRIVATE;
2774 };
2775
2776 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2777 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2778 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2779
2780
2781 // Create a new class for wxPython to use
2782 class wxPyBitmapDataObject : public wxBitmapDataObject {
2783 public:
2784 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2785 : wxBitmapDataObject(bitmap) {}
2786
2787 wxBitmap GetBitmap() const;
2788 void SetBitmap(const wxBitmap& bitmap);
2789 PYPRIVATE;
2790 };
2791
2792 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2793 wxBitmap* rval = &wxNullBitmap;
2794 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2795 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2796 PyObject* ro;
2797 wxBitmap* ptr;
2798 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2799 if (ro) {
2800 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2801 rval = ptr;
2802 Py_DECREF(ro);
2803 }
2804 }
2805 wxPyEndBlockThreads(blocked);
2806 return *rval;
2807 }
2808
2809 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2810 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2811 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2812 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2813 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2814 Py_DECREF(bo);
2815 }
2816 wxPyEndBlockThreads(blocked);
2817 }
2818
2819 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2820 return new wxCustomDataObject(wxDataFormat(formatName));
2821 }
2822 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2823 bool rval;
2824 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2825 if (PyString_Check(data)) {
2826 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2827 }
2828 else {
2829 // raise a TypeError if not a string
2830 PyErr_SetString(PyExc_TypeError, "String expected.");
2831 rval = false;
2832 }
2833 wxPyEndBlockThreads(blocked);
2834 return rval;
2835 }
2836 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2837 PyObject* obj;
2838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2839 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2840 wxPyEndBlockThreads(blocked);
2841 return obj;
2842 }
2843
2844 #include <wx/metafile.h>
2845
2846
2847 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2848
2849
2850 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2851 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2852 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2853 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2854 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2855
2856
2857 class wxPyTextDropTarget : public wxTextDropTarget {
2858 public:
2859 wxPyTextDropTarget() {}
2860
2861 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2862
2863 DEC_PYCALLBACK__(OnLeave);
2864 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2865 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2866 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2867 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2868
2869 PYPRIVATE;
2870 };
2871
2872 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2873 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2874 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2875 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2876 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2877 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2878
2879
2880
2881 class wxPyFileDropTarget : public wxFileDropTarget {
2882 public:
2883 wxPyFileDropTarget() {}
2884
2885 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2886
2887 DEC_PYCALLBACK__(OnLeave);
2888 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2889 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2890 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2891 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2892
2893 PYPRIVATE;
2894 };
2895
2896 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2897 const wxArrayString& filenames) {
2898 bool rval = false;
2899 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2900 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2901 PyObject* list = wxArrayString2PyList_helper(filenames);
2902 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2903 Py_DECREF(list);
2904 }
2905 wxPyEndBlockThreads(blocked);
2906 return rval;
2907 }
2908
2909
2910
2911 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2912 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2913 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2914 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2915 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2916
2917
2918
2919
2920 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2921
2922 #include <wx/display.h>
2923
2924 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2925 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2926
2927 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2928 #if !wxUSE_DISPLAY
2929 #include <wx/dynarray.h>
2930 #include <wx/vidmode.h>
2931
2932 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2933 #include "wx/arrimpl.cpp"
2934 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2935 const wxVideoMode wxDefaultVideoMode;
2936
2937 class wxDisplay
2938 {
2939 public:
2940 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2941 ~wxDisplay() {}
2942
2943 static size_t GetCount()
2944 { wxPyRaiseNotImplemented(); return 0; }
2945
2946 static int GetFromPoint(const wxPoint& pt)
2947 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2948 static int GetFromWindow(wxWindow *window)
2949 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2950
2951 virtual bool IsOk() const { return false; }
2952 virtual wxRect GetGeometry() const { wxRect r; return r; }
2953 virtual wxString GetName() const { return wxEmptyString; }
2954 bool IsPrimary() const { return false; }
2955
2956 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2957 { wxArrayVideoModes a; return a; }
2958
2959 virtual wxVideoMode GetCurrentMode() const
2960 { return wxDefaultVideoMode; }
2961
2962 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2963 { return false; }
2964
2965 void ResetMode() {}
2966 };
2967 #endif
2968
2969 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2970 PyObject* pyList = NULL;
2971 wxArrayVideoModes arr = self->GetModes(mode);
2972 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2973 pyList = PyList_New(0);
2974 for (int i=0; i < arr.GetCount(); i++) {
2975 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2976 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2977 PyList_Append(pyList, pyObj);
2978 Py_DECREF(pyObj);
2979 }
2980 wxPyEndBlockThreads(blocked);
2981 return pyList;
2982 }
2983
2984 #include <wx/stdpaths.h>
2985
2986 static wxStandardPaths *StandardPaths_Get(){
2987 return (wxStandardPaths*) &wxStandardPaths::Get();
2988 }
2989 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2990 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2991 #ifdef __cplusplus
2992 extern "C" {
2993 #endif
2994 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2995 PyObject *resultobj;
2996 wxSystemColour arg1 ;
2997 wxColour result;
2998 PyObject * obj0 = 0 ;
2999 char *kwnames[] = {
3000 (char *) "index", NULL
3001 };
3002
3003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3004 {
3005 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3006 if (SWIG_arg_fail(1)) SWIG_fail;
3007 }
3008 {
3009 if (!wxPyCheckForApp()) SWIG_fail;
3010 PyThreadState* __tstate = wxPyBeginAllowThreads();
3011 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3012
3013 wxPyEndAllowThreads(__tstate);
3014 if (PyErr_Occurred()) SWIG_fail;
3015 }
3016 {
3017 wxColour * resultptr;
3018 resultptr = new wxColour((wxColour &)(result));
3019 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3020 }
3021 return resultobj;
3022 fail:
3023 return NULL;
3024 }
3025
3026
3027 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3028 PyObject *resultobj;
3029 wxSystemFont arg1 ;
3030 wxFont result;
3031 PyObject * obj0 = 0 ;
3032 char *kwnames[] = {
3033 (char *) "index", NULL
3034 };
3035
3036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3037 {
3038 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3039 if (SWIG_arg_fail(1)) SWIG_fail;
3040 }
3041 {
3042 if (!wxPyCheckForApp()) SWIG_fail;
3043 PyThreadState* __tstate = wxPyBeginAllowThreads();
3044 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3045
3046 wxPyEndAllowThreads(__tstate);
3047 if (PyErr_Occurred()) SWIG_fail;
3048 }
3049 {
3050 wxFont * resultptr;
3051 resultptr = new wxFont((wxFont &)(result));
3052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3053 }
3054 return resultobj;
3055 fail:
3056 return NULL;
3057 }
3058
3059
3060 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3061 PyObject *resultobj;
3062 wxSystemMetric arg1 ;
3063 wxWindow *arg2 = (wxWindow *) NULL ;
3064 int result;
3065 PyObject * obj0 = 0 ;
3066 PyObject * obj1 = 0 ;
3067 char *kwnames[] = {
3068 (char *) "index",(char *) "win", NULL
3069 };
3070
3071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3072 {
3073 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3074 if (SWIG_arg_fail(1)) SWIG_fail;
3075 }
3076 if (obj1) {
3077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3078 if (SWIG_arg_fail(2)) SWIG_fail;
3079 }
3080 {
3081 if (!wxPyCheckForApp()) SWIG_fail;
3082 PyThreadState* __tstate = wxPyBeginAllowThreads();
3083 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3084
3085 wxPyEndAllowThreads(__tstate);
3086 if (PyErr_Occurred()) SWIG_fail;
3087 }
3088 {
3089 resultobj = SWIG_From_int((int)(result));
3090 }
3091 return resultobj;
3092 fail:
3093 return NULL;
3094 }
3095
3096
3097 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3098 PyObject *resultobj;
3099 wxSystemFeature arg1 ;
3100 bool result;
3101 PyObject * obj0 = 0 ;
3102 char *kwnames[] = {
3103 (char *) "index", NULL
3104 };
3105
3106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3107 {
3108 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3109 if (SWIG_arg_fail(1)) SWIG_fail;
3110 }
3111 {
3112 if (!wxPyCheckForApp()) SWIG_fail;
3113 PyThreadState* __tstate = wxPyBeginAllowThreads();
3114 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3115
3116 wxPyEndAllowThreads(__tstate);
3117 if (PyErr_Occurred()) SWIG_fail;
3118 }
3119 {
3120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3121 }
3122 return resultobj;
3123 fail:
3124 return NULL;
3125 }
3126
3127
3128 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3129 PyObject *resultobj;
3130 wxSystemScreenType result;
3131 char *kwnames[] = {
3132 NULL
3133 };
3134
3135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3136 {
3137 if (!wxPyCheckForApp()) SWIG_fail;
3138 PyThreadState* __tstate = wxPyBeginAllowThreads();
3139 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3140
3141 wxPyEndAllowThreads(__tstate);
3142 if (PyErr_Occurred()) SWIG_fail;
3143 }
3144 resultobj = SWIG_From_int((result));
3145 return resultobj;
3146 fail:
3147 return NULL;
3148 }
3149
3150
3151 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3152 PyObject *resultobj;
3153 wxSystemScreenType arg1 ;
3154 PyObject * obj0 = 0 ;
3155 char *kwnames[] = {
3156 (char *) "screen", NULL
3157 };
3158
3159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3160 {
3161 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3162 if (SWIG_arg_fail(1)) SWIG_fail;
3163 }
3164 {
3165 if (!wxPyCheckForApp()) SWIG_fail;
3166 PyThreadState* __tstate = wxPyBeginAllowThreads();
3167 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3168
3169 wxPyEndAllowThreads(__tstate);
3170 if (PyErr_Occurred()) SWIG_fail;
3171 }
3172 Py_INCREF(Py_None); resultobj = Py_None;
3173 return resultobj;
3174 fail:
3175 return NULL;
3176 }
3177
3178
3179 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3180 PyObject *obj;
3181 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3182 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3183 Py_INCREF(obj);
3184 return Py_BuildValue((char *)"");
3185 }
3186 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3187 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3188 return 1;
3189 }
3190
3191
3192 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3193 PyObject *pyobj;
3194
3195 {
3196 #if wxUSE_UNICODE
3197 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3198 #else
3199 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3200 #endif
3201 }
3202 return pyobj;
3203 }
3204
3205
3206 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3207 PyObject *resultobj;
3208 wxSystemOptions *result;
3209 char *kwnames[] = {
3210 NULL
3211 };
3212
3213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3214 {
3215 PyThreadState* __tstate = wxPyBeginAllowThreads();
3216 result = (wxSystemOptions *)new wxSystemOptions();
3217
3218 wxPyEndAllowThreads(__tstate);
3219 if (PyErr_Occurred()) SWIG_fail;
3220 }
3221 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3222 return resultobj;
3223 fail:
3224 return NULL;
3225 }
3226
3227
3228 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3229 PyObject *resultobj;
3230 wxString *arg1 = 0 ;
3231 wxString *arg2 = 0 ;
3232 bool temp1 = false ;
3233 bool temp2 = false ;
3234 PyObject * obj0 = 0 ;
3235 PyObject * obj1 = 0 ;
3236 char *kwnames[] = {
3237 (char *) "name",(char *) "value", NULL
3238 };
3239
3240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3241 {
3242 arg1 = wxString_in_helper(obj0);
3243 if (arg1 == NULL) SWIG_fail;
3244 temp1 = true;
3245 }
3246 {
3247 arg2 = wxString_in_helper(obj1);
3248 if (arg2 == NULL) SWIG_fail;
3249 temp2 = true;
3250 }
3251 {
3252 PyThreadState* __tstate = wxPyBeginAllowThreads();
3253 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3254
3255 wxPyEndAllowThreads(__tstate);
3256 if (PyErr_Occurred()) SWIG_fail;
3257 }
3258 Py_INCREF(Py_None); resultobj = Py_None;
3259 {
3260 if (temp1)
3261 delete arg1;
3262 }
3263 {
3264 if (temp2)
3265 delete arg2;
3266 }
3267 return resultobj;
3268 fail:
3269 {
3270 if (temp1)
3271 delete arg1;
3272 }
3273 {
3274 if (temp2)
3275 delete arg2;
3276 }
3277 return NULL;
3278 }
3279
3280
3281 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3282 PyObject *resultobj;
3283 wxString *arg1 = 0 ;
3284 int arg2 ;
3285 bool temp1 = false ;
3286 PyObject * obj0 = 0 ;
3287 PyObject * obj1 = 0 ;
3288 char *kwnames[] = {
3289 (char *) "name",(char *) "value", NULL
3290 };
3291
3292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3293 {
3294 arg1 = wxString_in_helper(obj0);
3295 if (arg1 == NULL) SWIG_fail;
3296 temp1 = true;
3297 }
3298 {
3299 arg2 = (int)(SWIG_As_int(obj1));
3300 if (SWIG_arg_fail(2)) SWIG_fail;
3301 }
3302 {
3303 PyThreadState* __tstate = wxPyBeginAllowThreads();
3304 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3305
3306 wxPyEndAllowThreads(__tstate);
3307 if (PyErr_Occurred()) SWIG_fail;
3308 }
3309 Py_INCREF(Py_None); resultobj = Py_None;
3310 {
3311 if (temp1)
3312 delete arg1;
3313 }
3314 return resultobj;
3315 fail:
3316 {
3317 if (temp1)
3318 delete arg1;
3319 }
3320 return NULL;
3321 }
3322
3323
3324 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3325 PyObject *resultobj;
3326 wxString *arg1 = 0 ;
3327 wxString result;
3328 bool temp1 = false ;
3329 PyObject * obj0 = 0 ;
3330 char *kwnames[] = {
3331 (char *) "name", NULL
3332 };
3333
3334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3335 {
3336 arg1 = wxString_in_helper(obj0);
3337 if (arg1 == NULL) SWIG_fail;
3338 temp1 = true;
3339 }
3340 {
3341 PyThreadState* __tstate = wxPyBeginAllowThreads();
3342 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3343
3344 wxPyEndAllowThreads(__tstate);
3345 if (PyErr_Occurred()) SWIG_fail;
3346 }
3347 {
3348 #if wxUSE_UNICODE
3349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3350 #else
3351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3352 #endif
3353 }
3354 {
3355 if (temp1)
3356 delete arg1;
3357 }
3358 return resultobj;
3359 fail:
3360 {
3361 if (temp1)
3362 delete arg1;
3363 }
3364 return NULL;
3365 }
3366
3367
3368 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3369 PyObject *resultobj;
3370 wxString *arg1 = 0 ;
3371 int result;
3372 bool temp1 = false ;
3373 PyObject * obj0 = 0 ;
3374 char *kwnames[] = {
3375 (char *) "name", NULL
3376 };
3377
3378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3379 {
3380 arg1 = wxString_in_helper(obj0);
3381 if (arg1 == NULL) SWIG_fail;
3382 temp1 = true;
3383 }
3384 {
3385 PyThreadState* __tstate = wxPyBeginAllowThreads();
3386 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3387
3388 wxPyEndAllowThreads(__tstate);
3389 if (PyErr_Occurred()) SWIG_fail;
3390 }
3391 {
3392 resultobj = SWIG_From_int((int)(result));
3393 }
3394 {
3395 if (temp1)
3396 delete arg1;
3397 }
3398 return resultobj;
3399 fail:
3400 {
3401 if (temp1)
3402 delete arg1;
3403 }
3404 return NULL;
3405 }
3406
3407
3408 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3409 PyObject *resultobj;
3410 wxString *arg1 = 0 ;
3411 bool result;
3412 bool temp1 = false ;
3413 PyObject * obj0 = 0 ;
3414 char *kwnames[] = {
3415 (char *) "name", NULL
3416 };
3417
3418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3419 {
3420 arg1 = wxString_in_helper(obj0);
3421 if (arg1 == NULL) SWIG_fail;
3422 temp1 = true;
3423 }
3424 {
3425 PyThreadState* __tstate = wxPyBeginAllowThreads();
3426 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3427
3428 wxPyEndAllowThreads(__tstate);
3429 if (PyErr_Occurred()) SWIG_fail;
3430 }
3431 {
3432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3433 }
3434 {
3435 if (temp1)
3436 delete arg1;
3437 }
3438 return resultobj;
3439 fail:
3440 {
3441 if (temp1)
3442 delete arg1;
3443 }
3444 return NULL;
3445 }
3446
3447
3448 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3449 PyObject *resultobj;
3450 wxString *arg1 = 0 ;
3451 bool result;
3452 bool temp1 = false ;
3453 PyObject * obj0 = 0 ;
3454 char *kwnames[] = {
3455 (char *) "name", NULL
3456 };
3457
3458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3459 {
3460 arg1 = wxString_in_helper(obj0);
3461 if (arg1 == NULL) SWIG_fail;
3462 temp1 = true;
3463 }
3464 {
3465 PyThreadState* __tstate = wxPyBeginAllowThreads();
3466 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3467
3468 wxPyEndAllowThreads(__tstate);
3469 if (PyErr_Occurred()) SWIG_fail;
3470 }
3471 {
3472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3473 }
3474 {
3475 if (temp1)
3476 delete arg1;
3477 }
3478 return resultobj;
3479 fail:
3480 {
3481 if (temp1)
3482 delete arg1;
3483 }
3484 return NULL;
3485 }
3486
3487
3488 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3489 PyObject *obj;
3490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3491 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3492 Py_INCREF(obj);
3493 return Py_BuildValue((char *)"");
3494 }
3495 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3496 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3497 return 1;
3498 }
3499
3500
3501 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3502 PyObject *pyobj;
3503
3504 {
3505 #if wxUSE_UNICODE
3506 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3507 #else
3508 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3509 #endif
3510 }
3511 return pyobj;
3512 }
3513
3514
3515 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3516 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3517 return 1;
3518 }
3519
3520
3521 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3522 PyObject *pyobj;
3523
3524 {
3525 #if wxUSE_UNICODE
3526 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3527 #else
3528 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3529 #endif
3530 }
3531 return pyobj;
3532 }
3533
3534
3535 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3536 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3537 return 1;
3538 }
3539
3540
3541 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3542 PyObject *pyobj;
3543
3544 {
3545 #if wxUSE_UNICODE
3546 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3547 #else
3548 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3549 #endif
3550 }
3551 return pyobj;
3552 }
3553
3554
3555 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3556 PyObject *resultobj;
3557 long result;
3558 char *kwnames[] = {
3559 NULL
3560 };
3561
3562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3563 {
3564 PyThreadState* __tstate = wxPyBeginAllowThreads();
3565 result = (long)wxNewId();
3566
3567 wxPyEndAllowThreads(__tstate);
3568 if (PyErr_Occurred()) SWIG_fail;
3569 }
3570 {
3571 resultobj = SWIG_From_long((long)(result));
3572 }
3573 return resultobj;
3574 fail:
3575 return NULL;
3576 }
3577
3578
3579 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3580 PyObject *resultobj;
3581 long arg1 ;
3582 PyObject * obj0 = 0 ;
3583 char *kwnames[] = {
3584 (char *) "id", NULL
3585 };
3586
3587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3588 {
3589 arg1 = (long)(SWIG_As_long(obj0));
3590 if (SWIG_arg_fail(1)) SWIG_fail;
3591 }
3592 {
3593 PyThreadState* __tstate = wxPyBeginAllowThreads();
3594 wxRegisterId(arg1);
3595
3596 wxPyEndAllowThreads(__tstate);
3597 if (PyErr_Occurred()) SWIG_fail;
3598 }
3599 Py_INCREF(Py_None); resultobj = Py_None;
3600 return resultobj;
3601 fail:
3602 return NULL;
3603 }
3604
3605
3606 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3607 PyObject *resultobj;
3608 long result;
3609 char *kwnames[] = {
3610 NULL
3611 };
3612
3613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3614 {
3615 PyThreadState* __tstate = wxPyBeginAllowThreads();
3616 result = (long)wxGetCurrentId();
3617
3618 wxPyEndAllowThreads(__tstate);
3619 if (PyErr_Occurred()) SWIG_fail;
3620 }
3621 {
3622 resultobj = SWIG_From_long((long)(result));
3623 }
3624 return resultobj;
3625 fail:
3626 return NULL;
3627 }
3628
3629
3630 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3631 PyObject *resultobj;
3632 int arg1 ;
3633 bool result;
3634 PyObject * obj0 = 0 ;
3635 char *kwnames[] = {
3636 (char *) "id", NULL
3637 };
3638
3639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3640 {
3641 arg1 = (int)(SWIG_As_int(obj0));
3642 if (SWIG_arg_fail(1)) SWIG_fail;
3643 }
3644 {
3645 PyThreadState* __tstate = wxPyBeginAllowThreads();
3646 result = (bool)wxIsStockID(arg1);
3647
3648 wxPyEndAllowThreads(__tstate);
3649 if (PyErr_Occurred()) SWIG_fail;
3650 }
3651 {
3652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3653 }
3654 return resultobj;
3655 fail:
3656 return NULL;
3657 }
3658
3659
3660 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3661 PyObject *resultobj;
3662 int arg1 ;
3663 wxString *arg2 = 0 ;
3664 bool result;
3665 bool temp2 = false ;
3666 PyObject * obj0 = 0 ;
3667 PyObject * obj1 = 0 ;
3668 char *kwnames[] = {
3669 (char *) "id",(char *) "label", NULL
3670 };
3671
3672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3673 {
3674 arg1 = (int)(SWIG_As_int(obj0));
3675 if (SWIG_arg_fail(1)) SWIG_fail;
3676 }
3677 {
3678 arg2 = wxString_in_helper(obj1);
3679 if (arg2 == NULL) SWIG_fail;
3680 temp2 = true;
3681 }
3682 {
3683 PyThreadState* __tstate = wxPyBeginAllowThreads();
3684 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3685
3686 wxPyEndAllowThreads(__tstate);
3687 if (PyErr_Occurred()) SWIG_fail;
3688 }
3689 {
3690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3691 }
3692 {
3693 if (temp2)
3694 delete arg2;
3695 }
3696 return resultobj;
3697 fail:
3698 {
3699 if (temp2)
3700 delete arg2;
3701 }
3702 return NULL;
3703 }
3704
3705
3706 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3707 PyObject *resultobj;
3708 int arg1 ;
3709 bool arg2 = (bool) true ;
3710 wxString arg3 = (wxString) wxPyEmptyString ;
3711 wxString result;
3712 PyObject * obj0 = 0 ;
3713 PyObject * obj1 = 0 ;
3714 PyObject * obj2 = 0 ;
3715 char *kwnames[] = {
3716 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3717 };
3718
3719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3720 {
3721 arg1 = (int)(SWIG_As_int(obj0));
3722 if (SWIG_arg_fail(1)) SWIG_fail;
3723 }
3724 if (obj1) {
3725 {
3726 arg2 = (bool)(SWIG_As_bool(obj1));
3727 if (SWIG_arg_fail(2)) SWIG_fail;
3728 }
3729 }
3730 if (obj2) {
3731 {
3732 wxString* sptr = wxString_in_helper(obj2);
3733 if (sptr == NULL) SWIG_fail;
3734 arg3 = *sptr;
3735 delete sptr;
3736 }
3737 }
3738 {
3739 PyThreadState* __tstate = wxPyBeginAllowThreads();
3740 result = wxGetStockLabel(arg1,arg2,arg3);
3741
3742 wxPyEndAllowThreads(__tstate);
3743 if (PyErr_Occurred()) SWIG_fail;
3744 }
3745 {
3746 #if wxUSE_UNICODE
3747 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3748 #else
3749 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3750 #endif
3751 }
3752 return resultobj;
3753 fail:
3754 return NULL;
3755 }
3756
3757
3758 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3759 PyObject *resultobj;
3760 char *kwnames[] = {
3761 NULL
3762 };
3763
3764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3765 {
3766 if (!wxPyCheckForApp()) SWIG_fail;
3767 PyThreadState* __tstate = wxPyBeginAllowThreads();
3768 wxBell();
3769
3770 wxPyEndAllowThreads(__tstate);
3771 if (PyErr_Occurred()) SWIG_fail;
3772 }
3773 Py_INCREF(Py_None); resultobj = Py_None;
3774 return resultobj;
3775 fail:
3776 return NULL;
3777 }
3778
3779
3780 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3781 PyObject *resultobj;
3782 char *kwnames[] = {
3783 NULL
3784 };
3785
3786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3787 {
3788 if (!wxPyCheckForApp()) SWIG_fail;
3789 PyThreadState* __tstate = wxPyBeginAllowThreads();
3790 wxEndBusyCursor();
3791
3792 wxPyEndAllowThreads(__tstate);
3793 if (PyErr_Occurred()) SWIG_fail;
3794 }
3795 Py_INCREF(Py_None); resultobj = Py_None;
3796 return resultobj;
3797 fail:
3798 return NULL;
3799 }
3800
3801
3802 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3803 PyObject *resultobj;
3804 bool arg1 = (bool) true ;
3805 long result;
3806 PyObject * obj0 = 0 ;
3807 char *kwnames[] = {
3808 (char *) "resetTimer", NULL
3809 };
3810
3811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3812 if (obj0) {
3813 {
3814 arg1 = (bool)(SWIG_As_bool(obj0));
3815 if (SWIG_arg_fail(1)) SWIG_fail;
3816 }
3817 }
3818 {
3819 PyThreadState* __tstate = wxPyBeginAllowThreads();
3820 result = (long)wxGetElapsedTime(arg1);
3821
3822 wxPyEndAllowThreads(__tstate);
3823 if (PyErr_Occurred()) SWIG_fail;
3824 }
3825 {
3826 resultobj = SWIG_From_long((long)(result));
3827 }
3828 return resultobj;
3829 fail:
3830 return NULL;
3831 }
3832
3833
3834 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3835 PyObject *resultobj;
3836 int *arg1 = (int *) 0 ;
3837 int *arg2 = (int *) 0 ;
3838 int temp1 ;
3839 int res1 = 0 ;
3840 int temp2 ;
3841 int res2 = 0 ;
3842 char *kwnames[] = {
3843 NULL
3844 };
3845
3846 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3847 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3849 {
3850 if (!wxPyCheckForApp()) SWIG_fail;
3851 PyThreadState* __tstate = wxPyBeginAllowThreads();
3852 wxGetMousePosition(arg1,arg2);
3853
3854 wxPyEndAllowThreads(__tstate);
3855 if (PyErr_Occurred()) SWIG_fail;
3856 }
3857 Py_INCREF(Py_None); resultobj = Py_None;
3858 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3859 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3860 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3861 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3862 return resultobj;
3863 fail:
3864 return NULL;
3865 }
3866
3867
3868 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3869 PyObject *resultobj;
3870 bool result;
3871 char *kwnames[] = {
3872 NULL
3873 };
3874
3875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3876 {
3877 PyThreadState* __tstate = wxPyBeginAllowThreads();
3878 result = (bool)wxIsBusy();
3879
3880 wxPyEndAllowThreads(__tstate);
3881 if (PyErr_Occurred()) SWIG_fail;
3882 }
3883 {
3884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3885 }
3886 return resultobj;
3887 fail:
3888 return NULL;
3889 }
3890
3891
3892 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3893 PyObject *resultobj;
3894 wxString result;
3895 char *kwnames[] = {
3896 NULL
3897 };
3898
3899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3900 {
3901 PyThreadState* __tstate = wxPyBeginAllowThreads();
3902 result = wxNow();
3903
3904 wxPyEndAllowThreads(__tstate);
3905 if (PyErr_Occurred()) SWIG_fail;
3906 }
3907 {
3908 #if wxUSE_UNICODE
3909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3910 #else
3911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3912 #endif
3913 }
3914 return resultobj;
3915 fail:
3916 return NULL;
3917 }
3918
3919
3920 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3921 PyObject *resultobj;
3922 wxString const &arg1_defvalue = wxPyEmptyString ;
3923 wxString *arg1 = (wxString *) &arg1_defvalue ;
3924 bool result;
3925 bool temp1 = false ;
3926 PyObject * obj0 = 0 ;
3927 char *kwnames[] = {
3928 (char *) "command", NULL
3929 };
3930
3931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3932 if (obj0) {
3933 {
3934 arg1 = wxString_in_helper(obj0);
3935 if (arg1 == NULL) SWIG_fail;
3936 temp1 = true;
3937 }
3938 }
3939 {
3940 PyThreadState* __tstate = wxPyBeginAllowThreads();
3941 result = (bool)wxShell((wxString const &)*arg1);
3942
3943 wxPyEndAllowThreads(__tstate);
3944 if (PyErr_Occurred()) SWIG_fail;
3945 }
3946 {
3947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3948 }
3949 {
3950 if (temp1)
3951 delete arg1;
3952 }
3953 return resultobj;
3954 fail:
3955 {
3956 if (temp1)
3957 delete arg1;
3958 }
3959 return NULL;
3960 }
3961
3962
3963 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3964 PyObject *resultobj;
3965 char *kwnames[] = {
3966 NULL
3967 };
3968
3969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3970 {
3971 PyThreadState* __tstate = wxPyBeginAllowThreads();
3972 wxStartTimer();
3973
3974 wxPyEndAllowThreads(__tstate);
3975 if (PyErr_Occurred()) SWIG_fail;
3976 }
3977 Py_INCREF(Py_None); resultobj = Py_None;
3978 return resultobj;
3979 fail:
3980 return NULL;
3981 }
3982
3983
3984 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3985 PyObject *resultobj;
3986 int *arg1 = (int *) 0 ;
3987 int *arg2 = (int *) 0 ;
3988 int result;
3989 int temp1 ;
3990 int res1 = 0 ;
3991 int temp2 ;
3992 int res2 = 0 ;
3993 char *kwnames[] = {
3994 NULL
3995 };
3996
3997 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3998 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4000 {
4001 PyThreadState* __tstate = wxPyBeginAllowThreads();
4002 result = (int)wxGetOsVersion(arg1,arg2);
4003
4004 wxPyEndAllowThreads(__tstate);
4005 if (PyErr_Occurred()) SWIG_fail;
4006 }
4007 {
4008 resultobj = SWIG_From_int((int)(result));
4009 }
4010 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4011 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4012 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4013 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4014 return resultobj;
4015 fail:
4016 return NULL;
4017 }
4018
4019
4020 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4021 PyObject *resultobj;
4022 wxString result;
4023 char *kwnames[] = {
4024 NULL
4025 };
4026
4027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4028 {
4029 PyThreadState* __tstate = wxPyBeginAllowThreads();
4030 result = wxGetOsDescription();
4031
4032 wxPyEndAllowThreads(__tstate);
4033 if (PyErr_Occurred()) SWIG_fail;
4034 }
4035 {
4036 #if wxUSE_UNICODE
4037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4038 #else
4039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4040 #endif
4041 }
4042 return resultobj;
4043 fail:
4044 return NULL;
4045 }
4046
4047
4048 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4049 PyObject *resultobj;
4050 long result;
4051 char *kwnames[] = {
4052 NULL
4053 };
4054
4055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4056 {
4057 PyThreadState* __tstate = wxPyBeginAllowThreads();
4058 result = (long)wxGetFreeMemory();
4059
4060 wxPyEndAllowThreads(__tstate);
4061 if (PyErr_Occurred()) SWIG_fail;
4062 }
4063 {
4064 resultobj = SWIG_From_long((long)(result));
4065 }
4066 return resultobj;
4067 fail:
4068 return NULL;
4069 }
4070
4071
4072 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4073 PyObject *resultobj;
4074 wxShutdownFlags arg1 ;
4075 bool result;
4076 PyObject * obj0 = 0 ;
4077 char *kwnames[] = {
4078 (char *) "wFlags", NULL
4079 };
4080
4081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4082 {
4083 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4084 if (SWIG_arg_fail(1)) SWIG_fail;
4085 }
4086 {
4087 if (!wxPyCheckForApp()) SWIG_fail;
4088 PyThreadState* __tstate = wxPyBeginAllowThreads();
4089 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4090
4091 wxPyEndAllowThreads(__tstate);
4092 if (PyErr_Occurred()) SWIG_fail;
4093 }
4094 {
4095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4096 }
4097 return resultobj;
4098 fail:
4099 return NULL;
4100 }
4101
4102
4103 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4104 PyObject *resultobj;
4105 int arg1 ;
4106 PyObject * obj0 = 0 ;
4107 char *kwnames[] = {
4108 (char *) "secs", NULL
4109 };
4110
4111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4112 {
4113 arg1 = (int)(SWIG_As_int(obj0));
4114 if (SWIG_arg_fail(1)) SWIG_fail;
4115 }
4116 {
4117 PyThreadState* __tstate = wxPyBeginAllowThreads();
4118 wxSleep(arg1);
4119
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 Py_INCREF(Py_None); resultobj = Py_None;
4124 return resultobj;
4125 fail:
4126 return NULL;
4127 }
4128
4129
4130 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4131 PyObject *resultobj;
4132 unsigned long arg1 ;
4133 PyObject * obj0 = 0 ;
4134 char *kwnames[] = {
4135 (char *) "milliseconds", NULL
4136 };
4137
4138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4139 {
4140 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4141 if (SWIG_arg_fail(1)) SWIG_fail;
4142 }
4143 {
4144 PyThreadState* __tstate = wxPyBeginAllowThreads();
4145 wxMilliSleep(arg1);
4146
4147 wxPyEndAllowThreads(__tstate);
4148 if (PyErr_Occurred()) SWIG_fail;
4149 }
4150 Py_INCREF(Py_None); resultobj = Py_None;
4151 return resultobj;
4152 fail:
4153 return NULL;
4154 }
4155
4156
4157 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4158 PyObject *resultobj;
4159 unsigned long arg1 ;
4160 PyObject * obj0 = 0 ;
4161 char *kwnames[] = {
4162 (char *) "microseconds", NULL
4163 };
4164
4165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4166 {
4167 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4168 if (SWIG_arg_fail(1)) SWIG_fail;
4169 }
4170 {
4171 PyThreadState* __tstate = wxPyBeginAllowThreads();
4172 wxMicroSleep(arg1);
4173
4174 wxPyEndAllowThreads(__tstate);
4175 if (PyErr_Occurred()) SWIG_fail;
4176 }
4177 Py_INCREF(Py_None); resultobj = Py_None;
4178 return resultobj;
4179 fail:
4180 return NULL;
4181 }
4182
4183
4184 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4185 PyObject *resultobj;
4186 bool arg1 ;
4187 PyObject * obj0 = 0 ;
4188 char *kwnames[] = {
4189 (char *) "enable", NULL
4190 };
4191
4192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4193 {
4194 arg1 = (bool)(SWIG_As_bool(obj0));
4195 if (SWIG_arg_fail(1)) SWIG_fail;
4196 }
4197 {
4198 PyThreadState* __tstate = wxPyBeginAllowThreads();
4199 wxEnableTopLevelWindows(arg1);
4200
4201 wxPyEndAllowThreads(__tstate);
4202 if (PyErr_Occurred()) SWIG_fail;
4203 }
4204 Py_INCREF(Py_None); resultobj = Py_None;
4205 return resultobj;
4206 fail:
4207 return NULL;
4208 }
4209
4210
4211 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4212 PyObject *resultobj;
4213 wxString *arg1 = 0 ;
4214 wxString result;
4215 bool temp1 = false ;
4216 PyObject * obj0 = 0 ;
4217 char *kwnames[] = {
4218 (char *) "in", NULL
4219 };
4220
4221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4222 {
4223 arg1 = wxString_in_helper(obj0);
4224 if (arg1 == NULL) SWIG_fail;
4225 temp1 = true;
4226 }
4227 {
4228 PyThreadState* __tstate = wxPyBeginAllowThreads();
4229 result = wxStripMenuCodes((wxString const &)*arg1);
4230
4231 wxPyEndAllowThreads(__tstate);
4232 if (PyErr_Occurred()) SWIG_fail;
4233 }
4234 {
4235 #if wxUSE_UNICODE
4236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4237 #else
4238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4239 #endif
4240 }
4241 {
4242 if (temp1)
4243 delete arg1;
4244 }
4245 return resultobj;
4246 fail:
4247 {
4248 if (temp1)
4249 delete arg1;
4250 }
4251 return NULL;
4252 }
4253
4254
4255 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4256 PyObject *resultobj;
4257 wxString result;
4258 char *kwnames[] = {
4259 NULL
4260 };
4261
4262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4263 {
4264 PyThreadState* __tstate = wxPyBeginAllowThreads();
4265 result = wxGetEmailAddress();
4266
4267 wxPyEndAllowThreads(__tstate);
4268 if (PyErr_Occurred()) SWIG_fail;
4269 }
4270 {
4271 #if wxUSE_UNICODE
4272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4273 #else
4274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4275 #endif
4276 }
4277 return resultobj;
4278 fail:
4279 return NULL;
4280 }
4281
4282
4283 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4284 PyObject *resultobj;
4285 wxString result;
4286 char *kwnames[] = {
4287 NULL
4288 };
4289
4290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4291 {
4292 PyThreadState* __tstate = wxPyBeginAllowThreads();
4293 result = wxGetHostName();
4294
4295 wxPyEndAllowThreads(__tstate);
4296 if (PyErr_Occurred()) SWIG_fail;
4297 }
4298 {
4299 #if wxUSE_UNICODE
4300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4301 #else
4302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4303 #endif
4304 }
4305 return resultobj;
4306 fail:
4307 return NULL;
4308 }
4309
4310
4311 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4312 PyObject *resultobj;
4313 wxString result;
4314 char *kwnames[] = {
4315 NULL
4316 };
4317
4318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4319 {
4320 PyThreadState* __tstate = wxPyBeginAllowThreads();
4321 result = wxGetFullHostName();
4322
4323 wxPyEndAllowThreads(__tstate);
4324 if (PyErr_Occurred()) SWIG_fail;
4325 }
4326 {
4327 #if wxUSE_UNICODE
4328 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4329 #else
4330 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4331 #endif
4332 }
4333 return resultobj;
4334 fail:
4335 return NULL;
4336 }
4337
4338
4339 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4340 PyObject *resultobj;
4341 wxString result;
4342 char *kwnames[] = {
4343 NULL
4344 };
4345
4346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4347 {
4348 PyThreadState* __tstate = wxPyBeginAllowThreads();
4349 result = wxGetUserId();
4350
4351 wxPyEndAllowThreads(__tstate);
4352 if (PyErr_Occurred()) SWIG_fail;
4353 }
4354 {
4355 #if wxUSE_UNICODE
4356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4357 #else
4358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4359 #endif
4360 }
4361 return resultobj;
4362 fail:
4363 return NULL;
4364 }
4365
4366
4367 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4368 PyObject *resultobj;
4369 wxString result;
4370 char *kwnames[] = {
4371 NULL
4372 };
4373
4374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4375 {
4376 PyThreadState* __tstate = wxPyBeginAllowThreads();
4377 result = wxGetUserName();
4378
4379 wxPyEndAllowThreads(__tstate);
4380 if (PyErr_Occurred()) SWIG_fail;
4381 }
4382 {
4383 #if wxUSE_UNICODE
4384 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4385 #else
4386 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4387 #endif
4388 }
4389 return resultobj;
4390 fail:
4391 return NULL;
4392 }
4393
4394
4395 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4396 PyObject *resultobj;
4397 wxString result;
4398 char *kwnames[] = {
4399 NULL
4400 };
4401
4402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4403 {
4404 PyThreadState* __tstate = wxPyBeginAllowThreads();
4405 result = wxGetHomeDir();
4406
4407 wxPyEndAllowThreads(__tstate);
4408 if (PyErr_Occurred()) SWIG_fail;
4409 }
4410 {
4411 #if wxUSE_UNICODE
4412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4413 #else
4414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4415 #endif
4416 }
4417 return resultobj;
4418 fail:
4419 return NULL;
4420 }
4421
4422
4423 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4424 PyObject *resultobj;
4425 wxString const &arg1_defvalue = wxPyEmptyString ;
4426 wxString *arg1 = (wxString *) &arg1_defvalue ;
4427 wxString result;
4428 bool temp1 = false ;
4429 PyObject * obj0 = 0 ;
4430 char *kwnames[] = {
4431 (char *) "user", NULL
4432 };
4433
4434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4435 if (obj0) {
4436 {
4437 arg1 = wxString_in_helper(obj0);
4438 if (arg1 == NULL) SWIG_fail;
4439 temp1 = true;
4440 }
4441 }
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 result = wxGetUserHome((wxString const &)*arg1);
4445
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 {
4450 #if wxUSE_UNICODE
4451 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4452 #else
4453 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4454 #endif
4455 }
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 return resultobj;
4461 fail:
4462 {
4463 if (temp1)
4464 delete arg1;
4465 }
4466 return NULL;
4467 }
4468
4469
4470 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4471 PyObject *resultobj;
4472 unsigned long result;
4473 char *kwnames[] = {
4474 NULL
4475 };
4476
4477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4478 {
4479 PyThreadState* __tstate = wxPyBeginAllowThreads();
4480 result = (unsigned long)wxGetProcessId();
4481
4482 wxPyEndAllowThreads(__tstate);
4483 if (PyErr_Occurred()) SWIG_fail;
4484 }
4485 {
4486 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4487 }
4488 return resultobj;
4489 fail:
4490 return NULL;
4491 }
4492
4493
4494 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4495 PyObject *resultobj;
4496 char *kwnames[] = {
4497 NULL
4498 };
4499
4500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4501 {
4502 PyThreadState* __tstate = wxPyBeginAllowThreads();
4503 wxTrap();
4504
4505 wxPyEndAllowThreads(__tstate);
4506 if (PyErr_Occurred()) SWIG_fail;
4507 }
4508 Py_INCREF(Py_None); resultobj = Py_None;
4509 return resultobj;
4510 fail:
4511 return NULL;
4512 }
4513
4514
4515 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4516 PyObject *resultobj;
4517 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4518 wxString *arg1 = (wxString *) &arg1_defvalue ;
4519 wxString const &arg2_defvalue = wxPyEmptyString ;
4520 wxString *arg2 = (wxString *) &arg2_defvalue ;
4521 wxString const &arg3_defvalue = wxPyEmptyString ;
4522 wxString *arg3 = (wxString *) &arg3_defvalue ;
4523 wxString const &arg4_defvalue = wxPyEmptyString ;
4524 wxString *arg4 = (wxString *) &arg4_defvalue ;
4525 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4526 wxString *arg5 = (wxString *) &arg5_defvalue ;
4527 int arg6 = (int) 0 ;
4528 wxWindow *arg7 = (wxWindow *) NULL ;
4529 int arg8 = (int) -1 ;
4530 int arg9 = (int) -1 ;
4531 wxString result;
4532 bool temp1 = false ;
4533 bool temp2 = false ;
4534 bool temp3 = false ;
4535 bool temp4 = false ;
4536 bool temp5 = false ;
4537 PyObject * obj0 = 0 ;
4538 PyObject * obj1 = 0 ;
4539 PyObject * obj2 = 0 ;
4540 PyObject * obj3 = 0 ;
4541 PyObject * obj4 = 0 ;
4542 PyObject * obj5 = 0 ;
4543 PyObject * obj6 = 0 ;
4544 PyObject * obj7 = 0 ;
4545 PyObject * obj8 = 0 ;
4546 char *kwnames[] = {
4547 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4548 };
4549
4550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4551 if (obj0) {
4552 {
4553 arg1 = wxString_in_helper(obj0);
4554 if (arg1 == NULL) SWIG_fail;
4555 temp1 = true;
4556 }
4557 }
4558 if (obj1) {
4559 {
4560 arg2 = wxString_in_helper(obj1);
4561 if (arg2 == NULL) SWIG_fail;
4562 temp2 = true;
4563 }
4564 }
4565 if (obj2) {
4566 {
4567 arg3 = wxString_in_helper(obj2);
4568 if (arg3 == NULL) SWIG_fail;
4569 temp3 = true;
4570 }
4571 }
4572 if (obj3) {
4573 {
4574 arg4 = wxString_in_helper(obj3);
4575 if (arg4 == NULL) SWIG_fail;
4576 temp4 = true;
4577 }
4578 }
4579 if (obj4) {
4580 {
4581 arg5 = wxString_in_helper(obj4);
4582 if (arg5 == NULL) SWIG_fail;
4583 temp5 = true;
4584 }
4585 }
4586 if (obj5) {
4587 {
4588 arg6 = (int)(SWIG_As_int(obj5));
4589 if (SWIG_arg_fail(6)) SWIG_fail;
4590 }
4591 }
4592 if (obj6) {
4593 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4594 if (SWIG_arg_fail(7)) SWIG_fail;
4595 }
4596 if (obj7) {
4597 {
4598 arg8 = (int)(SWIG_As_int(obj7));
4599 if (SWIG_arg_fail(8)) SWIG_fail;
4600 }
4601 }
4602 if (obj8) {
4603 {
4604 arg9 = (int)(SWIG_As_int(obj8));
4605 if (SWIG_arg_fail(9)) SWIG_fail;
4606 }
4607 }
4608 {
4609 if (!wxPyCheckForApp()) SWIG_fail;
4610 PyThreadState* __tstate = wxPyBeginAllowThreads();
4611 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4612
4613 wxPyEndAllowThreads(__tstate);
4614 if (PyErr_Occurred()) SWIG_fail;
4615 }
4616 {
4617 #if wxUSE_UNICODE
4618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4619 #else
4620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4621 #endif
4622 }
4623 {
4624 if (temp1)
4625 delete arg1;
4626 }
4627 {
4628 if (temp2)
4629 delete arg2;
4630 }
4631 {
4632 if (temp3)
4633 delete arg3;
4634 }
4635 {
4636 if (temp4)
4637 delete arg4;
4638 }
4639 {
4640 if (temp5)
4641 delete arg5;
4642 }
4643 return resultobj;
4644 fail:
4645 {
4646 if (temp1)
4647 delete arg1;
4648 }
4649 {
4650 if (temp2)
4651 delete arg2;
4652 }
4653 {
4654 if (temp3)
4655 delete arg3;
4656 }
4657 {
4658 if (temp4)
4659 delete arg4;
4660 }
4661 {
4662 if (temp5)
4663 delete arg5;
4664 }
4665 return NULL;
4666 }
4667
4668
4669 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4670 PyObject *resultobj;
4671 wxString *arg1 = 0 ;
4672 wxString *arg2 = 0 ;
4673 wxString const &arg3_defvalue = wxPyEmptyString ;
4674 wxString *arg3 = (wxString *) &arg3_defvalue ;
4675 wxWindow *arg4 = (wxWindow *) NULL ;
4676 wxString result;
4677 bool temp1 = false ;
4678 bool temp2 = false ;
4679 bool temp3 = false ;
4680 PyObject * obj0 = 0 ;
4681 PyObject * obj1 = 0 ;
4682 PyObject * obj2 = 0 ;
4683 PyObject * obj3 = 0 ;
4684 char *kwnames[] = {
4685 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4686 };
4687
4688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4689 {
4690 arg1 = wxString_in_helper(obj0);
4691 if (arg1 == NULL) SWIG_fail;
4692 temp1 = true;
4693 }
4694 {
4695 arg2 = wxString_in_helper(obj1);
4696 if (arg2 == NULL) SWIG_fail;
4697 temp2 = true;
4698 }
4699 if (obj2) {
4700 {
4701 arg3 = wxString_in_helper(obj2);
4702 if (arg3 == NULL) SWIG_fail;
4703 temp3 = true;
4704 }
4705 }
4706 if (obj3) {
4707 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4708 if (SWIG_arg_fail(4)) SWIG_fail;
4709 }
4710 {
4711 if (!wxPyCheckForApp()) SWIG_fail;
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4714
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 {
4719 #if wxUSE_UNICODE
4720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4721 #else
4722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4723 #endif
4724 }
4725 {
4726 if (temp1)
4727 delete arg1;
4728 }
4729 {
4730 if (temp2)
4731 delete arg2;
4732 }
4733 {
4734 if (temp3)
4735 delete arg3;
4736 }
4737 return resultobj;
4738 fail:
4739 {
4740 if (temp1)
4741 delete arg1;
4742 }
4743 {
4744 if (temp2)
4745 delete arg2;
4746 }
4747 {
4748 if (temp3)
4749 delete arg3;
4750 }
4751 return NULL;
4752 }
4753
4754
4755 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4756 PyObject *resultobj;
4757 wxString *arg1 = 0 ;
4758 wxString *arg2 = 0 ;
4759 wxString const &arg3_defvalue = wxPyEmptyString ;
4760 wxString *arg3 = (wxString *) &arg3_defvalue ;
4761 wxWindow *arg4 = (wxWindow *) NULL ;
4762 wxString result;
4763 bool temp1 = false ;
4764 bool temp2 = false ;
4765 bool temp3 = false ;
4766 PyObject * obj0 = 0 ;
4767 PyObject * obj1 = 0 ;
4768 PyObject * obj2 = 0 ;
4769 PyObject * obj3 = 0 ;
4770 char *kwnames[] = {
4771 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4772 };
4773
4774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4775 {
4776 arg1 = wxString_in_helper(obj0);
4777 if (arg1 == NULL) SWIG_fail;
4778 temp1 = true;
4779 }
4780 {
4781 arg2 = wxString_in_helper(obj1);
4782 if (arg2 == NULL) SWIG_fail;
4783 temp2 = true;
4784 }
4785 if (obj2) {
4786 {
4787 arg3 = wxString_in_helper(obj2);
4788 if (arg3 == NULL) SWIG_fail;
4789 temp3 = true;
4790 }
4791 }
4792 if (obj3) {
4793 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4794 if (SWIG_arg_fail(4)) SWIG_fail;
4795 }
4796 {
4797 if (!wxPyCheckForApp()) SWIG_fail;
4798 PyThreadState* __tstate = wxPyBeginAllowThreads();
4799 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4800
4801 wxPyEndAllowThreads(__tstate);
4802 if (PyErr_Occurred()) SWIG_fail;
4803 }
4804 {
4805 #if wxUSE_UNICODE
4806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4807 #else
4808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4809 #endif
4810 }
4811 {
4812 if (temp1)
4813 delete arg1;
4814 }
4815 {
4816 if (temp2)
4817 delete arg2;
4818 }
4819 {
4820 if (temp3)
4821 delete arg3;
4822 }
4823 return resultobj;
4824 fail:
4825 {
4826 if (temp1)
4827 delete arg1;
4828 }
4829 {
4830 if (temp2)
4831 delete arg2;
4832 }
4833 {
4834 if (temp3)
4835 delete arg3;
4836 }
4837 return NULL;
4838 }
4839
4840
4841 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4842 PyObject *resultobj;
4843 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4844 wxString *arg1 = (wxString *) &arg1_defvalue ;
4845 wxString const &arg2_defvalue = wxPyEmptyString ;
4846 wxString *arg2 = (wxString *) &arg2_defvalue ;
4847 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4848 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4849 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4850 wxWindow *arg5 = (wxWindow *) NULL ;
4851 wxString result;
4852 bool temp1 = false ;
4853 bool temp2 = false ;
4854 wxPoint temp4 ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 PyObject * obj2 = 0 ;
4858 PyObject * obj3 = 0 ;
4859 PyObject * obj4 = 0 ;
4860 char *kwnames[] = {
4861 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4862 };
4863
4864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4865 if (obj0) {
4866 {
4867 arg1 = wxString_in_helper(obj0);
4868 if (arg1 == NULL) SWIG_fail;
4869 temp1 = true;
4870 }
4871 }
4872 if (obj1) {
4873 {
4874 arg2 = wxString_in_helper(obj1);
4875 if (arg2 == NULL) SWIG_fail;
4876 temp2 = true;
4877 }
4878 }
4879 if (obj2) {
4880 {
4881 arg3 = (long)(SWIG_As_long(obj2));
4882 if (SWIG_arg_fail(3)) SWIG_fail;
4883 }
4884 }
4885 if (obj3) {
4886 {
4887 arg4 = &temp4;
4888 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4889 }
4890 }
4891 if (obj4) {
4892 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4893 if (SWIG_arg_fail(5)) SWIG_fail;
4894 }
4895 {
4896 if (!wxPyCheckForApp()) SWIG_fail;
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4899
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 {
4904 #if wxUSE_UNICODE
4905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4906 #else
4907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4908 #endif
4909 }
4910 {
4911 if (temp1)
4912 delete arg1;
4913 }
4914 {
4915 if (temp2)
4916 delete arg2;
4917 }
4918 return resultobj;
4919 fail:
4920 {
4921 if (temp1)
4922 delete arg1;
4923 }
4924 {
4925 if (temp2)
4926 delete arg2;
4927 }
4928 return NULL;
4929 }
4930
4931
4932 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4933 PyObject *resultobj;
4934 wxString *arg1 = 0 ;
4935 wxString const &arg2_defvalue = wxPyEmptyString ;
4936 wxString *arg2 = (wxString *) &arg2_defvalue ;
4937 wxString const &arg3_defvalue = wxPyEmptyString ;
4938 wxString *arg3 = (wxString *) &arg3_defvalue ;
4939 wxWindow *arg4 = (wxWindow *) NULL ;
4940 int arg5 = (int) -1 ;
4941 int arg6 = (int) -1 ;
4942 bool arg7 = (bool) true ;
4943 wxString result;
4944 bool temp1 = false ;
4945 bool temp2 = false ;
4946 bool temp3 = false ;
4947 PyObject * obj0 = 0 ;
4948 PyObject * obj1 = 0 ;
4949 PyObject * obj2 = 0 ;
4950 PyObject * obj3 = 0 ;
4951 PyObject * obj4 = 0 ;
4952 PyObject * obj5 = 0 ;
4953 PyObject * obj6 = 0 ;
4954 char *kwnames[] = {
4955 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4956 };
4957
4958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4959 {
4960 arg1 = wxString_in_helper(obj0);
4961 if (arg1 == NULL) SWIG_fail;
4962 temp1 = true;
4963 }
4964 if (obj1) {
4965 {
4966 arg2 = wxString_in_helper(obj1);
4967 if (arg2 == NULL) SWIG_fail;
4968 temp2 = true;
4969 }
4970 }
4971 if (obj2) {
4972 {
4973 arg3 = wxString_in_helper(obj2);
4974 if (arg3 == NULL) SWIG_fail;
4975 temp3 = true;
4976 }
4977 }
4978 if (obj3) {
4979 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4980 if (SWIG_arg_fail(4)) SWIG_fail;
4981 }
4982 if (obj4) {
4983 {
4984 arg5 = (int)(SWIG_As_int(obj4));
4985 if (SWIG_arg_fail(5)) SWIG_fail;
4986 }
4987 }
4988 if (obj5) {
4989 {
4990 arg6 = (int)(SWIG_As_int(obj5));
4991 if (SWIG_arg_fail(6)) SWIG_fail;
4992 }
4993 }
4994 if (obj6) {
4995 {
4996 arg7 = (bool)(SWIG_As_bool(obj6));
4997 if (SWIG_arg_fail(7)) SWIG_fail;
4998 }
4999 }
5000 {
5001 if (!wxPyCheckForApp()) SWIG_fail;
5002 PyThreadState* __tstate = wxPyBeginAllowThreads();
5003 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5004
5005 wxPyEndAllowThreads(__tstate);
5006 if (PyErr_Occurred()) SWIG_fail;
5007 }
5008 {
5009 #if wxUSE_UNICODE
5010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5011 #else
5012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5013 #endif
5014 }
5015 {
5016 if (temp1)
5017 delete arg1;
5018 }
5019 {
5020 if (temp2)
5021 delete arg2;
5022 }
5023 {
5024 if (temp3)
5025 delete arg3;
5026 }
5027 return resultobj;
5028 fail:
5029 {
5030 if (temp1)
5031 delete arg1;
5032 }
5033 {
5034 if (temp2)
5035 delete arg2;
5036 }
5037 {
5038 if (temp3)
5039 delete arg3;
5040 }
5041 return NULL;
5042 }
5043
5044
5045 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5046 PyObject *resultobj;
5047 wxString *arg1 = 0 ;
5048 wxString const &arg2_defvalue = wxPyEmptyString ;
5049 wxString *arg2 = (wxString *) &arg2_defvalue ;
5050 wxString const &arg3_defvalue = wxPyEmptyString ;
5051 wxString *arg3 = (wxString *) &arg3_defvalue ;
5052 wxWindow *arg4 = (wxWindow *) NULL ;
5053 wxString result;
5054 bool temp1 = false ;
5055 bool temp2 = false ;
5056 bool temp3 = false ;
5057 PyObject * obj0 = 0 ;
5058 PyObject * obj1 = 0 ;
5059 PyObject * obj2 = 0 ;
5060 PyObject * obj3 = 0 ;
5061 char *kwnames[] = {
5062 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5063 };
5064
5065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5066 {
5067 arg1 = wxString_in_helper(obj0);
5068 if (arg1 == NULL) SWIG_fail;
5069 temp1 = true;
5070 }
5071 if (obj1) {
5072 {
5073 arg2 = wxString_in_helper(obj1);
5074 if (arg2 == NULL) SWIG_fail;
5075 temp2 = true;
5076 }
5077 }
5078 if (obj2) {
5079 {
5080 arg3 = wxString_in_helper(obj2);
5081 if (arg3 == NULL) SWIG_fail;
5082 temp3 = true;
5083 }
5084 }
5085 if (obj3) {
5086 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5087 if (SWIG_arg_fail(4)) SWIG_fail;
5088 }
5089 {
5090 if (!wxPyCheckForApp()) SWIG_fail;
5091 PyThreadState* __tstate = wxPyBeginAllowThreads();
5092 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5093
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 {
5098 #if wxUSE_UNICODE
5099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5100 #else
5101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5102 #endif
5103 }
5104 {
5105 if (temp1)
5106 delete arg1;
5107 }
5108 {
5109 if (temp2)
5110 delete arg2;
5111 }
5112 {
5113 if (temp3)
5114 delete arg3;
5115 }
5116 return resultobj;
5117 fail:
5118 {
5119 if (temp1)
5120 delete arg1;
5121 }
5122 {
5123 if (temp2)
5124 delete arg2;
5125 }
5126 {
5127 if (temp3)
5128 delete arg3;
5129 }
5130 return NULL;
5131 }
5132
5133
5134 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5135 PyObject *resultobj;
5136 wxString *arg1 = 0 ;
5137 wxString *arg2 = 0 ;
5138 int arg3 ;
5139 wxString *arg4 = (wxString *) 0 ;
5140 wxWindow *arg5 = (wxWindow *) NULL ;
5141 int arg6 = (int) -1 ;
5142 int arg7 = (int) -1 ;
5143 bool arg8 = (bool) true ;
5144 int arg9 = (int) 150 ;
5145 int arg10 = (int) 200 ;
5146 wxString result;
5147 bool temp1 = false ;
5148 bool temp2 = false ;
5149 PyObject * obj0 = 0 ;
5150 PyObject * obj1 = 0 ;
5151 PyObject * obj2 = 0 ;
5152 PyObject * obj3 = 0 ;
5153 PyObject * obj4 = 0 ;
5154 PyObject * obj5 = 0 ;
5155 PyObject * obj6 = 0 ;
5156 PyObject * obj7 = 0 ;
5157 PyObject * obj8 = 0 ;
5158 char *kwnames[] = {
5159 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5160 };
5161
5162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5163 {
5164 arg1 = wxString_in_helper(obj0);
5165 if (arg1 == NULL) SWIG_fail;
5166 temp1 = true;
5167 }
5168 {
5169 arg2 = wxString_in_helper(obj1);
5170 if (arg2 == NULL) SWIG_fail;
5171 temp2 = true;
5172 }
5173 {
5174 arg3 = PyList_Size(obj2);
5175 arg4 = wxString_LIST_helper(obj2);
5176 if (arg4 == NULL) SWIG_fail;
5177 }
5178 if (obj3) {
5179 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5180 if (SWIG_arg_fail(5)) SWIG_fail;
5181 }
5182 if (obj4) {
5183 {
5184 arg6 = (int)(SWIG_As_int(obj4));
5185 if (SWIG_arg_fail(6)) SWIG_fail;
5186 }
5187 }
5188 if (obj5) {
5189 {
5190 arg7 = (int)(SWIG_As_int(obj5));
5191 if (SWIG_arg_fail(7)) SWIG_fail;
5192 }
5193 }
5194 if (obj6) {
5195 {
5196 arg8 = (bool)(SWIG_As_bool(obj6));
5197 if (SWIG_arg_fail(8)) SWIG_fail;
5198 }
5199 }
5200 if (obj7) {
5201 {
5202 arg9 = (int)(SWIG_As_int(obj7));
5203 if (SWIG_arg_fail(9)) SWIG_fail;
5204 }
5205 }
5206 if (obj8) {
5207 {
5208 arg10 = (int)(SWIG_As_int(obj8));
5209 if (SWIG_arg_fail(10)) SWIG_fail;
5210 }
5211 }
5212 {
5213 if (!wxPyCheckForApp()) SWIG_fail;
5214 PyThreadState* __tstate = wxPyBeginAllowThreads();
5215 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5216
5217 wxPyEndAllowThreads(__tstate);
5218 if (PyErr_Occurred()) SWIG_fail;
5219 }
5220 {
5221 #if wxUSE_UNICODE
5222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5223 #else
5224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5225 #endif
5226 }
5227 {
5228 if (temp1)
5229 delete arg1;
5230 }
5231 {
5232 if (temp2)
5233 delete arg2;
5234 }
5235 {
5236 if (arg4) delete [] arg4;
5237 }
5238 return resultobj;
5239 fail:
5240 {
5241 if (temp1)
5242 delete arg1;
5243 }
5244 {
5245 if (temp2)
5246 delete arg2;
5247 }
5248 {
5249 if (arg4) delete [] arg4;
5250 }
5251 return NULL;
5252 }
5253
5254
5255 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5256 PyObject *resultobj;
5257 wxString *arg1 = 0 ;
5258 wxString *arg2 = 0 ;
5259 int arg3 ;
5260 wxString *arg4 = (wxString *) 0 ;
5261 wxWindow *arg5 = (wxWindow *) NULL ;
5262 int arg6 = (int) -1 ;
5263 int arg7 = (int) -1 ;
5264 bool arg8 = (bool) true ;
5265 int arg9 = (int) 150 ;
5266 int arg10 = (int) 200 ;
5267 int result;
5268 bool temp1 = false ;
5269 bool temp2 = false ;
5270 PyObject * obj0 = 0 ;
5271 PyObject * obj1 = 0 ;
5272 PyObject * obj2 = 0 ;
5273 PyObject * obj3 = 0 ;
5274 PyObject * obj4 = 0 ;
5275 PyObject * obj5 = 0 ;
5276 PyObject * obj6 = 0 ;
5277 PyObject * obj7 = 0 ;
5278 PyObject * obj8 = 0 ;
5279 char *kwnames[] = {
5280 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5281 };
5282
5283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5284 {
5285 arg1 = wxString_in_helper(obj0);
5286 if (arg1 == NULL) SWIG_fail;
5287 temp1 = true;
5288 }
5289 {
5290 arg2 = wxString_in_helper(obj1);
5291 if (arg2 == NULL) SWIG_fail;
5292 temp2 = true;
5293 }
5294 {
5295 arg3 = PyList_Size(obj2);
5296 arg4 = wxString_LIST_helper(obj2);
5297 if (arg4 == NULL) SWIG_fail;
5298 }
5299 if (obj3) {
5300 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5301 if (SWIG_arg_fail(5)) SWIG_fail;
5302 }
5303 if (obj4) {
5304 {
5305 arg6 = (int)(SWIG_As_int(obj4));
5306 if (SWIG_arg_fail(6)) SWIG_fail;
5307 }
5308 }
5309 if (obj5) {
5310 {
5311 arg7 = (int)(SWIG_As_int(obj5));
5312 if (SWIG_arg_fail(7)) SWIG_fail;
5313 }
5314 }
5315 if (obj6) {
5316 {
5317 arg8 = (bool)(SWIG_As_bool(obj6));
5318 if (SWIG_arg_fail(8)) SWIG_fail;
5319 }
5320 }
5321 if (obj7) {
5322 {
5323 arg9 = (int)(SWIG_As_int(obj7));
5324 if (SWIG_arg_fail(9)) SWIG_fail;
5325 }
5326 }
5327 if (obj8) {
5328 {
5329 arg10 = (int)(SWIG_As_int(obj8));
5330 if (SWIG_arg_fail(10)) SWIG_fail;
5331 }
5332 }
5333 {
5334 if (!wxPyCheckForApp()) SWIG_fail;
5335 PyThreadState* __tstate = wxPyBeginAllowThreads();
5336 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5337
5338 wxPyEndAllowThreads(__tstate);
5339 if (PyErr_Occurred()) SWIG_fail;
5340 }
5341 {
5342 resultobj = SWIG_From_int((int)(result));
5343 }
5344 {
5345 if (temp1)
5346 delete arg1;
5347 }
5348 {
5349 if (temp2)
5350 delete arg2;
5351 }
5352 {
5353 if (arg4) delete [] arg4;
5354 }
5355 return resultobj;
5356 fail:
5357 {
5358 if (temp1)
5359 delete arg1;
5360 }
5361 {
5362 if (temp2)
5363 delete arg2;
5364 }
5365 {
5366 if (arg4) delete [] arg4;
5367 }
5368 return NULL;
5369 }
5370
5371
5372 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj;
5374 wxString *arg1 = 0 ;
5375 wxString const &arg2_defvalue = wxPyEmptyString ;
5376 wxString *arg2 = (wxString *) &arg2_defvalue ;
5377 int arg3 = (int) wxOK|wxCENTRE ;
5378 wxWindow *arg4 = (wxWindow *) NULL ;
5379 int arg5 = (int) -1 ;
5380 int arg6 = (int) -1 ;
5381 int result;
5382 bool temp1 = false ;
5383 bool temp2 = false ;
5384 PyObject * obj0 = 0 ;
5385 PyObject * obj1 = 0 ;
5386 PyObject * obj2 = 0 ;
5387 PyObject * obj3 = 0 ;
5388 PyObject * obj4 = 0 ;
5389 PyObject * obj5 = 0 ;
5390 char *kwnames[] = {
5391 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5392 };
5393
5394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5395 {
5396 arg1 = wxString_in_helper(obj0);
5397 if (arg1 == NULL) SWIG_fail;
5398 temp1 = true;
5399 }
5400 if (obj1) {
5401 {
5402 arg2 = wxString_in_helper(obj1);
5403 if (arg2 == NULL) SWIG_fail;
5404 temp2 = true;
5405 }
5406 }
5407 if (obj2) {
5408 {
5409 arg3 = (int)(SWIG_As_int(obj2));
5410 if (SWIG_arg_fail(3)) SWIG_fail;
5411 }
5412 }
5413 if (obj3) {
5414 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5415 if (SWIG_arg_fail(4)) SWIG_fail;
5416 }
5417 if (obj4) {
5418 {
5419 arg5 = (int)(SWIG_As_int(obj4));
5420 if (SWIG_arg_fail(5)) SWIG_fail;
5421 }
5422 }
5423 if (obj5) {
5424 {
5425 arg6 = (int)(SWIG_As_int(obj5));
5426 if (SWIG_arg_fail(6)) SWIG_fail;
5427 }
5428 }
5429 {
5430 if (!wxPyCheckForApp()) SWIG_fail;
5431 PyThreadState* __tstate = wxPyBeginAllowThreads();
5432 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5433
5434 wxPyEndAllowThreads(__tstate);
5435 if (PyErr_Occurred()) SWIG_fail;
5436 }
5437 {
5438 resultobj = SWIG_From_int((int)(result));
5439 }
5440 {
5441 if (temp1)
5442 delete arg1;
5443 }
5444 {
5445 if (temp2)
5446 delete arg2;
5447 }
5448 return resultobj;
5449 fail:
5450 {
5451 if (temp1)
5452 delete arg1;
5453 }
5454 {
5455 if (temp2)
5456 delete arg2;
5457 }
5458 return NULL;
5459 }
5460
5461
5462 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5463 PyObject *resultobj;
5464 wxString *arg1 = 0 ;
5465 wxString *arg2 = 0 ;
5466 wxString *arg3 = 0 ;
5467 long arg4 ;
5468 long arg5 = (long) 0 ;
5469 long arg6 = (long) 100 ;
5470 wxWindow *arg7 = (wxWindow *) NULL ;
5471 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5472 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5473 long result;
5474 bool temp1 = false ;
5475 bool temp2 = false ;
5476 bool temp3 = false ;
5477 wxPoint temp8 ;
5478 PyObject * obj0 = 0 ;
5479 PyObject * obj1 = 0 ;
5480 PyObject * obj2 = 0 ;
5481 PyObject * obj3 = 0 ;
5482 PyObject * obj4 = 0 ;
5483 PyObject * obj5 = 0 ;
5484 PyObject * obj6 = 0 ;
5485 PyObject * obj7 = 0 ;
5486 char *kwnames[] = {
5487 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5488 };
5489
5490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5491 {
5492 arg1 = wxString_in_helper(obj0);
5493 if (arg1 == NULL) SWIG_fail;
5494 temp1 = true;
5495 }
5496 {
5497 arg2 = wxString_in_helper(obj1);
5498 if (arg2 == NULL) SWIG_fail;
5499 temp2 = true;
5500 }
5501 {
5502 arg3 = wxString_in_helper(obj2);
5503 if (arg3 == NULL) SWIG_fail;
5504 temp3 = true;
5505 }
5506 {
5507 arg4 = (long)(SWIG_As_long(obj3));
5508 if (SWIG_arg_fail(4)) SWIG_fail;
5509 }
5510 if (obj4) {
5511 {
5512 arg5 = (long)(SWIG_As_long(obj4));
5513 if (SWIG_arg_fail(5)) SWIG_fail;
5514 }
5515 }
5516 if (obj5) {
5517 {
5518 arg6 = (long)(SWIG_As_long(obj5));
5519 if (SWIG_arg_fail(6)) SWIG_fail;
5520 }
5521 }
5522 if (obj6) {
5523 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5524 if (SWIG_arg_fail(7)) SWIG_fail;
5525 }
5526 if (obj7) {
5527 {
5528 arg8 = &temp8;
5529 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5530 }
5531 }
5532 {
5533 if (!wxPyCheckForApp()) SWIG_fail;
5534 PyThreadState* __tstate = wxPyBeginAllowThreads();
5535 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5536
5537 wxPyEndAllowThreads(__tstate);
5538 if (PyErr_Occurred()) SWIG_fail;
5539 }
5540 {
5541 resultobj = SWIG_From_long((long)(result));
5542 }
5543 {
5544 if (temp1)
5545 delete arg1;
5546 }
5547 {
5548 if (temp2)
5549 delete arg2;
5550 }
5551 {
5552 if (temp3)
5553 delete arg3;
5554 }
5555 return resultobj;
5556 fail:
5557 {
5558 if (temp1)
5559 delete arg1;
5560 }
5561 {
5562 if (temp2)
5563 delete arg2;
5564 }
5565 {
5566 if (temp3)
5567 delete arg3;
5568 }
5569 return NULL;
5570 }
5571
5572
5573 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5574 PyObject *resultobj;
5575 bool result;
5576 char *kwnames[] = {
5577 NULL
5578 };
5579
5580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5581 {
5582 if (!wxPyCheckForApp()) SWIG_fail;
5583 PyThreadState* __tstate = wxPyBeginAllowThreads();
5584 result = (bool)wxColourDisplay();
5585
5586 wxPyEndAllowThreads(__tstate);
5587 if (PyErr_Occurred()) SWIG_fail;
5588 }
5589 {
5590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5591 }
5592 return resultobj;
5593 fail:
5594 return NULL;
5595 }
5596
5597
5598 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5599 PyObject *resultobj;
5600 int result;
5601 char *kwnames[] = {
5602 NULL
5603 };
5604
5605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5606 {
5607 if (!wxPyCheckForApp()) SWIG_fail;
5608 PyThreadState* __tstate = wxPyBeginAllowThreads();
5609 result = (int)wxDisplayDepth();
5610
5611 wxPyEndAllowThreads(__tstate);
5612 if (PyErr_Occurred()) SWIG_fail;
5613 }
5614 {
5615 resultobj = SWIG_From_int((int)(result));
5616 }
5617 return resultobj;
5618 fail:
5619 return NULL;
5620 }
5621
5622
5623 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5624 PyObject *resultobj;
5625 int result;
5626 char *kwnames[] = {
5627 NULL
5628 };
5629
5630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5631 {
5632 if (!wxPyCheckForApp()) SWIG_fail;
5633 PyThreadState* __tstate = wxPyBeginAllowThreads();
5634 result = (int)wxGetDisplayDepth();
5635
5636 wxPyEndAllowThreads(__tstate);
5637 if (PyErr_Occurred()) SWIG_fail;
5638 }
5639 {
5640 resultobj = SWIG_From_int((int)(result));
5641 }
5642 return resultobj;
5643 fail:
5644 return NULL;
5645 }
5646
5647
5648 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5649 PyObject *resultobj;
5650 int *arg1 = (int *) 0 ;
5651 int *arg2 = (int *) 0 ;
5652 int temp1 ;
5653 int res1 = 0 ;
5654 int temp2 ;
5655 int res2 = 0 ;
5656 char *kwnames[] = {
5657 NULL
5658 };
5659
5660 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5661 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5663 {
5664 if (!wxPyCheckForApp()) SWIG_fail;
5665 PyThreadState* __tstate = wxPyBeginAllowThreads();
5666 wxDisplaySize(arg1,arg2);
5667
5668 wxPyEndAllowThreads(__tstate);
5669 if (PyErr_Occurred()) SWIG_fail;
5670 }
5671 Py_INCREF(Py_None); resultobj = Py_None;
5672 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5673 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5674 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5675 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5676 return resultobj;
5677 fail:
5678 return NULL;
5679 }
5680
5681
5682 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5683 PyObject *resultobj;
5684 wxSize result;
5685 char *kwnames[] = {
5686 NULL
5687 };
5688
5689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5690 {
5691 if (!wxPyCheckForApp()) SWIG_fail;
5692 PyThreadState* __tstate = wxPyBeginAllowThreads();
5693 result = wxGetDisplaySize();
5694
5695 wxPyEndAllowThreads(__tstate);
5696 if (PyErr_Occurred()) SWIG_fail;
5697 }
5698 {
5699 wxSize * resultptr;
5700 resultptr = new wxSize((wxSize &)(result));
5701 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5702 }
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj;
5711 int *arg1 = (int *) 0 ;
5712 int *arg2 = (int *) 0 ;
5713 int temp1 ;
5714 int res1 = 0 ;
5715 int temp2 ;
5716 int res2 = 0 ;
5717 char *kwnames[] = {
5718 NULL
5719 };
5720
5721 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5722 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5724 {
5725 if (!wxPyCheckForApp()) SWIG_fail;
5726 PyThreadState* __tstate = wxPyBeginAllowThreads();
5727 wxDisplaySizeMM(arg1,arg2);
5728
5729 wxPyEndAllowThreads(__tstate);
5730 if (PyErr_Occurred()) SWIG_fail;
5731 }
5732 Py_INCREF(Py_None); resultobj = Py_None;
5733 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5734 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5735 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5736 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj;
5745 wxSize result;
5746 char *kwnames[] = {
5747 NULL
5748 };
5749
5750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5751 {
5752 if (!wxPyCheckForApp()) SWIG_fail;
5753 PyThreadState* __tstate = wxPyBeginAllowThreads();
5754 result = wxGetDisplaySizeMM();
5755
5756 wxPyEndAllowThreads(__tstate);
5757 if (PyErr_Occurred()) SWIG_fail;
5758 }
5759 {
5760 wxSize * resultptr;
5761 resultptr = new wxSize((wxSize &)(result));
5762 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5763 }
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5771 PyObject *resultobj;
5772 int *arg1 = (int *) 0 ;
5773 int *arg2 = (int *) 0 ;
5774 int *arg3 = (int *) 0 ;
5775 int *arg4 = (int *) 0 ;
5776 int temp1 ;
5777 int res1 = 0 ;
5778 int temp2 ;
5779 int res2 = 0 ;
5780 int temp3 ;
5781 int res3 = 0 ;
5782 int temp4 ;
5783 int res4 = 0 ;
5784 char *kwnames[] = {
5785 NULL
5786 };
5787
5788 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5789 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5790 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5791 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5793 {
5794 if (!wxPyCheckForApp()) SWIG_fail;
5795 PyThreadState* __tstate = wxPyBeginAllowThreads();
5796 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5797
5798 wxPyEndAllowThreads(__tstate);
5799 if (PyErr_Occurred()) SWIG_fail;
5800 }
5801 Py_INCREF(Py_None); resultobj = Py_None;
5802 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5803 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5804 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5805 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5806 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5807 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5808 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5809 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj;
5818 wxRect result;
5819 char *kwnames[] = {
5820 NULL
5821 };
5822
5823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5824 {
5825 if (!wxPyCheckForApp()) SWIG_fail;
5826 PyThreadState* __tstate = wxPyBeginAllowThreads();
5827 result = wxGetClientDisplayRect();
5828
5829 wxPyEndAllowThreads(__tstate);
5830 if (PyErr_Occurred()) SWIG_fail;
5831 }
5832 {
5833 wxRect * resultptr;
5834 resultptr = new wxRect((wxRect &)(result));
5835 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5836 }
5837 return resultobj;
5838 fail:
5839 return NULL;
5840 }
5841
5842
5843 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5844 PyObject *resultobj;
5845 wxCursor *arg1 = 0 ;
5846 PyObject * obj0 = 0 ;
5847 char *kwnames[] = {
5848 (char *) "cursor", NULL
5849 };
5850
5851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5852 {
5853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5854 if (SWIG_arg_fail(1)) SWIG_fail;
5855 if (arg1 == NULL) {
5856 SWIG_null_ref("wxCursor");
5857 }
5858 if (SWIG_arg_fail(1)) SWIG_fail;
5859 }
5860 {
5861 if (!wxPyCheckForApp()) SWIG_fail;
5862 PyThreadState* __tstate = wxPyBeginAllowThreads();
5863 wxSetCursor(*arg1);
5864
5865 wxPyEndAllowThreads(__tstate);
5866 if (PyErr_Occurred()) SWIG_fail;
5867 }
5868 Py_INCREF(Py_None); resultobj = Py_None;
5869 return resultobj;
5870 fail:
5871 return NULL;
5872 }
5873
5874
5875 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5876 PyObject *resultobj;
5877 void *result;
5878 char *kwnames[] = {
5879 NULL
5880 };
5881
5882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5883 {
5884 if (!wxPyCheckForApp()) SWIG_fail;
5885 PyThreadState* __tstate = wxPyBeginAllowThreads();
5886 result = (void *)wxGetXDisplay();
5887
5888 wxPyEndAllowThreads(__tstate);
5889 if (PyErr_Occurred()) SWIG_fail;
5890 }
5891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5892 return resultobj;
5893 fail:
5894 return NULL;
5895 }
5896
5897
5898 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5899 PyObject *resultobj;
5900 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5901 PyObject * obj0 = 0 ;
5902 char *kwnames[] = {
5903 (char *) "cursor", NULL
5904 };
5905
5906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5907 if (obj0) {
5908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5909 if (SWIG_arg_fail(1)) SWIG_fail;
5910 }
5911 {
5912 if (!wxPyCheckForApp()) SWIG_fail;
5913 PyThreadState* __tstate = wxPyBeginAllowThreads();
5914 wxBeginBusyCursor(arg1);
5915
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 Py_INCREF(Py_None); resultobj = Py_None;
5920 return resultobj;
5921 fail:
5922 return NULL;
5923 }
5924
5925
5926 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5927 PyObject *resultobj;
5928 wxWindow *result;
5929 char *kwnames[] = {
5930 NULL
5931 };
5932
5933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5934 {
5935 if (!wxPyCheckForApp()) SWIG_fail;
5936 PyThreadState* __tstate = wxPyBeginAllowThreads();
5937 result = (wxWindow *)wxGetActiveWindow();
5938
5939 wxPyEndAllowThreads(__tstate);
5940 if (PyErr_Occurred()) SWIG_fail;
5941 }
5942 {
5943 resultobj = wxPyMake_wxObject(result, 0);
5944 }
5945 return resultobj;
5946 fail:
5947 return NULL;
5948 }
5949
5950
5951 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5952 PyObject *resultobj;
5953 wxPoint *arg1 = 0 ;
5954 wxWindow *result;
5955 wxPoint temp1 ;
5956 PyObject * obj0 = 0 ;
5957 char *kwnames[] = {
5958 (char *) "pt", NULL
5959 };
5960
5961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5962 {
5963 arg1 = &temp1;
5964 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5965 }
5966 {
5967 if (!wxPyCheckForApp()) SWIG_fail;
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5970
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 {
5975 resultobj = wxPyMake_wxObject(result, 0);
5976 }
5977 return resultobj;
5978 fail:
5979 return NULL;
5980 }
5981
5982
5983 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5984 PyObject *resultobj;
5985 wxPoint *arg1 = 0 ;
5986 wxWindow *result;
5987 wxPoint temp1 ;
5988 PyObject * obj0 = 0 ;
5989 char *kwnames[] = {
5990 (char *) "pt", NULL
5991 };
5992
5993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5994 {
5995 arg1 = &temp1;
5996 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5997 }
5998 {
5999 if (!wxPyCheckForApp()) SWIG_fail;
6000 PyThreadState* __tstate = wxPyBeginAllowThreads();
6001 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6002
6003 wxPyEndAllowThreads(__tstate);
6004 if (PyErr_Occurred()) SWIG_fail;
6005 }
6006 {
6007 resultobj = wxPyMake_wxObject(result, 0);
6008 }
6009 return resultobj;
6010 fail:
6011 return NULL;
6012 }
6013
6014
6015 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6016 PyObject *resultobj;
6017 wxWindow *arg1 = (wxWindow *) 0 ;
6018 wxWindow *result;
6019 PyObject * obj0 = 0 ;
6020 char *kwnames[] = {
6021 (char *) "win", NULL
6022 };
6023
6024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6026 if (SWIG_arg_fail(1)) SWIG_fail;
6027 {
6028 if (!wxPyCheckForApp()) SWIG_fail;
6029 PyThreadState* __tstate = wxPyBeginAllowThreads();
6030 result = (wxWindow *)wxGetTopLevelParent(arg1);
6031
6032 wxPyEndAllowThreads(__tstate);
6033 if (PyErr_Occurred()) SWIG_fail;
6034 }
6035 {
6036 resultobj = wxPyMake_wxObject(result, 0);
6037 }
6038 return resultobj;
6039 fail:
6040 return NULL;
6041 }
6042
6043
6044 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6045 PyObject *resultobj;
6046 wxString *arg1 = 0 ;
6047 bool result;
6048 bool temp1 = false ;
6049 PyObject * obj0 = 0 ;
6050 char *kwnames[] = {
6051 (char *) "url", NULL
6052 };
6053
6054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6055 {
6056 arg1 = wxString_in_helper(obj0);
6057 if (arg1 == NULL) SWIG_fail;
6058 temp1 = true;
6059 }
6060 {
6061 PyThreadState* __tstate = wxPyBeginAllowThreads();
6062 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6063
6064 wxPyEndAllowThreads(__tstate);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 {
6068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6069 }
6070 {
6071 if (temp1)
6072 delete arg1;
6073 }
6074 return resultobj;
6075 fail:
6076 {
6077 if (temp1)
6078 delete arg1;
6079 }
6080 return NULL;
6081 }
6082
6083
6084 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj;
6086 wxKeyCode arg1 ;
6087 bool result;
6088 PyObject * obj0 = 0 ;
6089 char *kwnames[] = {
6090 (char *) "key", NULL
6091 };
6092
6093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6094 {
6095 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6096 if (SWIG_arg_fail(1)) SWIG_fail;
6097 }
6098 {
6099 if (!wxPyCheckForApp()) SWIG_fail;
6100 PyThreadState* __tstate = wxPyBeginAllowThreads();
6101 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6102
6103 wxPyEndAllowThreads(__tstate);
6104 if (PyErr_Occurred()) SWIG_fail;
6105 }
6106 {
6107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6108 }
6109 return resultobj;
6110 fail:
6111 return NULL;
6112 }
6113
6114
6115 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6116 PyObject *resultobj;
6117 char *kwnames[] = {
6118 NULL
6119 };
6120
6121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6122 {
6123 if (!wxPyCheckForApp()) SWIG_fail;
6124 PyThreadState* __tstate = wxPyBeginAllowThreads();
6125 wxWakeUpMainThread();
6126
6127 wxPyEndAllowThreads(__tstate);
6128 if (PyErr_Occurred()) SWIG_fail;
6129 }
6130 Py_INCREF(Py_None); resultobj = Py_None;
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj;
6139 char *kwnames[] = {
6140 NULL
6141 };
6142
6143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6144 {
6145 if (!wxPyCheckForApp()) SWIG_fail;
6146 PyThreadState* __tstate = wxPyBeginAllowThreads();
6147 wxMutexGuiEnter();
6148
6149 wxPyEndAllowThreads(__tstate);
6150 if (PyErr_Occurred()) SWIG_fail;
6151 }
6152 Py_INCREF(Py_None); resultobj = Py_None;
6153 return resultobj;
6154 fail:
6155 return NULL;
6156 }
6157
6158
6159 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6160 PyObject *resultobj;
6161 char *kwnames[] = {
6162 NULL
6163 };
6164
6165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6166 {
6167 if (!wxPyCheckForApp()) SWIG_fail;
6168 PyThreadState* __tstate = wxPyBeginAllowThreads();
6169 wxMutexGuiLeave();
6170
6171 wxPyEndAllowThreads(__tstate);
6172 if (PyErr_Occurred()) SWIG_fail;
6173 }
6174 Py_INCREF(Py_None); resultobj = Py_None;
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj;
6183 wxMutexGuiLocker *result;
6184 char *kwnames[] = {
6185 NULL
6186 };
6187
6188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6189 {
6190 if (!wxPyCheckForApp()) SWIG_fail;
6191 PyThreadState* __tstate = wxPyBeginAllowThreads();
6192 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6193
6194 wxPyEndAllowThreads(__tstate);
6195 if (PyErr_Occurred()) SWIG_fail;
6196 }
6197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6198 return resultobj;
6199 fail:
6200 return NULL;
6201 }
6202
6203
6204 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6205 PyObject *resultobj;
6206 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6207 PyObject * obj0 = 0 ;
6208 char *kwnames[] = {
6209 (char *) "self", NULL
6210 };
6211
6212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6214 if (SWIG_arg_fail(1)) SWIG_fail;
6215 {
6216 PyThreadState* __tstate = wxPyBeginAllowThreads();
6217 delete arg1;
6218
6219 wxPyEndAllowThreads(__tstate);
6220 if (PyErr_Occurred()) SWIG_fail;
6221 }
6222 Py_INCREF(Py_None); resultobj = Py_None;
6223 return resultobj;
6224 fail:
6225 return NULL;
6226 }
6227
6228
6229 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6230 PyObject *obj;
6231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6232 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6233 Py_INCREF(obj);
6234 return Py_BuildValue((char *)"");
6235 }
6236 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6237 PyObject *resultobj;
6238 bool result;
6239 char *kwnames[] = {
6240 NULL
6241 };
6242
6243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6244 {
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 result = (bool)wxThread_IsMain();
6247
6248 wxPyEndAllowThreads(__tstate);
6249 if (PyErr_Occurred()) SWIG_fail;
6250 }
6251 {
6252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6253 }
6254 return resultobj;
6255 fail:
6256 return NULL;
6257 }
6258
6259
6260 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6261 PyObject *resultobj;
6262 wxString *arg1 = 0 ;
6263 wxToolTip *result;
6264 bool temp1 = false ;
6265 PyObject * obj0 = 0 ;
6266 char *kwnames[] = {
6267 (char *) "tip", NULL
6268 };
6269
6270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6271 {
6272 arg1 = wxString_in_helper(obj0);
6273 if (arg1 == NULL) SWIG_fail;
6274 temp1 = true;
6275 }
6276 {
6277 if (!wxPyCheckForApp()) SWIG_fail;
6278 PyThreadState* __tstate = wxPyBeginAllowThreads();
6279 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6280
6281 wxPyEndAllowThreads(__tstate);
6282 if (PyErr_Occurred()) SWIG_fail;
6283 }
6284 {
6285 resultobj = wxPyMake_wxObject(result, 1);
6286 }
6287 {
6288 if (temp1)
6289 delete arg1;
6290 }
6291 return resultobj;
6292 fail:
6293 {
6294 if (temp1)
6295 delete arg1;
6296 }
6297 return NULL;
6298 }
6299
6300
6301 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6302 PyObject *resultobj;
6303 wxToolTip *arg1 = (wxToolTip *) 0 ;
6304 wxString *arg2 = 0 ;
6305 bool temp2 = false ;
6306 PyObject * obj0 = 0 ;
6307 PyObject * obj1 = 0 ;
6308 char *kwnames[] = {
6309 (char *) "self",(char *) "tip", NULL
6310 };
6311
6312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6314 if (SWIG_arg_fail(1)) SWIG_fail;
6315 {
6316 arg2 = wxString_in_helper(obj1);
6317 if (arg2 == NULL) SWIG_fail;
6318 temp2 = true;
6319 }
6320 {
6321 PyThreadState* __tstate = wxPyBeginAllowThreads();
6322 (arg1)->SetTip((wxString const &)*arg2);
6323
6324 wxPyEndAllowThreads(__tstate);
6325 if (PyErr_Occurred()) SWIG_fail;
6326 }
6327 Py_INCREF(Py_None); resultobj = Py_None;
6328 {
6329 if (temp2)
6330 delete arg2;
6331 }
6332 return resultobj;
6333 fail:
6334 {
6335 if (temp2)
6336 delete arg2;
6337 }
6338 return NULL;
6339 }
6340
6341
6342 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6343 PyObject *resultobj;
6344 wxToolTip *arg1 = (wxToolTip *) 0 ;
6345 wxString result;
6346 PyObject * obj0 = 0 ;
6347 char *kwnames[] = {
6348 (char *) "self", NULL
6349 };
6350
6351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6353 if (SWIG_arg_fail(1)) SWIG_fail;
6354 {
6355 PyThreadState* __tstate = wxPyBeginAllowThreads();
6356 result = (arg1)->GetTip();
6357
6358 wxPyEndAllowThreads(__tstate);
6359 if (PyErr_Occurred()) SWIG_fail;
6360 }
6361 {
6362 #if wxUSE_UNICODE
6363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6364 #else
6365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6366 #endif
6367 }
6368 return resultobj;
6369 fail:
6370 return NULL;
6371 }
6372
6373
6374 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6375 PyObject *resultobj;
6376 wxToolTip *arg1 = (wxToolTip *) 0 ;
6377 wxWindow *result;
6378 PyObject * obj0 = 0 ;
6379 char *kwnames[] = {
6380 (char *) "self", NULL
6381 };
6382
6383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6385 if (SWIG_arg_fail(1)) SWIG_fail;
6386 {
6387 PyThreadState* __tstate = wxPyBeginAllowThreads();
6388 result = (wxWindow *)(arg1)->GetWindow();
6389
6390 wxPyEndAllowThreads(__tstate);
6391 if (PyErr_Occurred()) SWIG_fail;
6392 }
6393 {
6394 resultobj = wxPyMake_wxObject(result, 0);
6395 }
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj;
6404 bool arg1 ;
6405 PyObject * obj0 = 0 ;
6406 char *kwnames[] = {
6407 (char *) "flag", NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6411 {
6412 arg1 = (bool)(SWIG_As_bool(obj0));
6413 if (SWIG_arg_fail(1)) SWIG_fail;
6414 }
6415 {
6416 PyThreadState* __tstate = wxPyBeginAllowThreads();
6417 wxToolTip::Enable(arg1);
6418
6419 wxPyEndAllowThreads(__tstate);
6420 if (PyErr_Occurred()) SWIG_fail;
6421 }
6422 Py_INCREF(Py_None); resultobj = Py_None;
6423 return resultobj;
6424 fail:
6425 return NULL;
6426 }
6427
6428
6429 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6430 PyObject *resultobj;
6431 long arg1 ;
6432 PyObject * obj0 = 0 ;
6433 char *kwnames[] = {
6434 (char *) "milliseconds", NULL
6435 };
6436
6437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6438 {
6439 arg1 = (long)(SWIG_As_long(obj0));
6440 if (SWIG_arg_fail(1)) SWIG_fail;
6441 }
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 wxToolTip::SetDelay(arg1);
6445
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 Py_INCREF(Py_None); resultobj = Py_None;
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6457 PyObject *obj;
6458 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6459 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6460 Py_INCREF(obj);
6461 return Py_BuildValue((char *)"");
6462 }
6463 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6464 PyObject *resultobj;
6465 wxWindow *arg1 = (wxWindow *) 0 ;
6466 wxSize *arg2 = 0 ;
6467 wxCaret *result;
6468 wxSize temp2 ;
6469 PyObject * obj0 = 0 ;
6470 PyObject * obj1 = 0 ;
6471 char *kwnames[] = {
6472 (char *) "window",(char *) "size", NULL
6473 };
6474
6475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6477 if (SWIG_arg_fail(1)) SWIG_fail;
6478 {
6479 arg2 = &temp2;
6480 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6481 }
6482 {
6483 if (!wxPyCheckForApp()) SWIG_fail;
6484 PyThreadState* __tstate = wxPyBeginAllowThreads();
6485 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6486
6487 wxPyEndAllowThreads(__tstate);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6498 PyObject *resultobj;
6499 wxCaret *arg1 = (wxCaret *) 0 ;
6500 PyObject * obj0 = 0 ;
6501 char *kwnames[] = {
6502 (char *) "self", NULL
6503 };
6504
6505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6507 if (SWIG_arg_fail(1)) SWIG_fail;
6508 {
6509 PyThreadState* __tstate = wxPyBeginAllowThreads();
6510 wxCaret_Destroy(arg1);
6511
6512 wxPyEndAllowThreads(__tstate);
6513 if (PyErr_Occurred()) SWIG_fail;
6514 }
6515 Py_INCREF(Py_None); resultobj = Py_None;
6516 return resultobj;
6517 fail:
6518 return NULL;
6519 }
6520
6521
6522 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6523 PyObject *resultobj;
6524 wxCaret *arg1 = (wxCaret *) 0 ;
6525 bool result;
6526 PyObject * obj0 = 0 ;
6527 char *kwnames[] = {
6528 (char *) "self", NULL
6529 };
6530
6531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",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 = (bool)(arg1)->IsOk();
6537
6538 wxPyEndAllowThreads(__tstate);
6539 if (PyErr_Occurred()) SWIG_fail;
6540 }
6541 {
6542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6543 }
6544 return resultobj;
6545 fail:
6546 return NULL;
6547 }
6548
6549
6550 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6551 PyObject *resultobj;
6552 wxCaret *arg1 = (wxCaret *) 0 ;
6553 bool result;
6554 PyObject * obj0 = 0 ;
6555 char *kwnames[] = {
6556 (char *) "self", NULL
6557 };
6558
6559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6561 if (SWIG_arg_fail(1)) SWIG_fail;
6562 {
6563 PyThreadState* __tstate = wxPyBeginAllowThreads();
6564 result = (bool)(arg1)->IsVisible();
6565
6566 wxPyEndAllowThreads(__tstate);
6567 if (PyErr_Occurred()) SWIG_fail;
6568 }
6569 {
6570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6571 }
6572 return resultobj;
6573 fail:
6574 return NULL;
6575 }
6576
6577
6578 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6579 PyObject *resultobj;
6580 wxCaret *arg1 = (wxCaret *) 0 ;
6581 wxPoint result;
6582 PyObject * obj0 = 0 ;
6583 char *kwnames[] = {
6584 (char *) "self", NULL
6585 };
6586
6587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6589 if (SWIG_arg_fail(1)) SWIG_fail;
6590 {
6591 PyThreadState* __tstate = wxPyBeginAllowThreads();
6592 result = (arg1)->GetPosition();
6593
6594 wxPyEndAllowThreads(__tstate);
6595 if (PyErr_Occurred()) SWIG_fail;
6596 }
6597 {
6598 wxPoint * resultptr;
6599 resultptr = new wxPoint((wxPoint &)(result));
6600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6601 }
6602 return resultobj;
6603 fail:
6604 return NULL;
6605 }
6606
6607
6608 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6609 PyObject *resultobj;
6610 wxCaret *arg1 = (wxCaret *) 0 ;
6611 int *arg2 = (int *) 0 ;
6612 int *arg3 = (int *) 0 ;
6613 int temp2 ;
6614 int res2 = 0 ;
6615 int temp3 ;
6616 int res3 = 0 ;
6617 PyObject * obj0 = 0 ;
6618 char *kwnames[] = {
6619 (char *) "self", NULL
6620 };
6621
6622 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6623 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6626 if (SWIG_arg_fail(1)) SWIG_fail;
6627 {
6628 PyThreadState* __tstate = wxPyBeginAllowThreads();
6629 (arg1)->GetPosition(arg2,arg3);
6630
6631 wxPyEndAllowThreads(__tstate);
6632 if (PyErr_Occurred()) SWIG_fail;
6633 }
6634 Py_INCREF(Py_None); resultobj = Py_None;
6635 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6636 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6637 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6638 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6639 return resultobj;
6640 fail:
6641 return NULL;
6642 }
6643
6644
6645 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6646 PyObject *resultobj;
6647 wxCaret *arg1 = (wxCaret *) 0 ;
6648 wxSize result;
6649 PyObject * obj0 = 0 ;
6650 char *kwnames[] = {
6651 (char *) "self", NULL
6652 };
6653
6654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6656 if (SWIG_arg_fail(1)) SWIG_fail;
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 result = (arg1)->GetSize();
6660
6661 wxPyEndAllowThreads(__tstate);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 {
6665 wxSize * resultptr;
6666 resultptr = new wxSize((wxSize &)(result));
6667 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6668 }
6669 return resultobj;
6670 fail:
6671 return NULL;
6672 }
6673
6674
6675 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6676 PyObject *resultobj;
6677 wxCaret *arg1 = (wxCaret *) 0 ;
6678 int *arg2 = (int *) 0 ;
6679 int *arg3 = (int *) 0 ;
6680 int temp2 ;
6681 int res2 = 0 ;
6682 int temp3 ;
6683 int res3 = 0 ;
6684 PyObject * obj0 = 0 ;
6685 char *kwnames[] = {
6686 (char *) "self", NULL
6687 };
6688
6689 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6690 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6693 if (SWIG_arg_fail(1)) SWIG_fail;
6694 {
6695 PyThreadState* __tstate = wxPyBeginAllowThreads();
6696 (arg1)->GetSize(arg2,arg3);
6697
6698 wxPyEndAllowThreads(__tstate);
6699 if (PyErr_Occurred()) SWIG_fail;
6700 }
6701 Py_INCREF(Py_None); resultobj = Py_None;
6702 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6703 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6704 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6705 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6706 return resultobj;
6707 fail:
6708 return NULL;
6709 }
6710
6711
6712 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6713 PyObject *resultobj;
6714 wxCaret *arg1 = (wxCaret *) 0 ;
6715 wxWindow *result;
6716 PyObject * obj0 = 0 ;
6717 char *kwnames[] = {
6718 (char *) "self", NULL
6719 };
6720
6721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6723 if (SWIG_arg_fail(1)) SWIG_fail;
6724 {
6725 PyThreadState* __tstate = wxPyBeginAllowThreads();
6726 result = (wxWindow *)(arg1)->GetWindow();
6727
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 {
6732 resultobj = wxPyMake_wxObject(result, 0);
6733 }
6734 return resultobj;
6735 fail:
6736 return NULL;
6737 }
6738
6739
6740 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6741 PyObject *resultobj;
6742 wxCaret *arg1 = (wxCaret *) 0 ;
6743 int arg2 ;
6744 int arg3 ;
6745 PyObject * obj0 = 0 ;
6746 PyObject * obj1 = 0 ;
6747 PyObject * obj2 = 0 ;
6748 char *kwnames[] = {
6749 (char *) "self",(char *) "x",(char *) "y", NULL
6750 };
6751
6752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6754 if (SWIG_arg_fail(1)) SWIG_fail;
6755 {
6756 arg2 = (int)(SWIG_As_int(obj1));
6757 if (SWIG_arg_fail(2)) SWIG_fail;
6758 }
6759 {
6760 arg3 = (int)(SWIG_As_int(obj2));
6761 if (SWIG_arg_fail(3)) SWIG_fail;
6762 }
6763 {
6764 PyThreadState* __tstate = wxPyBeginAllowThreads();
6765 (arg1)->Move(arg2,arg3);
6766
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 Py_INCREF(Py_None); resultobj = Py_None;
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6778 PyObject *resultobj;
6779 wxCaret *arg1 = (wxCaret *) 0 ;
6780 wxPoint *arg2 = 0 ;
6781 wxPoint temp2 ;
6782 PyObject * obj0 = 0 ;
6783 PyObject * obj1 = 0 ;
6784 char *kwnames[] = {
6785 (char *) "self",(char *) "pt", NULL
6786 };
6787
6788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6790 if (SWIG_arg_fail(1)) SWIG_fail;
6791 {
6792 arg2 = &temp2;
6793 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6794 }
6795 {
6796 PyThreadState* __tstate = wxPyBeginAllowThreads();
6797 (arg1)->Move((wxPoint const &)*arg2);
6798
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 Py_INCREF(Py_None); resultobj = Py_None;
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6810 PyObject *resultobj;
6811 wxCaret *arg1 = (wxCaret *) 0 ;
6812 int arg2 ;
6813 int arg3 ;
6814 PyObject * obj0 = 0 ;
6815 PyObject * obj1 = 0 ;
6816 PyObject * obj2 = 0 ;
6817 char *kwnames[] = {
6818 (char *) "self",(char *) "width",(char *) "height", NULL
6819 };
6820
6821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6823 if (SWIG_arg_fail(1)) SWIG_fail;
6824 {
6825 arg2 = (int)(SWIG_As_int(obj1));
6826 if (SWIG_arg_fail(2)) SWIG_fail;
6827 }
6828 {
6829 arg3 = (int)(SWIG_As_int(obj2));
6830 if (SWIG_arg_fail(3)) SWIG_fail;
6831 }
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 (arg1)->SetSize(arg2,arg3);
6835
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 Py_INCREF(Py_None); resultobj = Py_None;
6840 return resultobj;
6841 fail:
6842 return NULL;
6843 }
6844
6845
6846 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6847 PyObject *resultobj;
6848 wxCaret *arg1 = (wxCaret *) 0 ;
6849 wxSize *arg2 = 0 ;
6850 wxSize temp2 ;
6851 PyObject * obj0 = 0 ;
6852 PyObject * obj1 = 0 ;
6853 char *kwnames[] = {
6854 (char *) "self",(char *) "size", NULL
6855 };
6856
6857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6859 if (SWIG_arg_fail(1)) SWIG_fail;
6860 {
6861 arg2 = &temp2;
6862 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6863 }
6864 {
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 (arg1)->SetSize((wxSize const &)*arg2);
6867
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 Py_INCREF(Py_None); resultobj = Py_None;
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6879 PyObject *resultobj;
6880 wxCaret *arg1 = (wxCaret *) 0 ;
6881 int arg2 = (int) true ;
6882 PyObject * obj0 = 0 ;
6883 PyObject * obj1 = 0 ;
6884 char *kwnames[] = {
6885 (char *) "self",(char *) "show", NULL
6886 };
6887
6888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6890 if (SWIG_arg_fail(1)) SWIG_fail;
6891 if (obj1) {
6892 {
6893 arg2 = (int)(SWIG_As_int(obj1));
6894 if (SWIG_arg_fail(2)) SWIG_fail;
6895 }
6896 }
6897 {
6898 PyThreadState* __tstate = wxPyBeginAllowThreads();
6899 (arg1)->Show(arg2);
6900
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 Py_INCREF(Py_None); resultobj = Py_None;
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6912 PyObject *resultobj;
6913 wxCaret *arg1 = (wxCaret *) 0 ;
6914 PyObject * obj0 = 0 ;
6915 char *kwnames[] = {
6916 (char *) "self", NULL
6917 };
6918
6919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6921 if (SWIG_arg_fail(1)) SWIG_fail;
6922 {
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 (arg1)->Hide();
6925
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 Py_INCREF(Py_None); resultobj = Py_None;
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6937 PyObject *resultobj;
6938 int result;
6939 char *kwnames[] = {
6940 NULL
6941 };
6942
6943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6944 {
6945 PyThreadState* __tstate = wxPyBeginAllowThreads();
6946 result = (int)wxCaret::GetBlinkTime();
6947
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 {
6952 resultobj = SWIG_From_int((int)(result));
6953 }
6954 return resultobj;
6955 fail:
6956 return NULL;
6957 }
6958
6959
6960 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6961 PyObject *resultobj;
6962 int arg1 ;
6963 PyObject * obj0 = 0 ;
6964 char *kwnames[] = {
6965 (char *) "milliseconds", NULL
6966 };
6967
6968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6969 {
6970 arg1 = (int)(SWIG_As_int(obj0));
6971 if (SWIG_arg_fail(1)) SWIG_fail;
6972 }
6973 {
6974 PyThreadState* __tstate = wxPyBeginAllowThreads();
6975 wxCaret::SetBlinkTime(arg1);
6976
6977 wxPyEndAllowThreads(__tstate);
6978 if (PyErr_Occurred()) SWIG_fail;
6979 }
6980 Py_INCREF(Py_None); resultobj = Py_None;
6981 return resultobj;
6982 fail:
6983 return NULL;
6984 }
6985
6986
6987 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6988 PyObject *obj;
6989 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6990 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6991 Py_INCREF(obj);
6992 return Py_BuildValue((char *)"");
6993 }
6994 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6995 PyObject *resultobj;
6996 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6997 wxBusyCursor *result;
6998 PyObject * obj0 = 0 ;
6999 char *kwnames[] = {
7000 (char *) "cursor", NULL
7001 };
7002
7003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7004 if (obj0) {
7005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7006 if (SWIG_arg_fail(1)) SWIG_fail;
7007 }
7008 {
7009 if (!wxPyCheckForApp()) SWIG_fail;
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7012
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj;
7025 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7026 PyObject * obj0 = 0 ;
7027 char *kwnames[] = {
7028 (char *) "self", NULL
7029 };
7030
7031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7033 if (SWIG_arg_fail(1)) SWIG_fail;
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 delete arg1;
7037
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 Py_INCREF(Py_None); resultobj = Py_None;
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7049 PyObject *obj;
7050 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7051 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7052 Py_INCREF(obj);
7053 return Py_BuildValue((char *)"");
7054 }
7055 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7056 PyObject *resultobj;
7057 wxWindow *arg1 = (wxWindow *) NULL ;
7058 wxWindowDisabler *result;
7059 PyObject * obj0 = 0 ;
7060 char *kwnames[] = {
7061 (char *) "winToSkip", NULL
7062 };
7063
7064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7065 if (obj0) {
7066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7067 if (SWIG_arg_fail(1)) SWIG_fail;
7068 }
7069 {
7070 if (!wxPyCheckForApp()) SWIG_fail;
7071 PyThreadState* __tstate = wxPyBeginAllowThreads();
7072 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7073
7074 wxPyEndAllowThreads(__tstate);
7075 if (PyErr_Occurred()) SWIG_fail;
7076 }
7077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7078 return resultobj;
7079 fail:
7080 return NULL;
7081 }
7082
7083
7084 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7085 PyObject *resultobj;
7086 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7087 PyObject * obj0 = 0 ;
7088 char *kwnames[] = {
7089 (char *) "self", NULL
7090 };
7091
7092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7094 if (SWIG_arg_fail(1)) SWIG_fail;
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 delete arg1;
7098
7099 wxPyEndAllowThreads(__tstate);
7100 if (PyErr_Occurred()) SWIG_fail;
7101 }
7102 Py_INCREF(Py_None); resultobj = Py_None;
7103 return resultobj;
7104 fail:
7105 return NULL;
7106 }
7107
7108
7109 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7110 PyObject *obj;
7111 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7112 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7113 Py_INCREF(obj);
7114 return Py_BuildValue((char *)"");
7115 }
7116 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7117 PyObject *resultobj;
7118 wxString *arg1 = 0 ;
7119 wxBusyInfo *result;
7120 bool temp1 = false ;
7121 PyObject * obj0 = 0 ;
7122 char *kwnames[] = {
7123 (char *) "message", NULL
7124 };
7125
7126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7127 {
7128 arg1 = wxString_in_helper(obj0);
7129 if (arg1 == NULL) SWIG_fail;
7130 temp1 = true;
7131 }
7132 {
7133 if (!wxPyCheckForApp()) SWIG_fail;
7134 PyThreadState* __tstate = wxPyBeginAllowThreads();
7135 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7136
7137 wxPyEndAllowThreads(__tstate);
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7141 {
7142 if (temp1)
7143 delete arg1;
7144 }
7145 return resultobj;
7146 fail:
7147 {
7148 if (temp1)
7149 delete arg1;
7150 }
7151 return NULL;
7152 }
7153
7154
7155 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7156 PyObject *resultobj;
7157 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7158 PyObject * obj0 = 0 ;
7159 char *kwnames[] = {
7160 (char *) "self", NULL
7161 };
7162
7163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7165 if (SWIG_arg_fail(1)) SWIG_fail;
7166 {
7167 PyThreadState* __tstate = wxPyBeginAllowThreads();
7168 delete arg1;
7169
7170 wxPyEndAllowThreads(__tstate);
7171 if (PyErr_Occurred()) SWIG_fail;
7172 }
7173 Py_INCREF(Py_None); resultobj = Py_None;
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7181 PyObject *obj;
7182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7183 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7184 Py_INCREF(obj);
7185 return Py_BuildValue((char *)"");
7186 }
7187 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7188 PyObject *resultobj;
7189 wxStopWatch *result;
7190 char *kwnames[] = {
7191 NULL
7192 };
7193
7194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7195 {
7196 PyThreadState* __tstate = wxPyBeginAllowThreads();
7197 result = (wxStopWatch *)new wxStopWatch();
7198
7199 wxPyEndAllowThreads(__tstate);
7200 if (PyErr_Occurred()) SWIG_fail;
7201 }
7202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj;
7211 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7212 long arg2 = (long) 0 ;
7213 PyObject * obj0 = 0 ;
7214 PyObject * obj1 = 0 ;
7215 char *kwnames[] = {
7216 (char *) "self",(char *) "t0", NULL
7217 };
7218
7219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7221 if (SWIG_arg_fail(1)) SWIG_fail;
7222 if (obj1) {
7223 {
7224 arg2 = (long)(SWIG_As_long(obj1));
7225 if (SWIG_arg_fail(2)) SWIG_fail;
7226 }
7227 }
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 (arg1)->Start(arg2);
7231
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 Py_INCREF(Py_None); resultobj = Py_None;
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj;
7244 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7245 PyObject * obj0 = 0 ;
7246 char *kwnames[] = {
7247 (char *) "self", NULL
7248 };
7249
7250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7252 if (SWIG_arg_fail(1)) SWIG_fail;
7253 {
7254 PyThreadState* __tstate = wxPyBeginAllowThreads();
7255 (arg1)->Pause();
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_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7268 PyObject *resultobj;
7269 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7270 PyObject * obj0 = 0 ;
7271 char *kwnames[] = {
7272 (char *) "self", NULL
7273 };
7274
7275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7277 if (SWIG_arg_fail(1)) SWIG_fail;
7278 {
7279 PyThreadState* __tstate = wxPyBeginAllowThreads();
7280 (arg1)->Resume();
7281
7282 wxPyEndAllowThreads(__tstate);
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 Py_INCREF(Py_None); resultobj = Py_None;
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj;
7294 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7295 long result;
7296 PyObject * obj0 = 0 ;
7297 char *kwnames[] = {
7298 (char *) "self", NULL
7299 };
7300
7301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7303 if (SWIG_arg_fail(1)) SWIG_fail;
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = (long)((wxStopWatch const *)arg1)->Time();
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 {
7312 resultobj = SWIG_From_long((long)(result));
7313 }
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7321 PyObject *obj;
7322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7323 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7324 Py_INCREF(obj);
7325 return Py_BuildValue((char *)"");
7326 }
7327 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7328 PyObject *resultobj;
7329 int arg1 = (int) 9 ;
7330 int arg2 = (int) wxID_FILE1 ;
7331 wxFileHistory *result;
7332 PyObject * obj0 = 0 ;
7333 PyObject * obj1 = 0 ;
7334 char *kwnames[] = {
7335 (char *) "maxFiles",(char *) "idBase", NULL
7336 };
7337
7338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7339 if (obj0) {
7340 {
7341 arg1 = (int)(SWIG_As_int(obj0));
7342 if (SWIG_arg_fail(1)) SWIG_fail;
7343 }
7344 }
7345 if (obj1) {
7346 {
7347 arg2 = (int)(SWIG_As_int(obj1));
7348 if (SWIG_arg_fail(2)) SWIG_fail;
7349 }
7350 }
7351 {
7352 PyThreadState* __tstate = wxPyBeginAllowThreads();
7353 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7354
7355 wxPyEndAllowThreads(__tstate);
7356 if (PyErr_Occurred()) SWIG_fail;
7357 }
7358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7359 return resultobj;
7360 fail:
7361 return NULL;
7362 }
7363
7364
7365 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7366 PyObject *resultobj;
7367 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7368 PyObject * obj0 = 0 ;
7369 char *kwnames[] = {
7370 (char *) "self", NULL
7371 };
7372
7373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7375 if (SWIG_arg_fail(1)) SWIG_fail;
7376 {
7377 PyThreadState* __tstate = wxPyBeginAllowThreads();
7378 delete arg1;
7379
7380 wxPyEndAllowThreads(__tstate);
7381 if (PyErr_Occurred()) SWIG_fail;
7382 }
7383 Py_INCREF(Py_None); resultobj = Py_None;
7384 return resultobj;
7385 fail:
7386 return NULL;
7387 }
7388
7389
7390 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7391 PyObject *resultobj;
7392 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7393 wxString *arg2 = 0 ;
7394 bool temp2 = false ;
7395 PyObject * obj0 = 0 ;
7396 PyObject * obj1 = 0 ;
7397 char *kwnames[] = {
7398 (char *) "self",(char *) "file", NULL
7399 };
7400
7401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7403 if (SWIG_arg_fail(1)) SWIG_fail;
7404 {
7405 arg2 = wxString_in_helper(obj1);
7406 if (arg2 == NULL) SWIG_fail;
7407 temp2 = true;
7408 }
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 (arg1)->AddFileToHistory((wxString const &)*arg2);
7412
7413 wxPyEndAllowThreads(__tstate);
7414 if (PyErr_Occurred()) SWIG_fail;
7415 }
7416 Py_INCREF(Py_None); resultobj = Py_None;
7417 {
7418 if (temp2)
7419 delete arg2;
7420 }
7421 return resultobj;
7422 fail:
7423 {
7424 if (temp2)
7425 delete arg2;
7426 }
7427 return NULL;
7428 }
7429
7430
7431 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7432 PyObject *resultobj;
7433 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7434 int arg2 ;
7435 PyObject * obj0 = 0 ;
7436 PyObject * obj1 = 0 ;
7437 char *kwnames[] = {
7438 (char *) "self",(char *) "i", NULL
7439 };
7440
7441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7443 if (SWIG_arg_fail(1)) SWIG_fail;
7444 {
7445 arg2 = (int)(SWIG_As_int(obj1));
7446 if (SWIG_arg_fail(2)) SWIG_fail;
7447 }
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 (arg1)->RemoveFileFromHistory(arg2);
7451
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 Py_INCREF(Py_None); resultobj = Py_None;
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7463 PyObject *resultobj;
7464 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7465 int result;
7466 PyObject * obj0 = 0 ;
7467 char *kwnames[] = {
7468 (char *) "self", NULL
7469 };
7470
7471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7473 if (SWIG_arg_fail(1)) SWIG_fail;
7474 {
7475 PyThreadState* __tstate = wxPyBeginAllowThreads();
7476 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7477
7478 wxPyEndAllowThreads(__tstate);
7479 if (PyErr_Occurred()) SWIG_fail;
7480 }
7481 {
7482 resultobj = SWIG_From_int((int)(result));
7483 }
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7491 PyObject *resultobj;
7492 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7493 wxMenu *arg2 = (wxMenu *) 0 ;
7494 PyObject * obj0 = 0 ;
7495 PyObject * obj1 = 0 ;
7496 char *kwnames[] = {
7497 (char *) "self",(char *) "menu", NULL
7498 };
7499
7500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7502 if (SWIG_arg_fail(1)) SWIG_fail;
7503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7504 if (SWIG_arg_fail(2)) SWIG_fail;
7505 {
7506 PyThreadState* __tstate = wxPyBeginAllowThreads();
7507 (arg1)->UseMenu(arg2);
7508
7509 wxPyEndAllowThreads(__tstate);
7510 if (PyErr_Occurred()) SWIG_fail;
7511 }
7512 Py_INCREF(Py_None); resultobj = Py_None;
7513 return resultobj;
7514 fail:
7515 return NULL;
7516 }
7517
7518
7519 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7520 PyObject *resultobj;
7521 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7522 wxMenu *arg2 = (wxMenu *) 0 ;
7523 PyObject * obj0 = 0 ;
7524 PyObject * obj1 = 0 ;
7525 char *kwnames[] = {
7526 (char *) "self",(char *) "menu", NULL
7527 };
7528
7529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7531 if (SWIG_arg_fail(1)) SWIG_fail;
7532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7533 if (SWIG_arg_fail(2)) SWIG_fail;
7534 {
7535 PyThreadState* __tstate = wxPyBeginAllowThreads();
7536 (arg1)->RemoveMenu(arg2);
7537
7538 wxPyEndAllowThreads(__tstate);
7539 if (PyErr_Occurred()) SWIG_fail;
7540 }
7541 Py_INCREF(Py_None); resultobj = Py_None;
7542 return resultobj;
7543 fail:
7544 return NULL;
7545 }
7546
7547
7548 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7549 PyObject *resultobj;
7550 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7551 wxConfigBase *arg2 = 0 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 char *kwnames[] = {
7555 (char *) "self",(char *) "config", NULL
7556 };
7557
7558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7560 if (SWIG_arg_fail(1)) SWIG_fail;
7561 {
7562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7563 if (SWIG_arg_fail(2)) SWIG_fail;
7564 if (arg2 == NULL) {
7565 SWIG_null_ref("wxConfigBase");
7566 }
7567 if (SWIG_arg_fail(2)) SWIG_fail;
7568 }
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 (arg1)->Load(*arg2);
7572
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 Py_INCREF(Py_None); resultobj = Py_None;
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj;
7585 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7586 wxConfigBase *arg2 = 0 ;
7587 PyObject * obj0 = 0 ;
7588 PyObject * obj1 = 0 ;
7589 char *kwnames[] = {
7590 (char *) "self",(char *) "config", NULL
7591 };
7592
7593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7595 if (SWIG_arg_fail(1)) SWIG_fail;
7596 {
7597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7598 if (SWIG_arg_fail(2)) SWIG_fail;
7599 if (arg2 == NULL) {
7600 SWIG_null_ref("wxConfigBase");
7601 }
7602 if (SWIG_arg_fail(2)) SWIG_fail;
7603 }
7604 {
7605 PyThreadState* __tstate = wxPyBeginAllowThreads();
7606 (arg1)->Save(*arg2);
7607
7608 wxPyEndAllowThreads(__tstate);
7609 if (PyErr_Occurred()) SWIG_fail;
7610 }
7611 Py_INCREF(Py_None); resultobj = Py_None;
7612 return resultobj;
7613 fail:
7614 return NULL;
7615 }
7616
7617
7618 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7619 PyObject *resultobj;
7620 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7621 PyObject * obj0 = 0 ;
7622 char *kwnames[] = {
7623 (char *) "self", NULL
7624 };
7625
7626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7628 if (SWIG_arg_fail(1)) SWIG_fail;
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 (arg1)->AddFilesToMenu();
7632
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 Py_INCREF(Py_None); resultobj = Py_None;
7637 return resultobj;
7638 fail:
7639 return NULL;
7640 }
7641
7642
7643 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7644 PyObject *resultobj;
7645 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7646 wxMenu *arg2 = (wxMenu *) 0 ;
7647 PyObject * obj0 = 0 ;
7648 PyObject * obj1 = 0 ;
7649 char *kwnames[] = {
7650 (char *) "self",(char *) "menu", NULL
7651 };
7652
7653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7655 if (SWIG_arg_fail(1)) SWIG_fail;
7656 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7657 if (SWIG_arg_fail(2)) SWIG_fail;
7658 {
7659 PyThreadState* __tstate = wxPyBeginAllowThreads();
7660 (arg1)->AddFilesToMenu(arg2);
7661
7662 wxPyEndAllowThreads(__tstate);
7663 if (PyErr_Occurred()) SWIG_fail;
7664 }
7665 Py_INCREF(Py_None); resultobj = Py_None;
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7673 PyObject *resultobj;
7674 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7675 int arg2 ;
7676 wxString result;
7677 PyObject * obj0 = 0 ;
7678 PyObject * obj1 = 0 ;
7679 char *kwnames[] = {
7680 (char *) "self",(char *) "i", NULL
7681 };
7682
7683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7685 if (SWIG_arg_fail(1)) SWIG_fail;
7686 {
7687 arg2 = (int)(SWIG_As_int(obj1));
7688 if (SWIG_arg_fail(2)) SWIG_fail;
7689 }
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 #if wxUSE_UNICODE
7699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7700 #else
7701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7702 #endif
7703 }
7704 return resultobj;
7705 fail:
7706 return NULL;
7707 }
7708
7709
7710 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7711 PyObject *resultobj;
7712 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7713 int result;
7714 PyObject * obj0 = 0 ;
7715 char *kwnames[] = {
7716 (char *) "self", NULL
7717 };
7718
7719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7721 if (SWIG_arg_fail(1)) SWIG_fail;
7722 {
7723 PyThreadState* __tstate = wxPyBeginAllowThreads();
7724 result = (int)((wxFileHistory const *)arg1)->GetCount();
7725
7726 wxPyEndAllowThreads(__tstate);
7727 if (PyErr_Occurred()) SWIG_fail;
7728 }
7729 {
7730 resultobj = SWIG_From_int((int)(result));
7731 }
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7739 PyObject *obj;
7740 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7741 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7742 Py_INCREF(obj);
7743 return Py_BuildValue((char *)"");
7744 }
7745 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7746 PyObject *resultobj;
7747 wxString *arg1 = 0 ;
7748 wxString const &arg2_defvalue = wxPyEmptyString ;
7749 wxString *arg2 = (wxString *) &arg2_defvalue ;
7750 wxSingleInstanceChecker *result;
7751 bool temp1 = false ;
7752 bool temp2 = false ;
7753 PyObject * obj0 = 0 ;
7754 PyObject * obj1 = 0 ;
7755 char *kwnames[] = {
7756 (char *) "name",(char *) "path", NULL
7757 };
7758
7759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7760 {
7761 arg1 = wxString_in_helper(obj0);
7762 if (arg1 == NULL) SWIG_fail;
7763 temp1 = true;
7764 }
7765 if (obj1) {
7766 {
7767 arg2 = wxString_in_helper(obj1);
7768 if (arg2 == NULL) SWIG_fail;
7769 temp2 = true;
7770 }
7771 }
7772 {
7773 PyThreadState* __tstate = wxPyBeginAllowThreads();
7774 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7775
7776 wxPyEndAllowThreads(__tstate);
7777 if (PyErr_Occurred()) SWIG_fail;
7778 }
7779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7780 {
7781 if (temp1)
7782 delete arg1;
7783 }
7784 {
7785 if (temp2)
7786 delete arg2;
7787 }
7788 return resultobj;
7789 fail:
7790 {
7791 if (temp1)
7792 delete arg1;
7793 }
7794 {
7795 if (temp2)
7796 delete arg2;
7797 }
7798 return NULL;
7799 }
7800
7801
7802 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7803 PyObject *resultobj;
7804 wxSingleInstanceChecker *result;
7805 char *kwnames[] = {
7806 NULL
7807 };
7808
7809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7810 {
7811 PyThreadState* __tstate = wxPyBeginAllowThreads();
7812 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7813
7814 wxPyEndAllowThreads(__tstate);
7815 if (PyErr_Occurred()) SWIG_fail;
7816 }
7817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7825 PyObject *resultobj;
7826 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7827 PyObject * obj0 = 0 ;
7828 char *kwnames[] = {
7829 (char *) "self", NULL
7830 };
7831
7832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7834 if (SWIG_arg_fail(1)) SWIG_fail;
7835 {
7836 PyThreadState* __tstate = wxPyBeginAllowThreads();
7837 delete arg1;
7838
7839 wxPyEndAllowThreads(__tstate);
7840 if (PyErr_Occurred()) SWIG_fail;
7841 }
7842 Py_INCREF(Py_None); resultobj = Py_None;
7843 return resultobj;
7844 fail:
7845 return NULL;
7846 }
7847
7848
7849 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7850 PyObject *resultobj;
7851 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7852 wxString *arg2 = 0 ;
7853 wxString const &arg3_defvalue = wxPyEmptyString ;
7854 wxString *arg3 = (wxString *) &arg3_defvalue ;
7855 bool result;
7856 bool temp2 = false ;
7857 bool temp3 = false ;
7858 PyObject * obj0 = 0 ;
7859 PyObject * obj1 = 0 ;
7860 PyObject * obj2 = 0 ;
7861 char *kwnames[] = {
7862 (char *) "self",(char *) "name",(char *) "path", NULL
7863 };
7864
7865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7867 if (SWIG_arg_fail(1)) SWIG_fail;
7868 {
7869 arg2 = wxString_in_helper(obj1);
7870 if (arg2 == NULL) SWIG_fail;
7871 temp2 = true;
7872 }
7873 if (obj2) {
7874 {
7875 arg3 = wxString_in_helper(obj2);
7876 if (arg3 == NULL) SWIG_fail;
7877 temp3 = true;
7878 }
7879 }
7880 {
7881 PyThreadState* __tstate = wxPyBeginAllowThreads();
7882 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7883
7884 wxPyEndAllowThreads(__tstate);
7885 if (PyErr_Occurred()) SWIG_fail;
7886 }
7887 {
7888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7889 }
7890 {
7891 if (temp2)
7892 delete arg2;
7893 }
7894 {
7895 if (temp3)
7896 delete arg3;
7897 }
7898 return resultobj;
7899 fail:
7900 {
7901 if (temp2)
7902 delete arg2;
7903 }
7904 {
7905 if (temp3)
7906 delete arg3;
7907 }
7908 return NULL;
7909 }
7910
7911
7912 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7913 PyObject *resultobj;
7914 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7915 bool result;
7916 PyObject * obj0 = 0 ;
7917 char *kwnames[] = {
7918 (char *) "self", NULL
7919 };
7920
7921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7923 if (SWIG_arg_fail(1)) SWIG_fail;
7924 {
7925 PyThreadState* __tstate = wxPyBeginAllowThreads();
7926 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7927
7928 wxPyEndAllowThreads(__tstate);
7929 if (PyErr_Occurred()) SWIG_fail;
7930 }
7931 {
7932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7933 }
7934 return resultobj;
7935 fail:
7936 return NULL;
7937 }
7938
7939
7940 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7941 PyObject *obj;
7942 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7943 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7944 Py_INCREF(obj);
7945 return Py_BuildValue((char *)"");
7946 }
7947 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7948 PyObject *resultobj;
7949 wxWindow *arg1 = (wxWindow *) 0 ;
7950 wxDC *arg2 = 0 ;
7951 bool result;
7952 PyObject * obj0 = 0 ;
7953 PyObject * obj1 = 0 ;
7954 char *kwnames[] = {
7955 (char *) "window",(char *) "dc", NULL
7956 };
7957
7958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7960 if (SWIG_arg_fail(1)) SWIG_fail;
7961 {
7962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7963 if (SWIG_arg_fail(2)) SWIG_fail;
7964 if (arg2 == NULL) {
7965 SWIG_null_ref("wxDC");
7966 }
7967 if (SWIG_arg_fail(2)) SWIG_fail;
7968 }
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7972
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 {
7977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7978 }
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7986 PyObject *resultobj;
7987 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7988 PyObject * obj0 = 0 ;
7989 char *kwnames[] = {
7990 (char *) "self", NULL
7991 };
7992
7993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7995 if (SWIG_arg_fail(1)) SWIG_fail;
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 delete arg1;
7999
8000 wxPyEndAllowThreads(__tstate);
8001 if (PyErr_Occurred()) SWIG_fail;
8002 }
8003 Py_INCREF(Py_None); resultobj = Py_None;
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8011 PyObject *resultobj;
8012 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8013 wxString result;
8014 PyObject * obj0 = 0 ;
8015 char *kwnames[] = {
8016 (char *) "self", NULL
8017 };
8018
8019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8021 if (SWIG_arg_fail(1)) SWIG_fail;
8022 {
8023 PyThreadState* __tstate = wxPyBeginAllowThreads();
8024 result = (arg1)->GetTip();
8025
8026 wxPyEndAllowThreads(__tstate);
8027 if (PyErr_Occurred()) SWIG_fail;
8028 }
8029 {
8030 #if wxUSE_UNICODE
8031 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8032 #else
8033 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8034 #endif
8035 }
8036 return resultobj;
8037 fail:
8038 return NULL;
8039 }
8040
8041
8042 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8043 PyObject *resultobj;
8044 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8045 size_t result;
8046 PyObject * obj0 = 0 ;
8047 char *kwnames[] = {
8048 (char *) "self", NULL
8049 };
8050
8051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8053 if (SWIG_arg_fail(1)) SWIG_fail;
8054 {
8055 PyThreadState* __tstate = wxPyBeginAllowThreads();
8056 result = (size_t)(arg1)->GetCurrentTip();
8057
8058 wxPyEndAllowThreads(__tstate);
8059 if (PyErr_Occurred()) SWIG_fail;
8060 }
8061 {
8062 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8063 }
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8071 PyObject *resultobj;
8072 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8073 wxString *arg2 = 0 ;
8074 wxString result;
8075 bool temp2 = false ;
8076 PyObject * obj0 = 0 ;
8077 PyObject * obj1 = 0 ;
8078 char *kwnames[] = {
8079 (char *) "self",(char *) "tip", NULL
8080 };
8081
8082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8084 if (SWIG_arg_fail(1)) SWIG_fail;
8085 {
8086 arg2 = wxString_in_helper(obj1);
8087 if (arg2 == NULL) SWIG_fail;
8088 temp2 = true;
8089 }
8090 {
8091 PyThreadState* __tstate = wxPyBeginAllowThreads();
8092 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8093
8094 wxPyEndAllowThreads(__tstate);
8095 if (PyErr_Occurred()) SWIG_fail;
8096 }
8097 {
8098 #if wxUSE_UNICODE
8099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8100 #else
8101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8102 #endif
8103 }
8104 {
8105 if (temp2)
8106 delete arg2;
8107 }
8108 return resultobj;
8109 fail:
8110 {
8111 if (temp2)
8112 delete arg2;
8113 }
8114 return NULL;
8115 }
8116
8117
8118 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8119 PyObject *obj;
8120 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8121 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8122 Py_INCREF(obj);
8123 return Py_BuildValue((char *)"");
8124 }
8125 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8126 PyObject *resultobj;
8127 size_t arg1 ;
8128 wxPyTipProvider *result;
8129 PyObject * obj0 = 0 ;
8130 char *kwnames[] = {
8131 (char *) "currentTip", NULL
8132 };
8133
8134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8135 {
8136 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8137 if (SWIG_arg_fail(1)) SWIG_fail;
8138 }
8139 {
8140 PyThreadState* __tstate = wxPyBeginAllowThreads();
8141 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8142
8143 wxPyEndAllowThreads(__tstate);
8144 if (PyErr_Occurred()) SWIG_fail;
8145 }
8146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8147 return resultobj;
8148 fail:
8149 return NULL;
8150 }
8151
8152
8153 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8154 PyObject *resultobj;
8155 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8156 PyObject *arg2 = (PyObject *) 0 ;
8157 PyObject *arg3 = (PyObject *) 0 ;
8158 PyObject * obj0 = 0 ;
8159 PyObject * obj1 = 0 ;
8160 PyObject * obj2 = 0 ;
8161 char *kwnames[] = {
8162 (char *) "self",(char *) "self",(char *) "_class", NULL
8163 };
8164
8165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8167 if (SWIG_arg_fail(1)) SWIG_fail;
8168 arg2 = obj1;
8169 arg3 = obj2;
8170 {
8171 PyThreadState* __tstate = wxPyBeginAllowThreads();
8172 (arg1)->_setCallbackInfo(arg2,arg3);
8173
8174 wxPyEndAllowThreads(__tstate);
8175 if (PyErr_Occurred()) SWIG_fail;
8176 }
8177 Py_INCREF(Py_None); resultobj = Py_None;
8178 return resultobj;
8179 fail:
8180 return NULL;
8181 }
8182
8183
8184 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8185 PyObject *obj;
8186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8187 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8188 Py_INCREF(obj);
8189 return Py_BuildValue((char *)"");
8190 }
8191 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8192 PyObject *resultobj;
8193 wxWindow *arg1 = (wxWindow *) 0 ;
8194 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8195 bool arg3 = (bool) true ;
8196 bool result;
8197 PyObject * obj0 = 0 ;
8198 PyObject * obj1 = 0 ;
8199 PyObject * obj2 = 0 ;
8200 char *kwnames[] = {
8201 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8202 };
8203
8204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8206 if (SWIG_arg_fail(1)) SWIG_fail;
8207 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8208 if (SWIG_arg_fail(2)) SWIG_fail;
8209 if (obj2) {
8210 {
8211 arg3 = (bool)(SWIG_As_bool(obj2));
8212 if (SWIG_arg_fail(3)) SWIG_fail;
8213 }
8214 }
8215 {
8216 if (!wxPyCheckForApp()) SWIG_fail;
8217 PyThreadState* __tstate = wxPyBeginAllowThreads();
8218 result = (bool)wxShowTip(arg1,arg2,arg3);
8219
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 {
8224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8225 }
8226 return resultobj;
8227 fail:
8228 return NULL;
8229 }
8230
8231
8232 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8233 PyObject *resultobj;
8234 wxString *arg1 = 0 ;
8235 size_t arg2 ;
8236 wxTipProvider *result;
8237 bool temp1 = false ;
8238 PyObject * obj0 = 0 ;
8239 PyObject * obj1 = 0 ;
8240 char *kwnames[] = {
8241 (char *) "filename",(char *) "currentTip", NULL
8242 };
8243
8244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8245 {
8246 arg1 = wxString_in_helper(obj0);
8247 if (arg1 == NULL) SWIG_fail;
8248 temp1 = true;
8249 }
8250 {
8251 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8252 if (SWIG_arg_fail(2)) SWIG_fail;
8253 }
8254 {
8255 if (!wxPyCheckForApp()) SWIG_fail;
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8258
8259 wxPyEndAllowThreads(__tstate);
8260 if (PyErr_Occurred()) SWIG_fail;
8261 }
8262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8263 {
8264 if (temp1)
8265 delete arg1;
8266 }
8267 return resultobj;
8268 fail:
8269 {
8270 if (temp1)
8271 delete arg1;
8272 }
8273 return NULL;
8274 }
8275
8276
8277 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8278 PyObject *resultobj;
8279 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8280 int arg2 = (int) -1 ;
8281 wxPyTimer *result;
8282 PyObject * obj0 = 0 ;
8283 PyObject * obj1 = 0 ;
8284 char *kwnames[] = {
8285 (char *) "owner",(char *) "id", NULL
8286 };
8287
8288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8289 if (obj0) {
8290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8291 if (SWIG_arg_fail(1)) SWIG_fail;
8292 }
8293 if (obj1) {
8294 {
8295 arg2 = (int)(SWIG_As_int(obj1));
8296 if (SWIG_arg_fail(2)) SWIG_fail;
8297 }
8298 }
8299 {
8300 if (!wxPyCheckForApp()) SWIG_fail;
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8303
8304 wxPyEndAllowThreads(__tstate);
8305 if (PyErr_Occurred()) SWIG_fail;
8306 }
8307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8315 PyObject *resultobj;
8316 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8317 PyObject * obj0 = 0 ;
8318 char *kwnames[] = {
8319 (char *) "self", NULL
8320 };
8321
8322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8324 if (SWIG_arg_fail(1)) SWIG_fail;
8325 {
8326 PyThreadState* __tstate = wxPyBeginAllowThreads();
8327 delete arg1;
8328
8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 Py_INCREF(Py_None); resultobj = Py_None;
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj;
8341 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8342 PyObject *arg2 = (PyObject *) 0 ;
8343 PyObject *arg3 = (PyObject *) 0 ;
8344 int arg4 = (int) 1 ;
8345 PyObject * obj0 = 0 ;
8346 PyObject * obj1 = 0 ;
8347 PyObject * obj2 = 0 ;
8348 PyObject * obj3 = 0 ;
8349 char *kwnames[] = {
8350 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8351 };
8352
8353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8355 if (SWIG_arg_fail(1)) SWIG_fail;
8356 arg2 = obj1;
8357 arg3 = obj2;
8358 if (obj3) {
8359 {
8360 arg4 = (int)(SWIG_As_int(obj3));
8361 if (SWIG_arg_fail(4)) SWIG_fail;
8362 }
8363 }
8364 {
8365 PyThreadState* __tstate = wxPyBeginAllowThreads();
8366 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8367
8368 wxPyEndAllowThreads(__tstate);
8369 if (PyErr_Occurred()) SWIG_fail;
8370 }
8371 Py_INCREF(Py_None); resultobj = Py_None;
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8379 PyObject *resultobj;
8380 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8381 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8382 int arg3 = (int) -1 ;
8383 PyObject * obj0 = 0 ;
8384 PyObject * obj1 = 0 ;
8385 PyObject * obj2 = 0 ;
8386 char *kwnames[] = {
8387 (char *) "self",(char *) "owner",(char *) "id", NULL
8388 };
8389
8390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8392 if (SWIG_arg_fail(1)) SWIG_fail;
8393 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8394 if (SWIG_arg_fail(2)) SWIG_fail;
8395 if (obj2) {
8396 {
8397 arg3 = (int)(SWIG_As_int(obj2));
8398 if (SWIG_arg_fail(3)) SWIG_fail;
8399 }
8400 }
8401 {
8402 PyThreadState* __tstate = wxPyBeginAllowThreads();
8403 (arg1)->SetOwner(arg2,arg3);
8404
8405 wxPyEndAllowThreads(__tstate);
8406 if (PyErr_Occurred()) SWIG_fail;
8407 }
8408 Py_INCREF(Py_None); resultobj = Py_None;
8409 return resultobj;
8410 fail:
8411 return NULL;
8412 }
8413
8414
8415 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8416 PyObject *resultobj;
8417 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8418 wxEvtHandler *result;
8419 PyObject * obj0 = 0 ;
8420 char *kwnames[] = {
8421 (char *) "self", NULL
8422 };
8423
8424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8426 if (SWIG_arg_fail(1)) SWIG_fail;
8427 {
8428 PyThreadState* __tstate = wxPyBeginAllowThreads();
8429 result = (wxEvtHandler *)(arg1)->GetOwner();
8430
8431 wxPyEndAllowThreads(__tstate);
8432 if (PyErr_Occurred()) SWIG_fail;
8433 }
8434 {
8435 resultobj = wxPyMake_wxObject(result, 0);
8436 }
8437 return resultobj;
8438 fail:
8439 return NULL;
8440 }
8441
8442
8443 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8444 PyObject *resultobj;
8445 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8446 int arg2 = (int) -1 ;
8447 bool arg3 = (bool) false ;
8448 bool result;
8449 PyObject * obj0 = 0 ;
8450 PyObject * obj1 = 0 ;
8451 PyObject * obj2 = 0 ;
8452 char *kwnames[] = {
8453 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8454 };
8455
8456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8458 if (SWIG_arg_fail(1)) SWIG_fail;
8459 if (obj1) {
8460 {
8461 arg2 = (int)(SWIG_As_int(obj1));
8462 if (SWIG_arg_fail(2)) SWIG_fail;
8463 }
8464 }
8465 if (obj2) {
8466 {
8467 arg3 = (bool)(SWIG_As_bool(obj2));
8468 if (SWIG_arg_fail(3)) SWIG_fail;
8469 }
8470 }
8471 {
8472 PyThreadState* __tstate = wxPyBeginAllowThreads();
8473 result = (bool)(arg1)->Start(arg2,arg3);
8474
8475 wxPyEndAllowThreads(__tstate);
8476 if (PyErr_Occurred()) SWIG_fail;
8477 }
8478 {
8479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8480 }
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8488 PyObject *resultobj;
8489 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8490 PyObject * obj0 = 0 ;
8491 char *kwnames[] = {
8492 (char *) "self", NULL
8493 };
8494
8495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8497 if (SWIG_arg_fail(1)) SWIG_fail;
8498 {
8499 PyThreadState* __tstate = wxPyBeginAllowThreads();
8500 (arg1)->Stop();
8501
8502 wxPyEndAllowThreads(__tstate);
8503 if (PyErr_Occurred()) SWIG_fail;
8504 }
8505 Py_INCREF(Py_None); resultobj = Py_None;
8506 return resultobj;
8507 fail:
8508 return NULL;
8509 }
8510
8511
8512 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8513 PyObject *resultobj;
8514 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8515 bool result;
8516 PyObject * obj0 = 0 ;
8517 char *kwnames[] = {
8518 (char *) "self", NULL
8519 };
8520
8521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8523 if (SWIG_arg_fail(1)) SWIG_fail;
8524 {
8525 PyThreadState* __tstate = wxPyBeginAllowThreads();
8526 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8527
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 {
8532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8533 }
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj;
8542 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8543 int result;
8544 PyObject * obj0 = 0 ;
8545 char *kwnames[] = {
8546 (char *) "self", NULL
8547 };
8548
8549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8551 if (SWIG_arg_fail(1)) SWIG_fail;
8552 {
8553 PyThreadState* __tstate = wxPyBeginAllowThreads();
8554 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8555
8556 wxPyEndAllowThreads(__tstate);
8557 if (PyErr_Occurred()) SWIG_fail;
8558 }
8559 {
8560 resultobj = SWIG_From_int((int)(result));
8561 }
8562 return resultobj;
8563 fail:
8564 return NULL;
8565 }
8566
8567
8568 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8569 PyObject *resultobj;
8570 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8571 bool result;
8572 PyObject * obj0 = 0 ;
8573 char *kwnames[] = {
8574 (char *) "self", NULL
8575 };
8576
8577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8579 if (SWIG_arg_fail(1)) SWIG_fail;
8580 {
8581 PyThreadState* __tstate = wxPyBeginAllowThreads();
8582 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8583
8584 wxPyEndAllowThreads(__tstate);
8585 if (PyErr_Occurred()) SWIG_fail;
8586 }
8587 {
8588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8589 }
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8597 PyObject *resultobj;
8598 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8599 int result;
8600 PyObject * obj0 = 0 ;
8601 char *kwnames[] = {
8602 (char *) "self", NULL
8603 };
8604
8605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8607 if (SWIG_arg_fail(1)) SWIG_fail;
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 result = (int)((wxPyTimer const *)arg1)->GetId();
8611
8612 wxPyEndAllowThreads(__tstate);
8613 if (PyErr_Occurred()) SWIG_fail;
8614 }
8615 {
8616 resultobj = SWIG_From_int((int)(result));
8617 }
8618 return resultobj;
8619 fail:
8620 return NULL;
8621 }
8622
8623
8624 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8625 PyObject *obj;
8626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8627 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8628 Py_INCREF(obj);
8629 return Py_BuildValue((char *)"");
8630 }
8631 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8632 PyObject *resultobj;
8633 int arg1 = (int) 0 ;
8634 int arg2 = (int) 0 ;
8635 wxTimerEvent *result;
8636 PyObject * obj0 = 0 ;
8637 PyObject * obj1 = 0 ;
8638 char *kwnames[] = {
8639 (char *) "timerid",(char *) "interval", NULL
8640 };
8641
8642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8643 if (obj0) {
8644 {
8645 arg1 = (int)(SWIG_As_int(obj0));
8646 if (SWIG_arg_fail(1)) SWIG_fail;
8647 }
8648 }
8649 if (obj1) {
8650 {
8651 arg2 = (int)(SWIG_As_int(obj1));
8652 if (SWIG_arg_fail(2)) SWIG_fail;
8653 }
8654 }
8655 {
8656 PyThreadState* __tstate = wxPyBeginAllowThreads();
8657 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8658
8659 wxPyEndAllowThreads(__tstate);
8660 if (PyErr_Occurred()) SWIG_fail;
8661 }
8662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8670 PyObject *resultobj;
8671 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8672 int result;
8673 PyObject * obj0 = 0 ;
8674 char *kwnames[] = {
8675 (char *) "self", NULL
8676 };
8677
8678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8680 if (SWIG_arg_fail(1)) SWIG_fail;
8681 {
8682 PyThreadState* __tstate = wxPyBeginAllowThreads();
8683 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8684
8685 wxPyEndAllowThreads(__tstate);
8686 if (PyErr_Occurred()) SWIG_fail;
8687 }
8688 {
8689 resultobj = SWIG_From_int((int)(result));
8690 }
8691 return resultobj;
8692 fail:
8693 return NULL;
8694 }
8695
8696
8697 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8698 PyObject *obj;
8699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8700 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8701 Py_INCREF(obj);
8702 return Py_BuildValue((char *)"");
8703 }
8704 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8705 PyObject *resultobj;
8706 wxTimer *arg1 = 0 ;
8707 wxTimerRunner *result;
8708 PyObject * obj0 = 0 ;
8709
8710 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8711 {
8712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8713 if (SWIG_arg_fail(1)) SWIG_fail;
8714 if (arg1 == NULL) {
8715 SWIG_null_ref("wxTimer");
8716 }
8717 if (SWIG_arg_fail(1)) SWIG_fail;
8718 }
8719 {
8720 if (!wxPyCheckForApp()) SWIG_fail;
8721 PyThreadState* __tstate = wxPyBeginAllowThreads();
8722 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8723
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8735 PyObject *resultobj;
8736 wxTimer *arg1 = 0 ;
8737 int arg2 ;
8738 bool arg3 = (bool) false ;
8739 wxTimerRunner *result;
8740 PyObject * obj0 = 0 ;
8741 PyObject * obj1 = 0 ;
8742 PyObject * obj2 = 0 ;
8743
8744 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8745 {
8746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8747 if (SWIG_arg_fail(1)) SWIG_fail;
8748 if (arg1 == NULL) {
8749 SWIG_null_ref("wxTimer");
8750 }
8751 if (SWIG_arg_fail(1)) SWIG_fail;
8752 }
8753 {
8754 arg2 = (int)(SWIG_As_int(obj1));
8755 if (SWIG_arg_fail(2)) SWIG_fail;
8756 }
8757 if (obj2) {
8758 {
8759 arg3 = (bool)(SWIG_As_bool(obj2));
8760 if (SWIG_arg_fail(3)) SWIG_fail;
8761 }
8762 }
8763 {
8764 if (!wxPyCheckForApp()) SWIG_fail;
8765 PyThreadState* __tstate = wxPyBeginAllowThreads();
8766 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8767
8768 wxPyEndAllowThreads(__tstate);
8769 if (PyErr_Occurred()) SWIG_fail;
8770 }
8771 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8772 return resultobj;
8773 fail:
8774 return NULL;
8775 }
8776
8777
8778 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8779 int argc;
8780 PyObject *argv[4];
8781 int ii;
8782
8783 argc = PyObject_Length(args);
8784 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8785 argv[ii] = PyTuple_GetItem(args,ii);
8786 }
8787 if (argc == 1) {
8788 int _v;
8789 {
8790 void *ptr = 0;
8791 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8792 _v = 0;
8793 PyErr_Clear();
8794 } else {
8795 _v = (ptr != 0);
8796 }
8797 }
8798 if (_v) {
8799 return _wrap_new_TimerRunner__SWIG_0(self,args);
8800 }
8801 }
8802 if ((argc >= 2) && (argc <= 3)) {
8803 int _v;
8804 {
8805 void *ptr = 0;
8806 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8807 _v = 0;
8808 PyErr_Clear();
8809 } else {
8810 _v = (ptr != 0);
8811 }
8812 }
8813 if (_v) {
8814 _v = SWIG_Check_int(argv[1]);
8815 if (_v) {
8816 if (argc <= 2) {
8817 return _wrap_new_TimerRunner__SWIG_1(self,args);
8818 }
8819 _v = SWIG_Check_bool(argv[2]);
8820 if (_v) {
8821 return _wrap_new_TimerRunner__SWIG_1(self,args);
8822 }
8823 }
8824 }
8825 }
8826
8827 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8828 return NULL;
8829 }
8830
8831
8832 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8833 PyObject *resultobj;
8834 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8835 PyObject * obj0 = 0 ;
8836 char *kwnames[] = {
8837 (char *) "self", NULL
8838 };
8839
8840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8842 if (SWIG_arg_fail(1)) SWIG_fail;
8843 {
8844 PyThreadState* __tstate = wxPyBeginAllowThreads();
8845 delete arg1;
8846
8847 wxPyEndAllowThreads(__tstate);
8848 if (PyErr_Occurred()) SWIG_fail;
8849 }
8850 Py_INCREF(Py_None); resultobj = Py_None;
8851 return resultobj;
8852 fail:
8853 return NULL;
8854 }
8855
8856
8857 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8858 PyObject *resultobj;
8859 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8860 int arg2 ;
8861 bool arg3 = (bool) false ;
8862 PyObject * obj0 = 0 ;
8863 PyObject * obj1 = 0 ;
8864 PyObject * obj2 = 0 ;
8865 char *kwnames[] = {
8866 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8867 };
8868
8869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8871 if (SWIG_arg_fail(1)) SWIG_fail;
8872 {
8873 arg2 = (int)(SWIG_As_int(obj1));
8874 if (SWIG_arg_fail(2)) SWIG_fail;
8875 }
8876 if (obj2) {
8877 {
8878 arg3 = (bool)(SWIG_As_bool(obj2));
8879 if (SWIG_arg_fail(3)) SWIG_fail;
8880 }
8881 }
8882 {
8883 PyThreadState* __tstate = wxPyBeginAllowThreads();
8884 (arg1)->Start(arg2,arg3);
8885
8886 wxPyEndAllowThreads(__tstate);
8887 if (PyErr_Occurred()) SWIG_fail;
8888 }
8889 Py_INCREF(Py_None); resultobj = Py_None;
8890 return resultobj;
8891 fail:
8892 return NULL;
8893 }
8894
8895
8896 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8897 PyObject *obj;
8898 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8899 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8900 Py_INCREF(obj);
8901 return Py_BuildValue((char *)"");
8902 }
8903 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8904 PyObject *resultobj;
8905 wxLog *result;
8906 char *kwnames[] = {
8907 NULL
8908 };
8909
8910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8911 {
8912 PyThreadState* __tstate = wxPyBeginAllowThreads();
8913 result = (wxLog *)new wxLog();
8914
8915 wxPyEndAllowThreads(__tstate);
8916 if (PyErr_Occurred()) SWIG_fail;
8917 }
8918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8919 return resultobj;
8920 fail:
8921 return NULL;
8922 }
8923
8924
8925 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8926 PyObject *resultobj;
8927 bool result;
8928 char *kwnames[] = {
8929 NULL
8930 };
8931
8932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8933 {
8934 PyThreadState* __tstate = wxPyBeginAllowThreads();
8935 result = (bool)wxLog::IsEnabled();
8936
8937 wxPyEndAllowThreads(__tstate);
8938 if (PyErr_Occurred()) SWIG_fail;
8939 }
8940 {
8941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8942 }
8943 return resultobj;
8944 fail:
8945 return NULL;
8946 }
8947
8948
8949 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8950 PyObject *resultobj;
8951 bool arg1 = (bool) true ;
8952 bool result;
8953 PyObject * obj0 = 0 ;
8954 char *kwnames[] = {
8955 (char *) "doIt", NULL
8956 };
8957
8958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8959 if (obj0) {
8960 {
8961 arg1 = (bool)(SWIG_As_bool(obj0));
8962 if (SWIG_arg_fail(1)) SWIG_fail;
8963 }
8964 }
8965 {
8966 PyThreadState* __tstate = wxPyBeginAllowThreads();
8967 result = (bool)wxLog::EnableLogging(arg1);
8968
8969 wxPyEndAllowThreads(__tstate);
8970 if (PyErr_Occurred()) SWIG_fail;
8971 }
8972 {
8973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8974 }
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8982 PyObject *resultobj;
8983 wxLogLevel arg1 ;
8984 wxChar *arg2 = (wxChar *) 0 ;
8985 time_t arg3 ;
8986 PyObject * obj0 = 0 ;
8987 PyObject * obj1 = 0 ;
8988 PyObject * obj2 = 0 ;
8989 char *kwnames[] = {
8990 (char *) "level",(char *) "szString",(char *) "t", NULL
8991 };
8992
8993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8994 {
8995 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8996 if (SWIG_arg_fail(1)) SWIG_fail;
8997 }
8998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8999 if (SWIG_arg_fail(2)) SWIG_fail;
9000 {
9001 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
9002 if (SWIG_arg_fail(3)) SWIG_fail;
9003 }
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9007
9008 wxPyEndAllowThreads(__tstate);
9009 if (PyErr_Occurred()) SWIG_fail;
9010 }
9011 Py_INCREF(Py_None); resultobj = Py_None;
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj;
9020 wxLog *arg1 = (wxLog *) 0 ;
9021 PyObject * obj0 = 0 ;
9022 char *kwnames[] = {
9023 (char *) "self", NULL
9024 };
9025
9026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9028 if (SWIG_arg_fail(1)) SWIG_fail;
9029 {
9030 PyThreadState* __tstate = wxPyBeginAllowThreads();
9031 (arg1)->Flush();
9032
9033 wxPyEndAllowThreads(__tstate);
9034 if (PyErr_Occurred()) SWIG_fail;
9035 }
9036 Py_INCREF(Py_None); resultobj = Py_None;
9037 return resultobj;
9038 fail:
9039 return NULL;
9040 }
9041
9042
9043 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj;
9045 char *kwnames[] = {
9046 NULL
9047 };
9048
9049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9050 {
9051 PyThreadState* __tstate = wxPyBeginAllowThreads();
9052 wxLog::FlushActive();
9053
9054 wxPyEndAllowThreads(__tstate);
9055 if (PyErr_Occurred()) SWIG_fail;
9056 }
9057 Py_INCREF(Py_None); resultobj = Py_None;
9058 return resultobj;
9059 fail:
9060 return NULL;
9061 }
9062
9063
9064 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9065 PyObject *resultobj;
9066 wxLog *result;
9067 char *kwnames[] = {
9068 NULL
9069 };
9070
9071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9072 {
9073 PyThreadState* __tstate = wxPyBeginAllowThreads();
9074 result = (wxLog *)wxLog::GetActiveTarget();
9075
9076 wxPyEndAllowThreads(__tstate);
9077 if (PyErr_Occurred()) SWIG_fail;
9078 }
9079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9080 return resultobj;
9081 fail:
9082 return NULL;
9083 }
9084
9085
9086 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj;
9088 wxLog *arg1 = (wxLog *) 0 ;
9089 wxLog *result;
9090 PyObject * obj0 = 0 ;
9091 char *kwnames[] = {
9092 (char *) "pLogger", NULL
9093 };
9094
9095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9097 if (SWIG_arg_fail(1)) SWIG_fail;
9098 {
9099 PyThreadState* __tstate = wxPyBeginAllowThreads();
9100 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9101
9102 wxPyEndAllowThreads(__tstate);
9103 if (PyErr_Occurred()) SWIG_fail;
9104 }
9105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9106 return resultobj;
9107 fail:
9108 return NULL;
9109 }
9110
9111
9112 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9113 PyObject *resultobj;
9114 char *kwnames[] = {
9115 NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9119 {
9120 PyThreadState* __tstate = wxPyBeginAllowThreads();
9121 wxLog::Suspend();
9122
9123 wxPyEndAllowThreads(__tstate);
9124 if (PyErr_Occurred()) SWIG_fail;
9125 }
9126 Py_INCREF(Py_None); resultobj = Py_None;
9127 return resultobj;
9128 fail:
9129 return NULL;
9130 }
9131
9132
9133 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9134 PyObject *resultobj;
9135 char *kwnames[] = {
9136 NULL
9137 };
9138
9139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9140 {
9141 PyThreadState* __tstate = wxPyBeginAllowThreads();
9142 wxLog::Resume();
9143
9144 wxPyEndAllowThreads(__tstate);
9145 if (PyErr_Occurred()) SWIG_fail;
9146 }
9147 Py_INCREF(Py_None); resultobj = Py_None;
9148 return resultobj;
9149 fail:
9150 return NULL;
9151 }
9152
9153
9154 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9155 PyObject *resultobj;
9156 bool arg1 = (bool) true ;
9157 PyObject * obj0 = 0 ;
9158 char *kwnames[] = {
9159 (char *) "bVerbose", NULL
9160 };
9161
9162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9163 if (obj0) {
9164 {
9165 arg1 = (bool)(SWIG_As_bool(obj0));
9166 if (SWIG_arg_fail(1)) SWIG_fail;
9167 }
9168 }
9169 {
9170 PyThreadState* __tstate = wxPyBeginAllowThreads();
9171 wxLog::SetVerbose(arg1);
9172
9173 wxPyEndAllowThreads(__tstate);
9174 if (PyErr_Occurred()) SWIG_fail;
9175 }
9176 Py_INCREF(Py_None); resultobj = Py_None;
9177 return resultobj;
9178 fail:
9179 return NULL;
9180 }
9181
9182
9183 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9184 PyObject *resultobj;
9185 wxLogLevel arg1 ;
9186 PyObject * obj0 = 0 ;
9187 char *kwnames[] = {
9188 (char *) "logLevel", NULL
9189 };
9190
9191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9192 {
9193 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9194 if (SWIG_arg_fail(1)) SWIG_fail;
9195 }
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 wxLog::SetLogLevel(arg1);
9199
9200 wxPyEndAllowThreads(__tstate);
9201 if (PyErr_Occurred()) SWIG_fail;
9202 }
9203 Py_INCREF(Py_None); resultobj = Py_None;
9204 return resultobj;
9205 fail:
9206 return NULL;
9207 }
9208
9209
9210 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9211 PyObject *resultobj;
9212 char *kwnames[] = {
9213 NULL
9214 };
9215
9216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9217 {
9218 PyThreadState* __tstate = wxPyBeginAllowThreads();
9219 wxLog::DontCreateOnDemand();
9220
9221 wxPyEndAllowThreads(__tstate);
9222 if (PyErr_Occurred()) SWIG_fail;
9223 }
9224 Py_INCREF(Py_None); resultobj = Py_None;
9225 return resultobj;
9226 fail:
9227 return NULL;
9228 }
9229
9230
9231 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9232 PyObject *resultobj;
9233 wxTraceMask arg1 ;
9234 PyObject * obj0 = 0 ;
9235 char *kwnames[] = {
9236 (char *) "ulMask", NULL
9237 };
9238
9239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9240 {
9241 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9242 if (SWIG_arg_fail(1)) SWIG_fail;
9243 }
9244 {
9245 PyThreadState* __tstate = wxPyBeginAllowThreads();
9246 wxLog::SetTraceMask(arg1);
9247
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 Py_INCREF(Py_None); resultobj = Py_None;
9252 return resultobj;
9253 fail:
9254 return NULL;
9255 }
9256
9257
9258 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9259 PyObject *resultobj;
9260 wxString *arg1 = 0 ;
9261 bool temp1 = false ;
9262 PyObject * obj0 = 0 ;
9263 char *kwnames[] = {
9264 (char *) "str", NULL
9265 };
9266
9267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9268 {
9269 arg1 = wxString_in_helper(obj0);
9270 if (arg1 == NULL) SWIG_fail;
9271 temp1 = true;
9272 }
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 wxLog::AddTraceMask((wxString const &)*arg1);
9276
9277 wxPyEndAllowThreads(__tstate);
9278 if (PyErr_Occurred()) SWIG_fail;
9279 }
9280 Py_INCREF(Py_None); resultobj = Py_None;
9281 {
9282 if (temp1)
9283 delete arg1;
9284 }
9285 return resultobj;
9286 fail:
9287 {
9288 if (temp1)
9289 delete arg1;
9290 }
9291 return NULL;
9292 }
9293
9294
9295 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9296 PyObject *resultobj;
9297 wxString *arg1 = 0 ;
9298 bool temp1 = false ;
9299 PyObject * obj0 = 0 ;
9300 char *kwnames[] = {
9301 (char *) "str", NULL
9302 };
9303
9304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9305 {
9306 arg1 = wxString_in_helper(obj0);
9307 if (arg1 == NULL) SWIG_fail;
9308 temp1 = true;
9309 }
9310 {
9311 PyThreadState* __tstate = wxPyBeginAllowThreads();
9312 wxLog::RemoveTraceMask((wxString const &)*arg1);
9313
9314 wxPyEndAllowThreads(__tstate);
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 Py_INCREF(Py_None); resultobj = Py_None;
9318 {
9319 if (temp1)
9320 delete arg1;
9321 }
9322 return resultobj;
9323 fail:
9324 {
9325 if (temp1)
9326 delete arg1;
9327 }
9328 return NULL;
9329 }
9330
9331
9332 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9333 PyObject *resultobj;
9334 char *kwnames[] = {
9335 NULL
9336 };
9337
9338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9339 {
9340 PyThreadState* __tstate = wxPyBeginAllowThreads();
9341 wxLog::ClearTraceMasks();
9342
9343 wxPyEndAllowThreads(__tstate);
9344 if (PyErr_Occurred()) SWIG_fail;
9345 }
9346 Py_INCREF(Py_None); resultobj = Py_None;
9347 return resultobj;
9348 fail:
9349 return NULL;
9350 }
9351
9352
9353 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9354 PyObject *resultobj;
9355 wxArrayString *result;
9356 char *kwnames[] = {
9357 NULL
9358 };
9359
9360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9361 {
9362 PyThreadState* __tstate = wxPyBeginAllowThreads();
9363 {
9364 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9365 result = (wxArrayString *) &_result_ref;
9366 }
9367
9368 wxPyEndAllowThreads(__tstate);
9369 if (PyErr_Occurred()) SWIG_fail;
9370 }
9371 {
9372 resultobj = wxArrayString2PyList_helper(*result);
9373 }
9374 return resultobj;
9375 fail:
9376 return NULL;
9377 }
9378
9379
9380 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9381 PyObject *resultobj;
9382 wxChar *arg1 = (wxChar *) 0 ;
9383 PyObject * obj0 = 0 ;
9384 char *kwnames[] = {
9385 (char *) "ts", NULL
9386 };
9387
9388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9390 if (SWIG_arg_fail(1)) SWIG_fail;
9391 {
9392 PyThreadState* __tstate = wxPyBeginAllowThreads();
9393 wxLog::SetTimestamp((wxChar const *)arg1);
9394
9395 wxPyEndAllowThreads(__tstate);
9396 if (PyErr_Occurred()) SWIG_fail;
9397 }
9398 Py_INCREF(Py_None); resultobj = Py_None;
9399 return resultobj;
9400 fail:
9401 return NULL;
9402 }
9403
9404
9405 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9406 PyObject *resultobj;
9407 bool result;
9408 char *kwnames[] = {
9409 NULL
9410 };
9411
9412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9413 {
9414 PyThreadState* __tstate = wxPyBeginAllowThreads();
9415 result = (bool)wxLog::GetVerbose();
9416
9417 wxPyEndAllowThreads(__tstate);
9418 if (PyErr_Occurred()) SWIG_fail;
9419 }
9420 {
9421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9422 }
9423 return resultobj;
9424 fail:
9425 return NULL;
9426 }
9427
9428
9429 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9430 PyObject *resultobj;
9431 wxTraceMask result;
9432 char *kwnames[] = {
9433 NULL
9434 };
9435
9436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9437 {
9438 PyThreadState* __tstate = wxPyBeginAllowThreads();
9439 result = (wxTraceMask)wxLog::GetTraceMask();
9440
9441 wxPyEndAllowThreads(__tstate);
9442 if (PyErr_Occurred()) SWIG_fail;
9443 }
9444 {
9445 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9446 }
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj;
9455 wxChar *arg1 = (wxChar *) 0 ;
9456 bool result;
9457 PyObject * obj0 = 0 ;
9458 char *kwnames[] = {
9459 (char *) "mask", NULL
9460 };
9461
9462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9464 if (SWIG_arg_fail(1)) SWIG_fail;
9465 {
9466 PyThreadState* __tstate = wxPyBeginAllowThreads();
9467 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9468
9469 wxPyEndAllowThreads(__tstate);
9470 if (PyErr_Occurred()) SWIG_fail;
9471 }
9472 {
9473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9474 }
9475 return resultobj;
9476 fail:
9477 return NULL;
9478 }
9479
9480
9481 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9482 PyObject *resultobj;
9483 wxLogLevel result;
9484 char *kwnames[] = {
9485 NULL
9486 };
9487
9488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 result = (wxLogLevel)wxLog::GetLogLevel();
9492
9493 wxPyEndAllowThreads(__tstate);
9494 if (PyErr_Occurred()) SWIG_fail;
9495 }
9496 {
9497 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9498 }
9499 return resultobj;
9500 fail:
9501 return NULL;
9502 }
9503
9504
9505 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9506 PyObject *resultobj;
9507 wxChar *result;
9508 char *kwnames[] = {
9509 NULL
9510 };
9511
9512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9513 {
9514 PyThreadState* __tstate = wxPyBeginAllowThreads();
9515 result = (wxChar *)wxLog::GetTimestamp();
9516
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9521 return resultobj;
9522 fail:
9523 return NULL;
9524 }
9525
9526
9527 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9528 PyObject *resultobj;
9529 wxString result;
9530 char *kwnames[] = {
9531 NULL
9532 };
9533
9534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9535 {
9536 PyThreadState* __tstate = wxPyBeginAllowThreads();
9537 result = Log_TimeStamp();
9538
9539 wxPyEndAllowThreads(__tstate);
9540 if (PyErr_Occurred()) SWIG_fail;
9541 }
9542 {
9543 #if wxUSE_UNICODE
9544 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9545 #else
9546 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9547 #endif
9548 }
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9556 PyObject *resultobj;
9557 wxLog *arg1 = (wxLog *) 0 ;
9558 PyObject * obj0 = 0 ;
9559 char *kwnames[] = {
9560 (char *) "self", NULL
9561 };
9562
9563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9565 if (SWIG_arg_fail(1)) SWIG_fail;
9566 {
9567 PyThreadState* __tstate = wxPyBeginAllowThreads();
9568 wxLog_Destroy(arg1);
9569
9570 wxPyEndAllowThreads(__tstate);
9571 if (PyErr_Occurred()) SWIG_fail;
9572 }
9573 Py_INCREF(Py_None); resultobj = Py_None;
9574 return resultobj;
9575 fail:
9576 return NULL;
9577 }
9578
9579
9580 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9581 PyObject *obj;
9582 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9583 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9584 Py_INCREF(obj);
9585 return Py_BuildValue((char *)"");
9586 }
9587 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj;
9589 wxLogStderr *result;
9590 char *kwnames[] = {
9591 NULL
9592 };
9593
9594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 result = (wxLogStderr *)new wxLogStderr();
9598
9599 wxPyEndAllowThreads(__tstate);
9600 if (PyErr_Occurred()) SWIG_fail;
9601 }
9602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9603 return resultobj;
9604 fail:
9605 return NULL;
9606 }
9607
9608
9609 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9610 PyObject *obj;
9611 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9612 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9613 Py_INCREF(obj);
9614 return Py_BuildValue((char *)"");
9615 }
9616 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9617 PyObject *resultobj;
9618 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9619 wxLogTextCtrl *result;
9620 PyObject * obj0 = 0 ;
9621 char *kwnames[] = {
9622 (char *) "pTextCtrl", NULL
9623 };
9624
9625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9627 if (SWIG_arg_fail(1)) SWIG_fail;
9628 {
9629 PyThreadState* __tstate = wxPyBeginAllowThreads();
9630 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9631
9632 wxPyEndAllowThreads(__tstate);
9633 if (PyErr_Occurred()) SWIG_fail;
9634 }
9635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9636 return resultobj;
9637 fail:
9638 return NULL;
9639 }
9640
9641
9642 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9643 PyObject *obj;
9644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9645 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9646 Py_INCREF(obj);
9647 return Py_BuildValue((char *)"");
9648 }
9649 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9650 PyObject *resultobj;
9651 wxLogGui *result;
9652 char *kwnames[] = {
9653 NULL
9654 };
9655
9656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9657 {
9658 PyThreadState* __tstate = wxPyBeginAllowThreads();
9659 result = (wxLogGui *)new wxLogGui();
9660
9661 wxPyEndAllowThreads(__tstate);
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9665 return resultobj;
9666 fail:
9667 return NULL;
9668 }
9669
9670
9671 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9672 PyObject *obj;
9673 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9674 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9675 Py_INCREF(obj);
9676 return Py_BuildValue((char *)"");
9677 }
9678 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9679 PyObject *resultobj;
9680 wxFrame *arg1 = (wxFrame *) 0 ;
9681 wxString *arg2 = 0 ;
9682 bool arg3 = (bool) true ;
9683 bool arg4 = (bool) true ;
9684 wxLogWindow *result;
9685 bool temp2 = false ;
9686 PyObject * obj0 = 0 ;
9687 PyObject * obj1 = 0 ;
9688 PyObject * obj2 = 0 ;
9689 PyObject * obj3 = 0 ;
9690 char *kwnames[] = {
9691 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9692 };
9693
9694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9696 if (SWIG_arg_fail(1)) SWIG_fail;
9697 {
9698 arg2 = wxString_in_helper(obj1);
9699 if (arg2 == NULL) SWIG_fail;
9700 temp2 = true;
9701 }
9702 if (obj2) {
9703 {
9704 arg3 = (bool)(SWIG_As_bool(obj2));
9705 if (SWIG_arg_fail(3)) SWIG_fail;
9706 }
9707 }
9708 if (obj3) {
9709 {
9710 arg4 = (bool)(SWIG_As_bool(obj3));
9711 if (SWIG_arg_fail(4)) SWIG_fail;
9712 }
9713 }
9714 {
9715 PyThreadState* __tstate = wxPyBeginAllowThreads();
9716 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9717
9718 wxPyEndAllowThreads(__tstate);
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9722 {
9723 if (temp2)
9724 delete arg2;
9725 }
9726 return resultobj;
9727 fail:
9728 {
9729 if (temp2)
9730 delete arg2;
9731 }
9732 return NULL;
9733 }
9734
9735
9736 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9737 PyObject *resultobj;
9738 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9739 bool arg2 = (bool) true ;
9740 PyObject * obj0 = 0 ;
9741 PyObject * obj1 = 0 ;
9742 char *kwnames[] = {
9743 (char *) "self",(char *) "bShow", NULL
9744 };
9745
9746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9748 if (SWIG_arg_fail(1)) SWIG_fail;
9749 if (obj1) {
9750 {
9751 arg2 = (bool)(SWIG_As_bool(obj1));
9752 if (SWIG_arg_fail(2)) SWIG_fail;
9753 }
9754 }
9755 {
9756 PyThreadState* __tstate = wxPyBeginAllowThreads();
9757 (arg1)->Show(arg2);
9758
9759 wxPyEndAllowThreads(__tstate);
9760 if (PyErr_Occurred()) SWIG_fail;
9761 }
9762 Py_INCREF(Py_None); resultobj = Py_None;
9763 return resultobj;
9764 fail:
9765 return NULL;
9766 }
9767
9768
9769 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9770 PyObject *resultobj;
9771 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9772 wxFrame *result;
9773 PyObject * obj0 = 0 ;
9774 char *kwnames[] = {
9775 (char *) "self", NULL
9776 };
9777
9778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9780 if (SWIG_arg_fail(1)) SWIG_fail;
9781 {
9782 PyThreadState* __tstate = wxPyBeginAllowThreads();
9783 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9784
9785 wxPyEndAllowThreads(__tstate);
9786 if (PyErr_Occurred()) SWIG_fail;
9787 }
9788 {
9789 resultobj = wxPyMake_wxObject(result, 0);
9790 }
9791 return resultobj;
9792 fail:
9793 return NULL;
9794 }
9795
9796
9797 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9798 PyObject *resultobj;
9799 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9800 wxLog *result;
9801 PyObject * obj0 = 0 ;
9802 char *kwnames[] = {
9803 (char *) "self", NULL
9804 };
9805
9806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9808 if (SWIG_arg_fail(1)) SWIG_fail;
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9812
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9817 return resultobj;
9818 fail:
9819 return NULL;
9820 }
9821
9822
9823 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9824 PyObject *resultobj;
9825 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9826 bool result;
9827 PyObject * obj0 = 0 ;
9828 char *kwnames[] = {
9829 (char *) "self", NULL
9830 };
9831
9832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9834 if (SWIG_arg_fail(1)) SWIG_fail;
9835 {
9836 PyThreadState* __tstate = wxPyBeginAllowThreads();
9837 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9838
9839 wxPyEndAllowThreads(__tstate);
9840 if (PyErr_Occurred()) SWIG_fail;
9841 }
9842 {
9843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9844 }
9845 return resultobj;
9846 fail:
9847 return NULL;
9848 }
9849
9850
9851 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9852 PyObject *resultobj;
9853 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9854 bool arg2 ;
9855 PyObject * obj0 = 0 ;
9856 PyObject * obj1 = 0 ;
9857 char *kwnames[] = {
9858 (char *) "self",(char *) "bDoPass", NULL
9859 };
9860
9861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9863 if (SWIG_arg_fail(1)) SWIG_fail;
9864 {
9865 arg2 = (bool)(SWIG_As_bool(obj1));
9866 if (SWIG_arg_fail(2)) SWIG_fail;
9867 }
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 (arg1)->PassMessages(arg2);
9871
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 Py_INCREF(Py_None); resultobj = Py_None;
9876 return resultobj;
9877 fail:
9878 return NULL;
9879 }
9880
9881
9882 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9883 PyObject *obj;
9884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9885 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9886 Py_INCREF(obj);
9887 return Py_BuildValue((char *)"");
9888 }
9889 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9890 PyObject *resultobj;
9891 wxLog *arg1 = (wxLog *) 0 ;
9892 wxLogChain *result;
9893 PyObject * obj0 = 0 ;
9894 char *kwnames[] = {
9895 (char *) "logger", NULL
9896 };
9897
9898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9900 if (SWIG_arg_fail(1)) SWIG_fail;
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 result = (wxLogChain *)new wxLogChain(arg1);
9904
9905 wxPyEndAllowThreads(__tstate);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj;
9917 wxLogChain *arg1 = (wxLogChain *) 0 ;
9918 wxLog *arg2 = (wxLog *) 0 ;
9919 PyObject * obj0 = 0 ;
9920 PyObject * obj1 = 0 ;
9921 char *kwnames[] = {
9922 (char *) "self",(char *) "logger", NULL
9923 };
9924
9925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9927 if (SWIG_arg_fail(1)) SWIG_fail;
9928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9929 if (SWIG_arg_fail(2)) SWIG_fail;
9930 {
9931 PyThreadState* __tstate = wxPyBeginAllowThreads();
9932 (arg1)->SetLog(arg2);
9933
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 Py_INCREF(Py_None); resultobj = Py_None;
9938 return resultobj;
9939 fail:
9940 return NULL;
9941 }
9942
9943
9944 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9945 PyObject *resultobj;
9946 wxLogChain *arg1 = (wxLogChain *) 0 ;
9947 bool arg2 ;
9948 PyObject * obj0 = 0 ;
9949 PyObject * obj1 = 0 ;
9950 char *kwnames[] = {
9951 (char *) "self",(char *) "bDoPass", NULL
9952 };
9953
9954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9956 if (SWIG_arg_fail(1)) SWIG_fail;
9957 {
9958 arg2 = (bool)(SWIG_As_bool(obj1));
9959 if (SWIG_arg_fail(2)) SWIG_fail;
9960 }
9961 {
9962 PyThreadState* __tstate = wxPyBeginAllowThreads();
9963 (arg1)->PassMessages(arg2);
9964
9965 wxPyEndAllowThreads(__tstate);
9966 if (PyErr_Occurred()) SWIG_fail;
9967 }
9968 Py_INCREF(Py_None); resultobj = Py_None;
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9976 PyObject *resultobj;
9977 wxLogChain *arg1 = (wxLogChain *) 0 ;
9978 bool result;
9979 PyObject * obj0 = 0 ;
9980 char *kwnames[] = {
9981 (char *) "self", NULL
9982 };
9983
9984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9986 if (SWIG_arg_fail(1)) SWIG_fail;
9987 {
9988 PyThreadState* __tstate = wxPyBeginAllowThreads();
9989 result = (bool)(arg1)->IsPassingMessages();
9990
9991 wxPyEndAllowThreads(__tstate);
9992 if (PyErr_Occurred()) SWIG_fail;
9993 }
9994 {
9995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9996 }
9997 return resultobj;
9998 fail:
9999 return NULL;
10000 }
10001
10002
10003 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10004 PyObject *resultobj;
10005 wxLogChain *arg1 = (wxLogChain *) 0 ;
10006 wxLog *result;
10007 PyObject * obj0 = 0 ;
10008 char *kwnames[] = {
10009 (char *) "self", NULL
10010 };
10011
10012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10014 if (SWIG_arg_fail(1)) SWIG_fail;
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 result = (wxLog *)(arg1)->GetOldLog();
10018
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10023 return resultobj;
10024 fail:
10025 return NULL;
10026 }
10027
10028
10029 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10030 PyObject *obj;
10031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10032 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10033 Py_INCREF(obj);
10034 return Py_BuildValue((char *)"");
10035 }
10036 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10037 PyObject *resultobj;
10038 unsigned long result;
10039 char *kwnames[] = {
10040 NULL
10041 };
10042
10043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10044 {
10045 PyThreadState* __tstate = wxPyBeginAllowThreads();
10046 result = (unsigned long)wxSysErrorCode();
10047
10048 wxPyEndAllowThreads(__tstate);
10049 if (PyErr_Occurred()) SWIG_fail;
10050 }
10051 {
10052 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10053 }
10054 return resultobj;
10055 fail:
10056 return NULL;
10057 }
10058
10059
10060 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10061 PyObject *resultobj;
10062 unsigned long arg1 = (unsigned long) 0 ;
10063 wxString result;
10064 PyObject * obj0 = 0 ;
10065 char *kwnames[] = {
10066 (char *) "nErrCode", NULL
10067 };
10068
10069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10070 if (obj0) {
10071 {
10072 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10073 if (SWIG_arg_fail(1)) SWIG_fail;
10074 }
10075 }
10076 {
10077 PyThreadState* __tstate = wxPyBeginAllowThreads();
10078 result = wxSysErrorMsg(arg1);
10079
10080 wxPyEndAllowThreads(__tstate);
10081 if (PyErr_Occurred()) SWIG_fail;
10082 }
10083 {
10084 #if wxUSE_UNICODE
10085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10086 #else
10087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10088 #endif
10089 }
10090 return resultobj;
10091 fail:
10092 return NULL;
10093 }
10094
10095
10096 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj;
10098 wxString *arg1 = 0 ;
10099 bool temp1 = false ;
10100 PyObject * obj0 = 0 ;
10101 char *kwnames[] = {
10102 (char *) "msg", NULL
10103 };
10104
10105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10106 {
10107 arg1 = wxString_in_helper(obj0);
10108 if (arg1 == NULL) SWIG_fail;
10109 temp1 = true;
10110 }
10111 {
10112 PyThreadState* __tstate = wxPyBeginAllowThreads();
10113 wxPyLogFatalError((wxString const &)*arg1);
10114
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 Py_INCREF(Py_None); resultobj = Py_None;
10119 {
10120 if (temp1)
10121 delete arg1;
10122 }
10123 return resultobj;
10124 fail:
10125 {
10126 if (temp1)
10127 delete arg1;
10128 }
10129 return NULL;
10130 }
10131
10132
10133 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10134 PyObject *resultobj;
10135 wxString *arg1 = 0 ;
10136 bool temp1 = false ;
10137 PyObject * obj0 = 0 ;
10138 char *kwnames[] = {
10139 (char *) "msg", NULL
10140 };
10141
10142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10143 {
10144 arg1 = wxString_in_helper(obj0);
10145 if (arg1 == NULL) SWIG_fail;
10146 temp1 = true;
10147 }
10148 {
10149 PyThreadState* __tstate = wxPyBeginAllowThreads();
10150 wxPyLogError((wxString const &)*arg1);
10151
10152 wxPyEndAllowThreads(__tstate);
10153 if (PyErr_Occurred()) SWIG_fail;
10154 }
10155 Py_INCREF(Py_None); resultobj = Py_None;
10156 {
10157 if (temp1)
10158 delete arg1;
10159 }
10160 return resultobj;
10161 fail:
10162 {
10163 if (temp1)
10164 delete arg1;
10165 }
10166 return NULL;
10167 }
10168
10169
10170 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10171 PyObject *resultobj;
10172 wxString *arg1 = 0 ;
10173 bool temp1 = false ;
10174 PyObject * obj0 = 0 ;
10175 char *kwnames[] = {
10176 (char *) "msg", NULL
10177 };
10178
10179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10180 {
10181 arg1 = wxString_in_helper(obj0);
10182 if (arg1 == NULL) SWIG_fail;
10183 temp1 = true;
10184 }
10185 {
10186 PyThreadState* __tstate = wxPyBeginAllowThreads();
10187 wxPyLogWarning((wxString const &)*arg1);
10188
10189 wxPyEndAllowThreads(__tstate);
10190 if (PyErr_Occurred()) SWIG_fail;
10191 }
10192 Py_INCREF(Py_None); resultobj = Py_None;
10193 {
10194 if (temp1)
10195 delete arg1;
10196 }
10197 return resultobj;
10198 fail:
10199 {
10200 if (temp1)
10201 delete arg1;
10202 }
10203 return NULL;
10204 }
10205
10206
10207 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10208 PyObject *resultobj;
10209 wxString *arg1 = 0 ;
10210 bool temp1 = false ;
10211 PyObject * obj0 = 0 ;
10212 char *kwnames[] = {
10213 (char *) "msg", NULL
10214 };
10215
10216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10217 {
10218 arg1 = wxString_in_helper(obj0);
10219 if (arg1 == NULL) SWIG_fail;
10220 temp1 = true;
10221 }
10222 {
10223 PyThreadState* __tstate = wxPyBeginAllowThreads();
10224 wxPyLogMessage((wxString const &)*arg1);
10225
10226 wxPyEndAllowThreads(__tstate);
10227 if (PyErr_Occurred()) SWIG_fail;
10228 }
10229 Py_INCREF(Py_None); resultobj = Py_None;
10230 {
10231 if (temp1)
10232 delete arg1;
10233 }
10234 return resultobj;
10235 fail:
10236 {
10237 if (temp1)
10238 delete arg1;
10239 }
10240 return NULL;
10241 }
10242
10243
10244 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10245 PyObject *resultobj;
10246 wxString *arg1 = 0 ;
10247 bool temp1 = false ;
10248 PyObject * obj0 = 0 ;
10249 char *kwnames[] = {
10250 (char *) "msg", NULL
10251 };
10252
10253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10254 {
10255 arg1 = wxString_in_helper(obj0);
10256 if (arg1 == NULL) SWIG_fail;
10257 temp1 = true;
10258 }
10259 {
10260 PyThreadState* __tstate = wxPyBeginAllowThreads();
10261 wxPyLogInfo((wxString const &)*arg1);
10262
10263 wxPyEndAllowThreads(__tstate);
10264 if (PyErr_Occurred()) SWIG_fail;
10265 }
10266 Py_INCREF(Py_None); resultobj = Py_None;
10267 {
10268 if (temp1)
10269 delete arg1;
10270 }
10271 return resultobj;
10272 fail:
10273 {
10274 if (temp1)
10275 delete arg1;
10276 }
10277 return NULL;
10278 }
10279
10280
10281 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10282 PyObject *resultobj;
10283 wxString *arg1 = 0 ;
10284 bool temp1 = false ;
10285 PyObject * obj0 = 0 ;
10286 char *kwnames[] = {
10287 (char *) "msg", NULL
10288 };
10289
10290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10291 {
10292 arg1 = wxString_in_helper(obj0);
10293 if (arg1 == NULL) SWIG_fail;
10294 temp1 = true;
10295 }
10296 {
10297 PyThreadState* __tstate = wxPyBeginAllowThreads();
10298 wxPyLogDebug((wxString const &)*arg1);
10299
10300 wxPyEndAllowThreads(__tstate);
10301 if (PyErr_Occurred()) SWIG_fail;
10302 }
10303 Py_INCREF(Py_None); resultobj = Py_None;
10304 {
10305 if (temp1)
10306 delete arg1;
10307 }
10308 return resultobj;
10309 fail:
10310 {
10311 if (temp1)
10312 delete arg1;
10313 }
10314 return NULL;
10315 }
10316
10317
10318 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10319 PyObject *resultobj;
10320 wxString *arg1 = 0 ;
10321 bool temp1 = false ;
10322 PyObject * obj0 = 0 ;
10323 char *kwnames[] = {
10324 (char *) "msg", NULL
10325 };
10326
10327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10328 {
10329 arg1 = wxString_in_helper(obj0);
10330 if (arg1 == NULL) SWIG_fail;
10331 temp1 = true;
10332 }
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 wxPyLogVerbose((wxString const &)*arg1);
10336
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 Py_INCREF(Py_None); resultobj = Py_None;
10341 {
10342 if (temp1)
10343 delete arg1;
10344 }
10345 return resultobj;
10346 fail:
10347 {
10348 if (temp1)
10349 delete arg1;
10350 }
10351 return NULL;
10352 }
10353
10354
10355 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10356 PyObject *resultobj;
10357 wxString *arg1 = 0 ;
10358 bool temp1 = false ;
10359 PyObject * obj0 = 0 ;
10360 char *kwnames[] = {
10361 (char *) "msg", NULL
10362 };
10363
10364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10365 {
10366 arg1 = wxString_in_helper(obj0);
10367 if (arg1 == NULL) SWIG_fail;
10368 temp1 = true;
10369 }
10370 {
10371 PyThreadState* __tstate = wxPyBeginAllowThreads();
10372 wxPyLogStatus((wxString const &)*arg1);
10373
10374 wxPyEndAllowThreads(__tstate);
10375 if (PyErr_Occurred()) SWIG_fail;
10376 }
10377 Py_INCREF(Py_None); resultobj = Py_None;
10378 {
10379 if (temp1)
10380 delete arg1;
10381 }
10382 return resultobj;
10383 fail:
10384 {
10385 if (temp1)
10386 delete arg1;
10387 }
10388 return NULL;
10389 }
10390
10391
10392 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10393 PyObject *resultobj;
10394 wxFrame *arg1 = (wxFrame *) 0 ;
10395 wxString *arg2 = 0 ;
10396 bool temp2 = false ;
10397 PyObject * obj0 = 0 ;
10398 PyObject * obj1 = 0 ;
10399 char *kwnames[] = {
10400 (char *) "pFrame",(char *) "msg", NULL
10401 };
10402
10403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10405 if (SWIG_arg_fail(1)) SWIG_fail;
10406 {
10407 arg2 = wxString_in_helper(obj1);
10408 if (arg2 == NULL) SWIG_fail;
10409 temp2 = true;
10410 }
10411 {
10412 PyThreadState* __tstate = wxPyBeginAllowThreads();
10413 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10414
10415 wxPyEndAllowThreads(__tstate);
10416 if (PyErr_Occurred()) SWIG_fail;
10417 }
10418 Py_INCREF(Py_None); resultobj = Py_None;
10419 {
10420 if (temp2)
10421 delete arg2;
10422 }
10423 return resultobj;
10424 fail:
10425 {
10426 if (temp2)
10427 delete arg2;
10428 }
10429 return NULL;
10430 }
10431
10432
10433 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10434 PyObject *resultobj;
10435 wxString *arg1 = 0 ;
10436 bool temp1 = false ;
10437 PyObject * obj0 = 0 ;
10438 char *kwnames[] = {
10439 (char *) "msg", NULL
10440 };
10441
10442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10443 {
10444 arg1 = wxString_in_helper(obj0);
10445 if (arg1 == NULL) SWIG_fail;
10446 temp1 = true;
10447 }
10448 {
10449 PyThreadState* __tstate = wxPyBeginAllowThreads();
10450 wxPyLogSysError((wxString const &)*arg1);
10451
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 Py_INCREF(Py_None); resultobj = Py_None;
10456 {
10457 if (temp1)
10458 delete arg1;
10459 }
10460 return resultobj;
10461 fail:
10462 {
10463 if (temp1)
10464 delete arg1;
10465 }
10466 return NULL;
10467 }
10468
10469
10470 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10471 PyObject *resultobj;
10472 unsigned long arg1 ;
10473 wxString *arg2 = 0 ;
10474 bool temp2 = false ;
10475 PyObject * obj0 = 0 ;
10476 PyObject * obj1 = 0 ;
10477 char *kwnames[] = {
10478 (char *) "level",(char *) "msg", NULL
10479 };
10480
10481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10482 {
10483 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10484 if (SWIG_arg_fail(1)) SWIG_fail;
10485 }
10486 {
10487 arg2 = wxString_in_helper(obj1);
10488 if (arg2 == NULL) SWIG_fail;
10489 temp2 = true;
10490 }
10491 {
10492 PyThreadState* __tstate = wxPyBeginAllowThreads();
10493 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10494
10495 wxPyEndAllowThreads(__tstate);
10496 if (PyErr_Occurred()) SWIG_fail;
10497 }
10498 Py_INCREF(Py_None); resultobj = Py_None;
10499 {
10500 if (temp2)
10501 delete arg2;
10502 }
10503 return resultobj;
10504 fail:
10505 {
10506 if (temp2)
10507 delete arg2;
10508 }
10509 return NULL;
10510 }
10511
10512
10513 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10514 PyObject *resultobj;
10515 unsigned long arg1 ;
10516 wxString *arg2 = 0 ;
10517 bool temp2 = false ;
10518 PyObject * obj0 = 0 ;
10519 PyObject * obj1 = 0 ;
10520
10521 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10522 {
10523 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10524 if (SWIG_arg_fail(1)) SWIG_fail;
10525 }
10526 {
10527 arg2 = wxString_in_helper(obj1);
10528 if (arg2 == NULL) SWIG_fail;
10529 temp2 = true;
10530 }
10531 {
10532 PyThreadState* __tstate = wxPyBeginAllowThreads();
10533 wxPyLogTrace(arg1,(wxString const &)*arg2);
10534
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 Py_INCREF(Py_None); resultobj = Py_None;
10539 {
10540 if (temp2)
10541 delete arg2;
10542 }
10543 return resultobj;
10544 fail:
10545 {
10546 if (temp2)
10547 delete arg2;
10548 }
10549 return NULL;
10550 }
10551
10552
10553 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10554 PyObject *resultobj;
10555 wxString *arg1 = 0 ;
10556 wxString *arg2 = 0 ;
10557 bool temp1 = false ;
10558 bool temp2 = false ;
10559 PyObject * obj0 = 0 ;
10560 PyObject * obj1 = 0 ;
10561
10562 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10563 {
10564 arg1 = wxString_in_helper(obj0);
10565 if (arg1 == NULL) SWIG_fail;
10566 temp1 = true;
10567 }
10568 {
10569 arg2 = wxString_in_helper(obj1);
10570 if (arg2 == NULL) SWIG_fail;
10571 temp2 = true;
10572 }
10573 {
10574 PyThreadState* __tstate = wxPyBeginAllowThreads();
10575 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10576
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 Py_INCREF(Py_None); resultobj = Py_None;
10581 {
10582 if (temp1)
10583 delete arg1;
10584 }
10585 {
10586 if (temp2)
10587 delete arg2;
10588 }
10589 return resultobj;
10590 fail:
10591 {
10592 if (temp1)
10593 delete arg1;
10594 }
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return NULL;
10600 }
10601
10602
10603 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10604 int argc;
10605 PyObject *argv[3];
10606 int ii;
10607
10608 argc = PyObject_Length(args);
10609 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10610 argv[ii] = PyTuple_GetItem(args,ii);
10611 }
10612 if (argc == 2) {
10613 int _v;
10614 {
10615 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10616 }
10617 if (_v) {
10618 {
10619 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10620 }
10621 if (_v) {
10622 return _wrap_LogTrace__SWIG_1(self,args);
10623 }
10624 }
10625 }
10626 if (argc == 2) {
10627 int _v;
10628 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10629 if (_v) {
10630 {
10631 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10632 }
10633 if (_v) {
10634 return _wrap_LogTrace__SWIG_0(self,args);
10635 }
10636 }
10637 }
10638
10639 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10640 return NULL;
10641 }
10642
10643
10644 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10645 PyObject *resultobj;
10646 wxString *arg1 = 0 ;
10647 wxString *arg2 = 0 ;
10648 bool temp1 = false ;
10649 bool temp2 = false ;
10650 PyObject * obj0 = 0 ;
10651 PyObject * obj1 = 0 ;
10652 char *kwnames[] = {
10653 (char *) "title",(char *) "text", NULL
10654 };
10655
10656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10657 {
10658 arg1 = wxString_in_helper(obj0);
10659 if (arg1 == NULL) SWIG_fail;
10660 temp1 = true;
10661 }
10662 {
10663 arg2 = wxString_in_helper(obj1);
10664 if (arg2 == NULL) SWIG_fail;
10665 temp2 = true;
10666 }
10667 {
10668 PyThreadState* __tstate = wxPyBeginAllowThreads();
10669 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10670
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 Py_INCREF(Py_None); resultobj = Py_None;
10675 {
10676 if (temp1)
10677 delete arg1;
10678 }
10679 {
10680 if (temp2)
10681 delete arg2;
10682 }
10683 return resultobj;
10684 fail:
10685 {
10686 if (temp1)
10687 delete arg1;
10688 }
10689 {
10690 if (temp2)
10691 delete arg2;
10692 }
10693 return NULL;
10694 }
10695
10696
10697 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10698 PyObject *resultobj;
10699 wxLogNull *result;
10700 char *kwnames[] = {
10701 NULL
10702 };
10703
10704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10705 {
10706 PyThreadState* __tstate = wxPyBeginAllowThreads();
10707 result = (wxLogNull *)new wxLogNull();
10708
10709 wxPyEndAllowThreads(__tstate);
10710 if (PyErr_Occurred()) SWIG_fail;
10711 }
10712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10713 return resultobj;
10714 fail:
10715 return NULL;
10716 }
10717
10718
10719 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10720 PyObject *resultobj;
10721 wxLogNull *arg1 = (wxLogNull *) 0 ;
10722 PyObject * obj0 = 0 ;
10723 char *kwnames[] = {
10724 (char *) "self", NULL
10725 };
10726
10727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10729 if (SWIG_arg_fail(1)) SWIG_fail;
10730 {
10731 PyThreadState* __tstate = wxPyBeginAllowThreads();
10732 delete arg1;
10733
10734 wxPyEndAllowThreads(__tstate);
10735 if (PyErr_Occurred()) SWIG_fail;
10736 }
10737 Py_INCREF(Py_None); resultobj = Py_None;
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10745 PyObject *obj;
10746 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10747 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10748 Py_INCREF(obj);
10749 return Py_BuildValue((char *)"");
10750 }
10751 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10752 PyObject *resultobj;
10753 wxPyLog *result;
10754 char *kwnames[] = {
10755 NULL
10756 };
10757
10758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10759 {
10760 PyThreadState* __tstate = wxPyBeginAllowThreads();
10761 result = (wxPyLog *)new wxPyLog();
10762
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj;
10775 wxPyLog *arg1 = (wxPyLog *) 0 ;
10776 PyObject *arg2 = (PyObject *) 0 ;
10777 PyObject *arg3 = (PyObject *) 0 ;
10778 PyObject * obj0 = 0 ;
10779 PyObject * obj1 = 0 ;
10780 PyObject * obj2 = 0 ;
10781 char *kwnames[] = {
10782 (char *) "self",(char *) "self",(char *) "_class", NULL
10783 };
10784
10785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10787 if (SWIG_arg_fail(1)) SWIG_fail;
10788 arg2 = obj1;
10789 arg3 = obj2;
10790 {
10791 PyThreadState* __tstate = wxPyBeginAllowThreads();
10792 (arg1)->_setCallbackInfo(arg2,arg3);
10793
10794 wxPyEndAllowThreads(__tstate);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 Py_INCREF(Py_None); resultobj = Py_None;
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10805 PyObject *obj;
10806 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10807 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10808 Py_INCREF(obj);
10809 return Py_BuildValue((char *)"");
10810 }
10811 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10812 PyObject *resultobj;
10813 int arg1 ;
10814 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10815 int arg3 = (int) wxKILL_NOCHILDREN ;
10816 wxKillError result;
10817 PyObject * obj0 = 0 ;
10818 PyObject * obj1 = 0 ;
10819 PyObject * obj2 = 0 ;
10820 char *kwnames[] = {
10821 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10822 };
10823
10824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10825 {
10826 arg1 = (int)(SWIG_As_int(obj0));
10827 if (SWIG_arg_fail(1)) SWIG_fail;
10828 }
10829 if (obj1) {
10830 {
10831 arg2 = (wxSignal)(SWIG_As_int(obj1));
10832 if (SWIG_arg_fail(2)) SWIG_fail;
10833 }
10834 }
10835 if (obj2) {
10836 {
10837 arg3 = (int)(SWIG_As_int(obj2));
10838 if (SWIG_arg_fail(3)) SWIG_fail;
10839 }
10840 }
10841 {
10842 PyThreadState* __tstate = wxPyBeginAllowThreads();
10843 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10844
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 resultobj = SWIG_From_int((result));
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10856 PyObject *resultobj;
10857 int arg1 ;
10858 bool result;
10859 PyObject * obj0 = 0 ;
10860 char *kwnames[] = {
10861 (char *) "pid", NULL
10862 };
10863
10864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10865 {
10866 arg1 = (int)(SWIG_As_int(obj0));
10867 if (SWIG_arg_fail(1)) SWIG_fail;
10868 }
10869 {
10870 PyThreadState* __tstate = wxPyBeginAllowThreads();
10871 result = (bool)wxPyProcess::Exists(arg1);
10872
10873 wxPyEndAllowThreads(__tstate);
10874 if (PyErr_Occurred()) SWIG_fail;
10875 }
10876 {
10877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10878 }
10879 return resultobj;
10880 fail:
10881 return NULL;
10882 }
10883
10884
10885 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10886 PyObject *resultobj;
10887 wxString *arg1 = 0 ;
10888 int arg2 = (int) wxEXEC_ASYNC ;
10889 wxPyProcess *result;
10890 bool temp1 = false ;
10891 PyObject * obj0 = 0 ;
10892 PyObject * obj1 = 0 ;
10893 char *kwnames[] = {
10894 (char *) "cmd",(char *) "flags", NULL
10895 };
10896
10897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10898 {
10899 arg1 = wxString_in_helper(obj0);
10900 if (arg1 == NULL) SWIG_fail;
10901 temp1 = true;
10902 }
10903 if (obj1) {
10904 {
10905 arg2 = (int)(SWIG_As_int(obj1));
10906 if (SWIG_arg_fail(2)) SWIG_fail;
10907 }
10908 }
10909 {
10910 PyThreadState* __tstate = wxPyBeginAllowThreads();
10911 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10912
10913 wxPyEndAllowThreads(__tstate);
10914 if (PyErr_Occurred()) SWIG_fail;
10915 }
10916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10917 {
10918 if (temp1)
10919 delete arg1;
10920 }
10921 return resultobj;
10922 fail:
10923 {
10924 if (temp1)
10925 delete arg1;
10926 }
10927 return NULL;
10928 }
10929
10930
10931 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10932 PyObject *resultobj;
10933 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10934 int arg2 = (int) -1 ;
10935 wxPyProcess *result;
10936 PyObject * obj0 = 0 ;
10937 PyObject * obj1 = 0 ;
10938 char *kwnames[] = {
10939 (char *) "parent",(char *) "id", NULL
10940 };
10941
10942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10943 if (obj0) {
10944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10945 if (SWIG_arg_fail(1)) SWIG_fail;
10946 }
10947 if (obj1) {
10948 {
10949 arg2 = (int)(SWIG_As_int(obj1));
10950 if (SWIG_arg_fail(2)) SWIG_fail;
10951 }
10952 }
10953 {
10954 PyThreadState* __tstate = wxPyBeginAllowThreads();
10955 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10956
10957 wxPyEndAllowThreads(__tstate);
10958 if (PyErr_Occurred()) SWIG_fail;
10959 }
10960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10961 return resultobj;
10962 fail:
10963 return NULL;
10964 }
10965
10966
10967 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj;
10969 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10970 PyObject *arg2 = (PyObject *) 0 ;
10971 PyObject *arg3 = (PyObject *) 0 ;
10972 PyObject * obj0 = 0 ;
10973 PyObject * obj1 = 0 ;
10974 PyObject * obj2 = 0 ;
10975 char *kwnames[] = {
10976 (char *) "self",(char *) "self",(char *) "_class", NULL
10977 };
10978
10979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10981 if (SWIG_arg_fail(1)) SWIG_fail;
10982 arg2 = obj1;
10983 arg3 = obj2;
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 (arg1)->_setCallbackInfo(arg2,arg3);
10987
10988 wxPyEndAllowThreads(__tstate);
10989 if (PyErr_Occurred()) SWIG_fail;
10990 }
10991 Py_INCREF(Py_None); resultobj = Py_None;
10992 return resultobj;
10993 fail:
10994 return NULL;
10995 }
10996
10997
10998 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10999 PyObject *resultobj;
11000 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11001 int arg2 ;
11002 int arg3 ;
11003 PyObject * obj0 = 0 ;
11004 PyObject * obj1 = 0 ;
11005 PyObject * obj2 = 0 ;
11006 char *kwnames[] = {
11007 (char *) "self",(char *) "pid",(char *) "status", NULL
11008 };
11009
11010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11012 if (SWIG_arg_fail(1)) SWIG_fail;
11013 {
11014 arg2 = (int)(SWIG_As_int(obj1));
11015 if (SWIG_arg_fail(2)) SWIG_fail;
11016 }
11017 {
11018 arg3 = (int)(SWIG_As_int(obj2));
11019 if (SWIG_arg_fail(3)) SWIG_fail;
11020 }
11021 {
11022 PyThreadState* __tstate = wxPyBeginAllowThreads();
11023 (arg1)->base_OnTerminate(arg2,arg3);
11024
11025 wxPyEndAllowThreads(__tstate);
11026 if (PyErr_Occurred()) SWIG_fail;
11027 }
11028 Py_INCREF(Py_None); resultobj = Py_None;
11029 return resultobj;
11030 fail:
11031 return NULL;
11032 }
11033
11034
11035 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11036 PyObject *resultobj;
11037 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11038 PyObject * obj0 = 0 ;
11039 char *kwnames[] = {
11040 (char *) "self", NULL
11041 };
11042
11043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11045 if (SWIG_arg_fail(1)) SWIG_fail;
11046 {
11047 PyThreadState* __tstate = wxPyBeginAllowThreads();
11048 (arg1)->Redirect();
11049
11050 wxPyEndAllowThreads(__tstate);
11051 if (PyErr_Occurred()) SWIG_fail;
11052 }
11053 Py_INCREF(Py_None); resultobj = Py_None;
11054 return resultobj;
11055 fail:
11056 return NULL;
11057 }
11058
11059
11060 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11061 PyObject *resultobj;
11062 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11063 bool result;
11064 PyObject * obj0 = 0 ;
11065 char *kwnames[] = {
11066 (char *) "self", NULL
11067 };
11068
11069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11071 if (SWIG_arg_fail(1)) SWIG_fail;
11072 {
11073 PyThreadState* __tstate = wxPyBeginAllowThreads();
11074 result = (bool)(arg1)->IsRedirected();
11075
11076 wxPyEndAllowThreads(__tstate);
11077 if (PyErr_Occurred()) SWIG_fail;
11078 }
11079 {
11080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11081 }
11082 return resultobj;
11083 fail:
11084 return NULL;
11085 }
11086
11087
11088 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11089 PyObject *resultobj;
11090 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11091 PyObject * obj0 = 0 ;
11092 char *kwnames[] = {
11093 (char *) "self", NULL
11094 };
11095
11096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11098 if (SWIG_arg_fail(1)) SWIG_fail;
11099 {
11100 PyThreadState* __tstate = wxPyBeginAllowThreads();
11101 (arg1)->Detach();
11102
11103 wxPyEndAllowThreads(__tstate);
11104 if (PyErr_Occurred()) SWIG_fail;
11105 }
11106 Py_INCREF(Py_None); resultobj = Py_None;
11107 return resultobj;
11108 fail:
11109 return NULL;
11110 }
11111
11112
11113 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11114 PyObject *resultobj;
11115 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11116 wxInputStream *result;
11117 PyObject * obj0 = 0 ;
11118 char *kwnames[] = {
11119 (char *) "self", NULL
11120 };
11121
11122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11124 if (SWIG_arg_fail(1)) SWIG_fail;
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 result = (wxInputStream *)(arg1)->GetInputStream();
11128
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 {
11133 wxPyInputStream * _ptr = NULL;
11134
11135 if (result) {
11136 _ptr = new wxPyInputStream(result);
11137 }
11138 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11139 }
11140 return resultobj;
11141 fail:
11142 return NULL;
11143 }
11144
11145
11146 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11147 PyObject *resultobj;
11148 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11149 wxInputStream *result;
11150 PyObject * obj0 = 0 ;
11151 char *kwnames[] = {
11152 (char *) "self", NULL
11153 };
11154
11155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11157 if (SWIG_arg_fail(1)) SWIG_fail;
11158 {
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (wxInputStream *)(arg1)->GetErrorStream();
11161
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 {
11166 wxPyInputStream * _ptr = NULL;
11167
11168 if (result) {
11169 _ptr = new wxPyInputStream(result);
11170 }
11171 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11172 }
11173 return resultobj;
11174 fail:
11175 return NULL;
11176 }
11177
11178
11179 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11180 PyObject *resultobj;
11181 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11182 wxOutputStream *result;
11183 PyObject * obj0 = 0 ;
11184 char *kwnames[] = {
11185 (char *) "self", NULL
11186 };
11187
11188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11190 if (SWIG_arg_fail(1)) SWIG_fail;
11191 {
11192 PyThreadState* __tstate = wxPyBeginAllowThreads();
11193 result = (wxOutputStream *)(arg1)->GetOutputStream();
11194
11195 wxPyEndAllowThreads(__tstate);
11196 if (PyErr_Occurred()) SWIG_fail;
11197 }
11198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11199 return resultobj;
11200 fail:
11201 return NULL;
11202 }
11203
11204
11205 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj;
11207 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11208 PyObject * obj0 = 0 ;
11209 char *kwnames[] = {
11210 (char *) "self", NULL
11211 };
11212
11213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11215 if (SWIG_arg_fail(1)) SWIG_fail;
11216 {
11217 PyThreadState* __tstate = wxPyBeginAllowThreads();
11218 (arg1)->CloseOutput();
11219
11220 wxPyEndAllowThreads(__tstate);
11221 if (PyErr_Occurred()) SWIG_fail;
11222 }
11223 Py_INCREF(Py_None); resultobj = Py_None;
11224 return resultobj;
11225 fail:
11226 return NULL;
11227 }
11228
11229
11230 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11231 PyObject *resultobj;
11232 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11233 bool result;
11234 PyObject * obj0 = 0 ;
11235 char *kwnames[] = {
11236 (char *) "self", NULL
11237 };
11238
11239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11241 if (SWIG_arg_fail(1)) SWIG_fail;
11242 {
11243 PyThreadState* __tstate = wxPyBeginAllowThreads();
11244 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11245
11246 wxPyEndAllowThreads(__tstate);
11247 if (PyErr_Occurred()) SWIG_fail;
11248 }
11249 {
11250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11251 }
11252 return resultobj;
11253 fail:
11254 return NULL;
11255 }
11256
11257
11258 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj;
11260 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11261 bool result;
11262 PyObject * obj0 = 0 ;
11263 char *kwnames[] = {
11264 (char *) "self", NULL
11265 };
11266
11267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11269 if (SWIG_arg_fail(1)) SWIG_fail;
11270 {
11271 PyThreadState* __tstate = wxPyBeginAllowThreads();
11272 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11273
11274 wxPyEndAllowThreads(__tstate);
11275 if (PyErr_Occurred()) SWIG_fail;
11276 }
11277 {
11278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11279 }
11280 return resultobj;
11281 fail:
11282 return NULL;
11283 }
11284
11285
11286 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11287 PyObject *resultobj;
11288 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11289 bool result;
11290 PyObject * obj0 = 0 ;
11291 char *kwnames[] = {
11292 (char *) "self", NULL
11293 };
11294
11295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11297 if (SWIG_arg_fail(1)) SWIG_fail;
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11301
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 {
11306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11307 }
11308 return resultobj;
11309 fail:
11310 return NULL;
11311 }
11312
11313
11314 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11315 PyObject *obj;
11316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11317 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11318 Py_INCREF(obj);
11319 return Py_BuildValue((char *)"");
11320 }
11321 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11322 PyObject *resultobj;
11323 int arg1 = (int) 0 ;
11324 int arg2 = (int) 0 ;
11325 int arg3 = (int) 0 ;
11326 wxProcessEvent *result;
11327 PyObject * obj0 = 0 ;
11328 PyObject * obj1 = 0 ;
11329 PyObject * obj2 = 0 ;
11330 char *kwnames[] = {
11331 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11332 };
11333
11334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11335 if (obj0) {
11336 {
11337 arg1 = (int)(SWIG_As_int(obj0));
11338 if (SWIG_arg_fail(1)) SWIG_fail;
11339 }
11340 }
11341 if (obj1) {
11342 {
11343 arg2 = (int)(SWIG_As_int(obj1));
11344 if (SWIG_arg_fail(2)) SWIG_fail;
11345 }
11346 }
11347 if (obj2) {
11348 {
11349 arg3 = (int)(SWIG_As_int(obj2));
11350 if (SWIG_arg_fail(3)) SWIG_fail;
11351 }
11352 }
11353 {
11354 PyThreadState* __tstate = wxPyBeginAllowThreads();
11355 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11356
11357 wxPyEndAllowThreads(__tstate);
11358 if (PyErr_Occurred()) SWIG_fail;
11359 }
11360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11361 return resultobj;
11362 fail:
11363 return NULL;
11364 }
11365
11366
11367 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11368 PyObject *resultobj;
11369 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11370 int result;
11371 PyObject * obj0 = 0 ;
11372 char *kwnames[] = {
11373 (char *) "self", NULL
11374 };
11375
11376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11378 if (SWIG_arg_fail(1)) SWIG_fail;
11379 {
11380 PyThreadState* __tstate = wxPyBeginAllowThreads();
11381 result = (int)(arg1)->GetPid();
11382
11383 wxPyEndAllowThreads(__tstate);
11384 if (PyErr_Occurred()) SWIG_fail;
11385 }
11386 {
11387 resultobj = SWIG_From_int((int)(result));
11388 }
11389 return resultobj;
11390 fail:
11391 return NULL;
11392 }
11393
11394
11395 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11396 PyObject *resultobj;
11397 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11398 int result;
11399 PyObject * obj0 = 0 ;
11400 char *kwnames[] = {
11401 (char *) "self", NULL
11402 };
11403
11404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11406 if (SWIG_arg_fail(1)) SWIG_fail;
11407 {
11408 PyThreadState* __tstate = wxPyBeginAllowThreads();
11409 result = (int)(arg1)->GetExitCode();
11410
11411 wxPyEndAllowThreads(__tstate);
11412 if (PyErr_Occurred()) SWIG_fail;
11413 }
11414 {
11415 resultobj = SWIG_From_int((int)(result));
11416 }
11417 return resultobj;
11418 fail:
11419 return NULL;
11420 }
11421
11422
11423 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11424 PyObject *resultobj;
11425 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11426 int arg2 ;
11427 PyObject * obj0 = 0 ;
11428 PyObject * obj1 = 0 ;
11429 char *kwnames[] = {
11430 (char *) "self",(char *) "m_pid", NULL
11431 };
11432
11433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11435 if (SWIG_arg_fail(1)) SWIG_fail;
11436 {
11437 arg2 = (int)(SWIG_As_int(obj1));
11438 if (SWIG_arg_fail(2)) SWIG_fail;
11439 }
11440 if (arg1) (arg1)->m_pid = arg2;
11441
11442 Py_INCREF(Py_None); resultobj = Py_None;
11443 return resultobj;
11444 fail:
11445 return NULL;
11446 }
11447
11448
11449 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11450 PyObject *resultobj;
11451 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11452 int result;
11453 PyObject * obj0 = 0 ;
11454 char *kwnames[] = {
11455 (char *) "self", NULL
11456 };
11457
11458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11460 if (SWIG_arg_fail(1)) SWIG_fail;
11461 result = (int) ((arg1)->m_pid);
11462
11463 {
11464 resultobj = SWIG_From_int((int)(result));
11465 }
11466 return resultobj;
11467 fail:
11468 return NULL;
11469 }
11470
11471
11472 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11473 PyObject *resultobj;
11474 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11475 int arg2 ;
11476 PyObject * obj0 = 0 ;
11477 PyObject * obj1 = 0 ;
11478 char *kwnames[] = {
11479 (char *) "self",(char *) "m_exitcode", NULL
11480 };
11481
11482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 {
11486 arg2 = (int)(SWIG_As_int(obj1));
11487 if (SWIG_arg_fail(2)) SWIG_fail;
11488 }
11489 if (arg1) (arg1)->m_exitcode = arg2;
11490
11491 Py_INCREF(Py_None); resultobj = Py_None;
11492 return resultobj;
11493 fail:
11494 return NULL;
11495 }
11496
11497
11498 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11499 PyObject *resultobj;
11500 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11501 int result;
11502 PyObject * obj0 = 0 ;
11503 char *kwnames[] = {
11504 (char *) "self", NULL
11505 };
11506
11507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11509 if (SWIG_arg_fail(1)) SWIG_fail;
11510 result = (int) ((arg1)->m_exitcode);
11511
11512 {
11513 resultobj = SWIG_From_int((int)(result));
11514 }
11515 return resultobj;
11516 fail:
11517 return NULL;
11518 }
11519
11520
11521 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11522 PyObject *obj;
11523 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11524 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11525 Py_INCREF(obj);
11526 return Py_BuildValue((char *)"");
11527 }
11528 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11529 PyObject *resultobj;
11530 wxString *arg1 = 0 ;
11531 int arg2 = (int) wxEXEC_ASYNC ;
11532 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11533 long result;
11534 bool temp1 = false ;
11535 PyObject * obj0 = 0 ;
11536 PyObject * obj1 = 0 ;
11537 PyObject * obj2 = 0 ;
11538 char *kwnames[] = {
11539 (char *) "command",(char *) "flags",(char *) "process", NULL
11540 };
11541
11542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11543 {
11544 arg1 = wxString_in_helper(obj0);
11545 if (arg1 == NULL) SWIG_fail;
11546 temp1 = true;
11547 }
11548 if (obj1) {
11549 {
11550 arg2 = (int)(SWIG_As_int(obj1));
11551 if (SWIG_arg_fail(2)) SWIG_fail;
11552 }
11553 }
11554 if (obj2) {
11555 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11556 if (SWIG_arg_fail(3)) SWIG_fail;
11557 }
11558 {
11559 if (!wxPyCheckForApp()) SWIG_fail;
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11562
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 {
11567 resultobj = SWIG_From_long((long)(result));
11568 }
11569 {
11570 if (temp1)
11571 delete arg1;
11572 }
11573 return resultobj;
11574 fail:
11575 {
11576 if (temp1)
11577 delete arg1;
11578 }
11579 return NULL;
11580 }
11581
11582
11583 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11584 PyObject *resultobj;
11585 long arg1 ;
11586 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11587 wxKillError *arg3 = (wxKillError *) 0 ;
11588 int arg4 = (int) wxKILL_NOCHILDREN ;
11589 int result;
11590 wxKillError temp3 ;
11591 PyObject * obj0 = 0 ;
11592 PyObject * obj1 = 0 ;
11593 PyObject * obj2 = 0 ;
11594 char *kwnames[] = {
11595 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11596 };
11597
11598 {
11599 arg3 = &temp3;
11600 }
11601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11602 {
11603 arg1 = (long)(SWIG_As_long(obj0));
11604 if (SWIG_arg_fail(1)) SWIG_fail;
11605 }
11606 if (obj1) {
11607 {
11608 arg2 = (wxSignal)(SWIG_As_int(obj1));
11609 if (SWIG_arg_fail(2)) SWIG_fail;
11610 }
11611 }
11612 if (obj2) {
11613 {
11614 arg4 = (int)(SWIG_As_int(obj2));
11615 if (SWIG_arg_fail(4)) SWIG_fail;
11616 }
11617 }
11618 {
11619 PyThreadState* __tstate = wxPyBeginAllowThreads();
11620 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11621
11622 wxPyEndAllowThreads(__tstate);
11623 if (PyErr_Occurred()) SWIG_fail;
11624 }
11625 {
11626 resultobj = SWIG_From_int((int)(result));
11627 }
11628 {
11629 PyObject* o;
11630 o = PyInt_FromLong((long) (*arg3));
11631 resultobj = t_output_helper(resultobj, o);
11632 }
11633 return resultobj;
11634 fail:
11635 return NULL;
11636 }
11637
11638
11639 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11640 PyObject *resultobj;
11641 int arg1 = (int) wxJOYSTICK1 ;
11642 wxJoystick *result;
11643 PyObject * obj0 = 0 ;
11644 char *kwnames[] = {
11645 (char *) "joystick", NULL
11646 };
11647
11648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11649 if (obj0) {
11650 {
11651 arg1 = (int)(SWIG_As_int(obj0));
11652 if (SWIG_arg_fail(1)) SWIG_fail;
11653 }
11654 }
11655 {
11656 if (!wxPyCheckForApp()) SWIG_fail;
11657 PyThreadState* __tstate = wxPyBeginAllowThreads();
11658 result = (wxJoystick *)new wxJoystick(arg1);
11659
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11664 return resultobj;
11665 fail:
11666 return NULL;
11667 }
11668
11669
11670 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11671 PyObject *resultobj;
11672 wxJoystick *arg1 = (wxJoystick *) 0 ;
11673 PyObject * obj0 = 0 ;
11674 char *kwnames[] = {
11675 (char *) "self", NULL
11676 };
11677
11678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11680 if (SWIG_arg_fail(1)) SWIG_fail;
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 delete arg1;
11684
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 Py_INCREF(Py_None); resultobj = Py_None;
11689 return resultobj;
11690 fail:
11691 return NULL;
11692 }
11693
11694
11695 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11696 PyObject *resultobj;
11697 wxJoystick *arg1 = (wxJoystick *) 0 ;
11698 wxPoint result;
11699 PyObject * obj0 = 0 ;
11700 char *kwnames[] = {
11701 (char *) "self", NULL
11702 };
11703
11704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11706 if (SWIG_arg_fail(1)) SWIG_fail;
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (arg1)->GetPosition();
11710
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 wxPoint * resultptr;
11716 resultptr = new wxPoint((wxPoint &)(result));
11717 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11718 }
11719 return resultobj;
11720 fail:
11721 return NULL;
11722 }
11723
11724
11725 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11726 PyObject *resultobj;
11727 wxJoystick *arg1 = (wxJoystick *) 0 ;
11728 int result;
11729 PyObject * obj0 = 0 ;
11730 char *kwnames[] = {
11731 (char *) "self", NULL
11732 };
11733
11734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11736 if (SWIG_arg_fail(1)) SWIG_fail;
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 result = (int)(arg1)->GetZPosition();
11740
11741 wxPyEndAllowThreads(__tstate);
11742 if (PyErr_Occurred()) SWIG_fail;
11743 }
11744 {
11745 resultobj = SWIG_From_int((int)(result));
11746 }
11747 return resultobj;
11748 fail:
11749 return NULL;
11750 }
11751
11752
11753 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11754 PyObject *resultobj;
11755 wxJoystick *arg1 = (wxJoystick *) 0 ;
11756 int result;
11757 PyObject * obj0 = 0 ;
11758 char *kwnames[] = {
11759 (char *) "self", NULL
11760 };
11761
11762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11764 if (SWIG_arg_fail(1)) SWIG_fail;
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (int)(arg1)->GetButtonState();
11768
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 resultobj = SWIG_From_int((int)(result));
11774 }
11775 return resultobj;
11776 fail:
11777 return NULL;
11778 }
11779
11780
11781 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11782 PyObject *resultobj;
11783 wxJoystick *arg1 = (wxJoystick *) 0 ;
11784 int result;
11785 PyObject * obj0 = 0 ;
11786 char *kwnames[] = {
11787 (char *) "self", NULL
11788 };
11789
11790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11792 if (SWIG_arg_fail(1)) SWIG_fail;
11793 {
11794 PyThreadState* __tstate = wxPyBeginAllowThreads();
11795 result = (int)(arg1)->GetPOVPosition();
11796
11797 wxPyEndAllowThreads(__tstate);
11798 if (PyErr_Occurred()) SWIG_fail;
11799 }
11800 {
11801 resultobj = SWIG_From_int((int)(result));
11802 }
11803 return resultobj;
11804 fail:
11805 return NULL;
11806 }
11807
11808
11809 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11810 PyObject *resultobj;
11811 wxJoystick *arg1 = (wxJoystick *) 0 ;
11812 int result;
11813 PyObject * obj0 = 0 ;
11814 char *kwnames[] = {
11815 (char *) "self", NULL
11816 };
11817
11818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11820 if (SWIG_arg_fail(1)) SWIG_fail;
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (int)(arg1)->GetPOVCTSPosition();
11824
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 {
11829 resultobj = SWIG_From_int((int)(result));
11830 }
11831 return resultobj;
11832 fail:
11833 return NULL;
11834 }
11835
11836
11837 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11838 PyObject *resultobj;
11839 wxJoystick *arg1 = (wxJoystick *) 0 ;
11840 int result;
11841 PyObject * obj0 = 0 ;
11842 char *kwnames[] = {
11843 (char *) "self", NULL
11844 };
11845
11846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11848 if (SWIG_arg_fail(1)) SWIG_fail;
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = (int)(arg1)->GetRudderPosition();
11852
11853 wxPyEndAllowThreads(__tstate);
11854 if (PyErr_Occurred()) SWIG_fail;
11855 }
11856 {
11857 resultobj = SWIG_From_int((int)(result));
11858 }
11859 return resultobj;
11860 fail:
11861 return NULL;
11862 }
11863
11864
11865 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11866 PyObject *resultobj;
11867 wxJoystick *arg1 = (wxJoystick *) 0 ;
11868 int result;
11869 PyObject * obj0 = 0 ;
11870 char *kwnames[] = {
11871 (char *) "self", NULL
11872 };
11873
11874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11876 if (SWIG_arg_fail(1)) SWIG_fail;
11877 {
11878 PyThreadState* __tstate = wxPyBeginAllowThreads();
11879 result = (int)(arg1)->GetUPosition();
11880
11881 wxPyEndAllowThreads(__tstate);
11882 if (PyErr_Occurred()) SWIG_fail;
11883 }
11884 {
11885 resultobj = SWIG_From_int((int)(result));
11886 }
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11894 PyObject *resultobj;
11895 wxJoystick *arg1 = (wxJoystick *) 0 ;
11896 int result;
11897 PyObject * obj0 = 0 ;
11898 char *kwnames[] = {
11899 (char *) "self", NULL
11900 };
11901
11902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11904 if (SWIG_arg_fail(1)) SWIG_fail;
11905 {
11906 PyThreadState* __tstate = wxPyBeginAllowThreads();
11907 result = (int)(arg1)->GetVPosition();
11908
11909 wxPyEndAllowThreads(__tstate);
11910 if (PyErr_Occurred()) SWIG_fail;
11911 }
11912 {
11913 resultobj = SWIG_From_int((int)(result));
11914 }
11915 return resultobj;
11916 fail:
11917 return NULL;
11918 }
11919
11920
11921 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11922 PyObject *resultobj;
11923 wxJoystick *arg1 = (wxJoystick *) 0 ;
11924 int result;
11925 PyObject * obj0 = 0 ;
11926 char *kwnames[] = {
11927 (char *) "self", NULL
11928 };
11929
11930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11932 if (SWIG_arg_fail(1)) SWIG_fail;
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 result = (int)(arg1)->GetMovementThreshold();
11936
11937 wxPyEndAllowThreads(__tstate);
11938 if (PyErr_Occurred()) SWIG_fail;
11939 }
11940 {
11941 resultobj = SWIG_From_int((int)(result));
11942 }
11943 return resultobj;
11944 fail:
11945 return NULL;
11946 }
11947
11948
11949 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11950 PyObject *resultobj;
11951 wxJoystick *arg1 = (wxJoystick *) 0 ;
11952 int arg2 ;
11953 PyObject * obj0 = 0 ;
11954 PyObject * obj1 = 0 ;
11955 char *kwnames[] = {
11956 (char *) "self",(char *) "threshold", NULL
11957 };
11958
11959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11961 if (SWIG_arg_fail(1)) SWIG_fail;
11962 {
11963 arg2 = (int)(SWIG_As_int(obj1));
11964 if (SWIG_arg_fail(2)) SWIG_fail;
11965 }
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 (arg1)->SetMovementThreshold(arg2);
11969
11970 wxPyEndAllowThreads(__tstate);
11971 if (PyErr_Occurred()) SWIG_fail;
11972 }
11973 Py_INCREF(Py_None); resultobj = Py_None;
11974 return resultobj;
11975 fail:
11976 return NULL;
11977 }
11978
11979
11980 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11981 PyObject *resultobj;
11982 wxJoystick *arg1 = (wxJoystick *) 0 ;
11983 bool result;
11984 PyObject * obj0 = 0 ;
11985 char *kwnames[] = {
11986 (char *) "self", NULL
11987 };
11988
11989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11991 if (SWIG_arg_fail(1)) SWIG_fail;
11992 {
11993 PyThreadState* __tstate = wxPyBeginAllowThreads();
11994 result = (bool)(arg1)->IsOk();
11995
11996 wxPyEndAllowThreads(__tstate);
11997 if (PyErr_Occurred()) SWIG_fail;
11998 }
11999 {
12000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12001 }
12002 return resultobj;
12003 fail:
12004 return NULL;
12005 }
12006
12007
12008 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12009 PyObject *resultobj;
12010 wxJoystick *arg1 = (wxJoystick *) 0 ;
12011 int result;
12012 PyObject * obj0 = 0 ;
12013 char *kwnames[] = {
12014 (char *) "self", NULL
12015 };
12016
12017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12019 if (SWIG_arg_fail(1)) SWIG_fail;
12020 {
12021 PyThreadState* __tstate = wxPyBeginAllowThreads();
12022 result = (int)(arg1)->GetNumberJoysticks();
12023
12024 wxPyEndAllowThreads(__tstate);
12025 if (PyErr_Occurred()) SWIG_fail;
12026 }
12027 {
12028 resultobj = SWIG_From_int((int)(result));
12029 }
12030 return resultobj;
12031 fail:
12032 return NULL;
12033 }
12034
12035
12036 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12037 PyObject *resultobj;
12038 wxJoystick *arg1 = (wxJoystick *) 0 ;
12039 int result;
12040 PyObject * obj0 = 0 ;
12041 char *kwnames[] = {
12042 (char *) "self", NULL
12043 };
12044
12045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12047 if (SWIG_arg_fail(1)) SWIG_fail;
12048 {
12049 PyThreadState* __tstate = wxPyBeginAllowThreads();
12050 result = (int)(arg1)->GetManufacturerId();
12051
12052 wxPyEndAllowThreads(__tstate);
12053 if (PyErr_Occurred()) SWIG_fail;
12054 }
12055 {
12056 resultobj = SWIG_From_int((int)(result));
12057 }
12058 return resultobj;
12059 fail:
12060 return NULL;
12061 }
12062
12063
12064 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12065 PyObject *resultobj;
12066 wxJoystick *arg1 = (wxJoystick *) 0 ;
12067 int result;
12068 PyObject * obj0 = 0 ;
12069 char *kwnames[] = {
12070 (char *) "self", NULL
12071 };
12072
12073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12075 if (SWIG_arg_fail(1)) SWIG_fail;
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 result = (int)(arg1)->GetProductId();
12079
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 {
12084 resultobj = SWIG_From_int((int)(result));
12085 }
12086 return resultobj;
12087 fail:
12088 return NULL;
12089 }
12090
12091
12092 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12093 PyObject *resultobj;
12094 wxJoystick *arg1 = (wxJoystick *) 0 ;
12095 wxString result;
12096 PyObject * obj0 = 0 ;
12097 char *kwnames[] = {
12098 (char *) "self", NULL
12099 };
12100
12101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12103 if (SWIG_arg_fail(1)) SWIG_fail;
12104 {
12105 PyThreadState* __tstate = wxPyBeginAllowThreads();
12106 result = (arg1)->GetProductName();
12107
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 {
12112 #if wxUSE_UNICODE
12113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12114 #else
12115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12116 #endif
12117 }
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12125 PyObject *resultobj;
12126 wxJoystick *arg1 = (wxJoystick *) 0 ;
12127 int result;
12128 PyObject * obj0 = 0 ;
12129 char *kwnames[] = {
12130 (char *) "self", NULL
12131 };
12132
12133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(1)) SWIG_fail;
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (int)(arg1)->GetXMin();
12139
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 {
12144 resultobj = SWIG_From_int((int)(result));
12145 }
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj;
12154 wxJoystick *arg1 = (wxJoystick *) 0 ;
12155 int result;
12156 PyObject * obj0 = 0 ;
12157 char *kwnames[] = {
12158 (char *) "self", NULL
12159 };
12160
12161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12163 if (SWIG_arg_fail(1)) SWIG_fail;
12164 {
12165 PyThreadState* __tstate = wxPyBeginAllowThreads();
12166 result = (int)(arg1)->GetYMin();
12167
12168 wxPyEndAllowThreads(__tstate);
12169 if (PyErr_Occurred()) SWIG_fail;
12170 }
12171 {
12172 resultobj = SWIG_From_int((int)(result));
12173 }
12174 return resultobj;
12175 fail:
12176 return NULL;
12177 }
12178
12179
12180 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12181 PyObject *resultobj;
12182 wxJoystick *arg1 = (wxJoystick *) 0 ;
12183 int result;
12184 PyObject * obj0 = 0 ;
12185 char *kwnames[] = {
12186 (char *) "self", NULL
12187 };
12188
12189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12191 if (SWIG_arg_fail(1)) SWIG_fail;
12192 {
12193 PyThreadState* __tstate = wxPyBeginAllowThreads();
12194 result = (int)(arg1)->GetZMin();
12195
12196 wxPyEndAllowThreads(__tstate);
12197 if (PyErr_Occurred()) SWIG_fail;
12198 }
12199 {
12200 resultobj = SWIG_From_int((int)(result));
12201 }
12202 return resultobj;
12203 fail:
12204 return NULL;
12205 }
12206
12207
12208 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12209 PyObject *resultobj;
12210 wxJoystick *arg1 = (wxJoystick *) 0 ;
12211 int result;
12212 PyObject * obj0 = 0 ;
12213 char *kwnames[] = {
12214 (char *) "self", NULL
12215 };
12216
12217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12219 if (SWIG_arg_fail(1)) SWIG_fail;
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 result = (int)(arg1)->GetXMax();
12223
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 {
12228 resultobj = SWIG_From_int((int)(result));
12229 }
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12237 PyObject *resultobj;
12238 wxJoystick *arg1 = (wxJoystick *) 0 ;
12239 int result;
12240 PyObject * obj0 = 0 ;
12241 char *kwnames[] = {
12242 (char *) "self", NULL
12243 };
12244
12245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12247 if (SWIG_arg_fail(1)) SWIG_fail;
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 result = (int)(arg1)->GetYMax();
12251
12252 wxPyEndAllowThreads(__tstate);
12253 if (PyErr_Occurred()) SWIG_fail;
12254 }
12255 {
12256 resultobj = SWIG_From_int((int)(result));
12257 }
12258 return resultobj;
12259 fail:
12260 return NULL;
12261 }
12262
12263
12264 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12265 PyObject *resultobj;
12266 wxJoystick *arg1 = (wxJoystick *) 0 ;
12267 int result;
12268 PyObject * obj0 = 0 ;
12269 char *kwnames[] = {
12270 (char *) "self", NULL
12271 };
12272
12273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12275 if (SWIG_arg_fail(1)) SWIG_fail;
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 result = (int)(arg1)->GetZMax();
12279
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 {
12284 resultobj = SWIG_From_int((int)(result));
12285 }
12286 return resultobj;
12287 fail:
12288 return NULL;
12289 }
12290
12291
12292 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12293 PyObject *resultobj;
12294 wxJoystick *arg1 = (wxJoystick *) 0 ;
12295 int result;
12296 PyObject * obj0 = 0 ;
12297 char *kwnames[] = {
12298 (char *) "self", NULL
12299 };
12300
12301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12303 if (SWIG_arg_fail(1)) SWIG_fail;
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 result = (int)(arg1)->GetNumberButtons();
12307
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 {
12312 resultobj = SWIG_From_int((int)(result));
12313 }
12314 return resultobj;
12315 fail:
12316 return NULL;
12317 }
12318
12319
12320 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12321 PyObject *resultobj;
12322 wxJoystick *arg1 = (wxJoystick *) 0 ;
12323 int result;
12324 PyObject * obj0 = 0 ;
12325 char *kwnames[] = {
12326 (char *) "self", NULL
12327 };
12328
12329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12331 if (SWIG_arg_fail(1)) SWIG_fail;
12332 {
12333 PyThreadState* __tstate = wxPyBeginAllowThreads();
12334 result = (int)(arg1)->GetNumberAxes();
12335
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 {
12340 resultobj = SWIG_From_int((int)(result));
12341 }
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12349 PyObject *resultobj;
12350 wxJoystick *arg1 = (wxJoystick *) 0 ;
12351 int result;
12352 PyObject * obj0 = 0 ;
12353 char *kwnames[] = {
12354 (char *) "self", NULL
12355 };
12356
12357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12359 if (SWIG_arg_fail(1)) SWIG_fail;
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (int)(arg1)->GetMaxButtons();
12363
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 {
12368 resultobj = SWIG_From_int((int)(result));
12369 }
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12377 PyObject *resultobj;
12378 wxJoystick *arg1 = (wxJoystick *) 0 ;
12379 int result;
12380 PyObject * obj0 = 0 ;
12381 char *kwnames[] = {
12382 (char *) "self", NULL
12383 };
12384
12385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12387 if (SWIG_arg_fail(1)) SWIG_fail;
12388 {
12389 PyThreadState* __tstate = wxPyBeginAllowThreads();
12390 result = (int)(arg1)->GetMaxAxes();
12391
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 {
12396 resultobj = SWIG_From_int((int)(result));
12397 }
12398 return resultobj;
12399 fail:
12400 return NULL;
12401 }
12402
12403
12404 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12405 PyObject *resultobj;
12406 wxJoystick *arg1 = (wxJoystick *) 0 ;
12407 int result;
12408 PyObject * obj0 = 0 ;
12409 char *kwnames[] = {
12410 (char *) "self", NULL
12411 };
12412
12413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12415 if (SWIG_arg_fail(1)) SWIG_fail;
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 result = (int)(arg1)->GetPollingMin();
12419
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 {
12424 resultobj = SWIG_From_int((int)(result));
12425 }
12426 return resultobj;
12427 fail:
12428 return NULL;
12429 }
12430
12431
12432 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12433 PyObject *resultobj;
12434 wxJoystick *arg1 = (wxJoystick *) 0 ;
12435 int result;
12436 PyObject * obj0 = 0 ;
12437 char *kwnames[] = {
12438 (char *) "self", NULL
12439 };
12440
12441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12443 if (SWIG_arg_fail(1)) SWIG_fail;
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 result = (int)(arg1)->GetPollingMax();
12447
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 {
12452 resultobj = SWIG_From_int((int)(result));
12453 }
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12461 PyObject *resultobj;
12462 wxJoystick *arg1 = (wxJoystick *) 0 ;
12463 int result;
12464 PyObject * obj0 = 0 ;
12465 char *kwnames[] = {
12466 (char *) "self", NULL
12467 };
12468
12469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12471 if (SWIG_arg_fail(1)) SWIG_fail;
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 result = (int)(arg1)->GetRudderMin();
12475
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 {
12480 resultobj = SWIG_From_int((int)(result));
12481 }
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj;
12490 wxJoystick *arg1 = (wxJoystick *) 0 ;
12491 int result;
12492 PyObject * obj0 = 0 ;
12493 char *kwnames[] = {
12494 (char *) "self", NULL
12495 };
12496
12497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12499 if (SWIG_arg_fail(1)) SWIG_fail;
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = (int)(arg1)->GetRudderMax();
12503
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 {
12508 resultobj = SWIG_From_int((int)(result));
12509 }
12510 return resultobj;
12511 fail:
12512 return NULL;
12513 }
12514
12515
12516 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12517 PyObject *resultobj;
12518 wxJoystick *arg1 = (wxJoystick *) 0 ;
12519 int result;
12520 PyObject * obj0 = 0 ;
12521 char *kwnames[] = {
12522 (char *) "self", NULL
12523 };
12524
12525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12527 if (SWIG_arg_fail(1)) SWIG_fail;
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 result = (int)(arg1)->GetUMin();
12531
12532 wxPyEndAllowThreads(__tstate);
12533 if (PyErr_Occurred()) SWIG_fail;
12534 }
12535 {
12536 resultobj = SWIG_From_int((int)(result));
12537 }
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12545 PyObject *resultobj;
12546 wxJoystick *arg1 = (wxJoystick *) 0 ;
12547 int result;
12548 PyObject * obj0 = 0 ;
12549 char *kwnames[] = {
12550 (char *) "self", NULL
12551 };
12552
12553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12555 if (SWIG_arg_fail(1)) SWIG_fail;
12556 {
12557 PyThreadState* __tstate = wxPyBeginAllowThreads();
12558 result = (int)(arg1)->GetUMax();
12559
12560 wxPyEndAllowThreads(__tstate);
12561 if (PyErr_Occurred()) SWIG_fail;
12562 }
12563 {
12564 resultobj = SWIG_From_int((int)(result));
12565 }
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12573 PyObject *resultobj;
12574 wxJoystick *arg1 = (wxJoystick *) 0 ;
12575 int result;
12576 PyObject * obj0 = 0 ;
12577 char *kwnames[] = {
12578 (char *) "self", NULL
12579 };
12580
12581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12583 if (SWIG_arg_fail(1)) SWIG_fail;
12584 {
12585 PyThreadState* __tstate = wxPyBeginAllowThreads();
12586 result = (int)(arg1)->GetVMin();
12587
12588 wxPyEndAllowThreads(__tstate);
12589 if (PyErr_Occurred()) SWIG_fail;
12590 }
12591 {
12592 resultobj = SWIG_From_int((int)(result));
12593 }
12594 return resultobj;
12595 fail:
12596 return NULL;
12597 }
12598
12599
12600 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12601 PyObject *resultobj;
12602 wxJoystick *arg1 = (wxJoystick *) 0 ;
12603 int result;
12604 PyObject * obj0 = 0 ;
12605 char *kwnames[] = {
12606 (char *) "self", NULL
12607 };
12608
12609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12611 if (SWIG_arg_fail(1)) SWIG_fail;
12612 {
12613 PyThreadState* __tstate = wxPyBeginAllowThreads();
12614 result = (int)(arg1)->GetVMax();
12615
12616 wxPyEndAllowThreads(__tstate);
12617 if (PyErr_Occurred()) SWIG_fail;
12618 }
12619 {
12620 resultobj = SWIG_From_int((int)(result));
12621 }
12622 return resultobj;
12623 fail:
12624 return NULL;
12625 }
12626
12627
12628 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj;
12630 wxJoystick *arg1 = (wxJoystick *) 0 ;
12631 bool result;
12632 PyObject * obj0 = 0 ;
12633 char *kwnames[] = {
12634 (char *) "self", NULL
12635 };
12636
12637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12639 if (SWIG_arg_fail(1)) SWIG_fail;
12640 {
12641 PyThreadState* __tstate = wxPyBeginAllowThreads();
12642 result = (bool)(arg1)->HasRudder();
12643
12644 wxPyEndAllowThreads(__tstate);
12645 if (PyErr_Occurred()) SWIG_fail;
12646 }
12647 {
12648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12649 }
12650 return resultobj;
12651 fail:
12652 return NULL;
12653 }
12654
12655
12656 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12657 PyObject *resultobj;
12658 wxJoystick *arg1 = (wxJoystick *) 0 ;
12659 bool result;
12660 PyObject * obj0 = 0 ;
12661 char *kwnames[] = {
12662 (char *) "self", NULL
12663 };
12664
12665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12667 if (SWIG_arg_fail(1)) SWIG_fail;
12668 {
12669 PyThreadState* __tstate = wxPyBeginAllowThreads();
12670 result = (bool)(arg1)->HasZ();
12671
12672 wxPyEndAllowThreads(__tstate);
12673 if (PyErr_Occurred()) SWIG_fail;
12674 }
12675 {
12676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12677 }
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12685 PyObject *resultobj;
12686 wxJoystick *arg1 = (wxJoystick *) 0 ;
12687 bool result;
12688 PyObject * obj0 = 0 ;
12689 char *kwnames[] = {
12690 (char *) "self", NULL
12691 };
12692
12693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12695 if (SWIG_arg_fail(1)) SWIG_fail;
12696 {
12697 PyThreadState* __tstate = wxPyBeginAllowThreads();
12698 result = (bool)(arg1)->HasU();
12699
12700 wxPyEndAllowThreads(__tstate);
12701 if (PyErr_Occurred()) SWIG_fail;
12702 }
12703 {
12704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12705 }
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12713 PyObject *resultobj;
12714 wxJoystick *arg1 = (wxJoystick *) 0 ;
12715 bool result;
12716 PyObject * obj0 = 0 ;
12717 char *kwnames[] = {
12718 (char *) "self", NULL
12719 };
12720
12721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12723 if (SWIG_arg_fail(1)) SWIG_fail;
12724 {
12725 PyThreadState* __tstate = wxPyBeginAllowThreads();
12726 result = (bool)(arg1)->HasV();
12727
12728 wxPyEndAllowThreads(__tstate);
12729 if (PyErr_Occurred()) SWIG_fail;
12730 }
12731 {
12732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12733 }
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12741 PyObject *resultobj;
12742 wxJoystick *arg1 = (wxJoystick *) 0 ;
12743 bool result;
12744 PyObject * obj0 = 0 ;
12745 char *kwnames[] = {
12746 (char *) "self", NULL
12747 };
12748
12749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12751 if (SWIG_arg_fail(1)) SWIG_fail;
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 result = (bool)(arg1)->HasPOV();
12755
12756 wxPyEndAllowThreads(__tstate);
12757 if (PyErr_Occurred()) SWIG_fail;
12758 }
12759 {
12760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12761 }
12762 return resultobj;
12763 fail:
12764 return NULL;
12765 }
12766
12767
12768 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12769 PyObject *resultobj;
12770 wxJoystick *arg1 = (wxJoystick *) 0 ;
12771 bool result;
12772 PyObject * obj0 = 0 ;
12773 char *kwnames[] = {
12774 (char *) "self", NULL
12775 };
12776
12777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12779 if (SWIG_arg_fail(1)) SWIG_fail;
12780 {
12781 PyThreadState* __tstate = wxPyBeginAllowThreads();
12782 result = (bool)(arg1)->HasPOV4Dir();
12783
12784 wxPyEndAllowThreads(__tstate);
12785 if (PyErr_Occurred()) SWIG_fail;
12786 }
12787 {
12788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12789 }
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12797 PyObject *resultobj;
12798 wxJoystick *arg1 = (wxJoystick *) 0 ;
12799 bool result;
12800 PyObject * obj0 = 0 ;
12801 char *kwnames[] = {
12802 (char *) "self", NULL
12803 };
12804
12805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12807 if (SWIG_arg_fail(1)) SWIG_fail;
12808 {
12809 PyThreadState* __tstate = wxPyBeginAllowThreads();
12810 result = (bool)(arg1)->HasPOVCTS();
12811
12812 wxPyEndAllowThreads(__tstate);
12813 if (PyErr_Occurred()) SWIG_fail;
12814 }
12815 {
12816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12817 }
12818 return resultobj;
12819 fail:
12820 return NULL;
12821 }
12822
12823
12824 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12825 PyObject *resultobj;
12826 wxJoystick *arg1 = (wxJoystick *) 0 ;
12827 wxWindow *arg2 = (wxWindow *) 0 ;
12828 int arg3 = (int) 0 ;
12829 bool result;
12830 PyObject * obj0 = 0 ;
12831 PyObject * obj1 = 0 ;
12832 PyObject * obj2 = 0 ;
12833 char *kwnames[] = {
12834 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12835 };
12836
12837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12839 if (SWIG_arg_fail(1)) SWIG_fail;
12840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12841 if (SWIG_arg_fail(2)) SWIG_fail;
12842 if (obj2) {
12843 {
12844 arg3 = (int)(SWIG_As_int(obj2));
12845 if (SWIG_arg_fail(3)) SWIG_fail;
12846 }
12847 }
12848 {
12849 PyThreadState* __tstate = wxPyBeginAllowThreads();
12850 result = (bool)(arg1)->SetCapture(arg2,arg3);
12851
12852 wxPyEndAllowThreads(__tstate);
12853 if (PyErr_Occurred()) SWIG_fail;
12854 }
12855 {
12856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12857 }
12858 return resultobj;
12859 fail:
12860 return NULL;
12861 }
12862
12863
12864 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12865 PyObject *resultobj;
12866 wxJoystick *arg1 = (wxJoystick *) 0 ;
12867 bool result;
12868 PyObject * obj0 = 0 ;
12869 char *kwnames[] = {
12870 (char *) "self", NULL
12871 };
12872
12873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12875 if (SWIG_arg_fail(1)) SWIG_fail;
12876 {
12877 PyThreadState* __tstate = wxPyBeginAllowThreads();
12878 result = (bool)(arg1)->ReleaseCapture();
12879
12880 wxPyEndAllowThreads(__tstate);
12881 if (PyErr_Occurred()) SWIG_fail;
12882 }
12883 {
12884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12885 }
12886 return resultobj;
12887 fail:
12888 return NULL;
12889 }
12890
12891
12892 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12893 PyObject *obj;
12894 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12895 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12896 Py_INCREF(obj);
12897 return Py_BuildValue((char *)"");
12898 }
12899 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12900 PyObject *resultobj;
12901 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12902 int arg2 = (int) 0 ;
12903 int arg3 = (int) wxJOYSTICK1 ;
12904 int arg4 = (int) 0 ;
12905 wxJoystickEvent *result;
12906 PyObject * obj0 = 0 ;
12907 PyObject * obj1 = 0 ;
12908 PyObject * obj2 = 0 ;
12909 PyObject * obj3 = 0 ;
12910 char *kwnames[] = {
12911 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12912 };
12913
12914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12915 if (obj0) {
12916 {
12917 arg1 = (wxEventType)(SWIG_As_int(obj0));
12918 if (SWIG_arg_fail(1)) SWIG_fail;
12919 }
12920 }
12921 if (obj1) {
12922 {
12923 arg2 = (int)(SWIG_As_int(obj1));
12924 if (SWIG_arg_fail(2)) SWIG_fail;
12925 }
12926 }
12927 if (obj2) {
12928 {
12929 arg3 = (int)(SWIG_As_int(obj2));
12930 if (SWIG_arg_fail(3)) SWIG_fail;
12931 }
12932 }
12933 if (obj3) {
12934 {
12935 arg4 = (int)(SWIG_As_int(obj3));
12936 if (SWIG_arg_fail(4)) SWIG_fail;
12937 }
12938 }
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12942
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12947 return resultobj;
12948 fail:
12949 return NULL;
12950 }
12951
12952
12953 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12954 PyObject *resultobj;
12955 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12956 wxPoint result;
12957 PyObject * obj0 = 0 ;
12958 char *kwnames[] = {
12959 (char *) "self", NULL
12960 };
12961
12962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12964 if (SWIG_arg_fail(1)) SWIG_fail;
12965 {
12966 PyThreadState* __tstate = wxPyBeginAllowThreads();
12967 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12968
12969 wxPyEndAllowThreads(__tstate);
12970 if (PyErr_Occurred()) SWIG_fail;
12971 }
12972 {
12973 wxPoint * resultptr;
12974 resultptr = new wxPoint((wxPoint &)(result));
12975 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12976 }
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12984 PyObject *resultobj;
12985 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12986 int result;
12987 PyObject * obj0 = 0 ;
12988 char *kwnames[] = {
12989 (char *) "self", NULL
12990 };
12991
12992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12994 if (SWIG_arg_fail(1)) SWIG_fail;
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12998
12999 wxPyEndAllowThreads(__tstate);
13000 if (PyErr_Occurred()) SWIG_fail;
13001 }
13002 {
13003 resultobj = SWIG_From_int((int)(result));
13004 }
13005 return resultobj;
13006 fail:
13007 return NULL;
13008 }
13009
13010
13011 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13012 PyObject *resultobj;
13013 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13014 int result;
13015 PyObject * obj0 = 0 ;
13016 char *kwnames[] = {
13017 (char *) "self", NULL
13018 };
13019
13020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13022 if (SWIG_arg_fail(1)) SWIG_fail;
13023 {
13024 PyThreadState* __tstate = wxPyBeginAllowThreads();
13025 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13026
13027 wxPyEndAllowThreads(__tstate);
13028 if (PyErr_Occurred()) SWIG_fail;
13029 }
13030 {
13031 resultobj = SWIG_From_int((int)(result));
13032 }
13033 return resultobj;
13034 fail:
13035 return NULL;
13036 }
13037
13038
13039 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13040 PyObject *resultobj;
13041 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13042 int result;
13043 PyObject * obj0 = 0 ;
13044 char *kwnames[] = {
13045 (char *) "self", NULL
13046 };
13047
13048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13050 if (SWIG_arg_fail(1)) SWIG_fail;
13051 {
13052 PyThreadState* __tstate = wxPyBeginAllowThreads();
13053 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13054
13055 wxPyEndAllowThreads(__tstate);
13056 if (PyErr_Occurred()) SWIG_fail;
13057 }
13058 {
13059 resultobj = SWIG_From_int((int)(result));
13060 }
13061 return resultobj;
13062 fail:
13063 return NULL;
13064 }
13065
13066
13067 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj;
13069 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13070 int result;
13071 PyObject * obj0 = 0 ;
13072 char *kwnames[] = {
13073 (char *) "self", NULL
13074 };
13075
13076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
13081 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13082
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 {
13087 resultobj = SWIG_From_int((int)(result));
13088 }
13089 return resultobj;
13090 fail:
13091 return NULL;
13092 }
13093
13094
13095 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13096 PyObject *resultobj;
13097 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13098 int arg2 ;
13099 PyObject * obj0 = 0 ;
13100 PyObject * obj1 = 0 ;
13101 char *kwnames[] = {
13102 (char *) "self",(char *) "stick", NULL
13103 };
13104
13105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13107 if (SWIG_arg_fail(1)) SWIG_fail;
13108 {
13109 arg2 = (int)(SWIG_As_int(obj1));
13110 if (SWIG_arg_fail(2)) SWIG_fail;
13111 }
13112 {
13113 PyThreadState* __tstate = wxPyBeginAllowThreads();
13114 (arg1)->SetJoystick(arg2);
13115
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 Py_INCREF(Py_None); resultobj = Py_None;
13120 return resultobj;
13121 fail:
13122 return NULL;
13123 }
13124
13125
13126 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13127 PyObject *resultobj;
13128 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13129 int arg2 ;
13130 PyObject * obj0 = 0 ;
13131 PyObject * obj1 = 0 ;
13132 char *kwnames[] = {
13133 (char *) "self",(char *) "state", NULL
13134 };
13135
13136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13138 if (SWIG_arg_fail(1)) SWIG_fail;
13139 {
13140 arg2 = (int)(SWIG_As_int(obj1));
13141 if (SWIG_arg_fail(2)) SWIG_fail;
13142 }
13143 {
13144 PyThreadState* __tstate = wxPyBeginAllowThreads();
13145 (arg1)->SetButtonState(arg2);
13146
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 Py_INCREF(Py_None); resultobj = Py_None;
13151 return resultobj;
13152 fail:
13153 return NULL;
13154 }
13155
13156
13157 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13158 PyObject *resultobj;
13159 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13160 int arg2 ;
13161 PyObject * obj0 = 0 ;
13162 PyObject * obj1 = 0 ;
13163 char *kwnames[] = {
13164 (char *) "self",(char *) "change", NULL
13165 };
13166
13167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13169 if (SWIG_arg_fail(1)) SWIG_fail;
13170 {
13171 arg2 = (int)(SWIG_As_int(obj1));
13172 if (SWIG_arg_fail(2)) SWIG_fail;
13173 }
13174 {
13175 PyThreadState* __tstate = wxPyBeginAllowThreads();
13176 (arg1)->SetButtonChange(arg2);
13177
13178 wxPyEndAllowThreads(__tstate);
13179 if (PyErr_Occurred()) SWIG_fail;
13180 }
13181 Py_INCREF(Py_None); resultobj = Py_None;
13182 return resultobj;
13183 fail:
13184 return NULL;
13185 }
13186
13187
13188 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13189 PyObject *resultobj;
13190 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13191 wxPoint *arg2 = 0 ;
13192 wxPoint temp2 ;
13193 PyObject * obj0 = 0 ;
13194 PyObject * obj1 = 0 ;
13195 char *kwnames[] = {
13196 (char *) "self",(char *) "pos", NULL
13197 };
13198
13199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13201 if (SWIG_arg_fail(1)) SWIG_fail;
13202 {
13203 arg2 = &temp2;
13204 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13205 }
13206 {
13207 PyThreadState* __tstate = wxPyBeginAllowThreads();
13208 (arg1)->SetPosition((wxPoint const &)*arg2);
13209
13210 wxPyEndAllowThreads(__tstate);
13211 if (PyErr_Occurred()) SWIG_fail;
13212 }
13213 Py_INCREF(Py_None); resultobj = Py_None;
13214 return resultobj;
13215 fail:
13216 return NULL;
13217 }
13218
13219
13220 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13221 PyObject *resultobj;
13222 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13223 int arg2 ;
13224 PyObject * obj0 = 0 ;
13225 PyObject * obj1 = 0 ;
13226 char *kwnames[] = {
13227 (char *) "self",(char *) "zPos", NULL
13228 };
13229
13230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13232 if (SWIG_arg_fail(1)) SWIG_fail;
13233 {
13234 arg2 = (int)(SWIG_As_int(obj1));
13235 if (SWIG_arg_fail(2)) SWIG_fail;
13236 }
13237 {
13238 PyThreadState* __tstate = wxPyBeginAllowThreads();
13239 (arg1)->SetZPosition(arg2);
13240
13241 wxPyEndAllowThreads(__tstate);
13242 if (PyErr_Occurred()) SWIG_fail;
13243 }
13244 Py_INCREF(Py_None); resultobj = Py_None;
13245 return resultobj;
13246 fail:
13247 return NULL;
13248 }
13249
13250
13251 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj;
13253 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13254 bool result;
13255 PyObject * obj0 = 0 ;
13256 char *kwnames[] = {
13257 (char *) "self", NULL
13258 };
13259
13260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13262 if (SWIG_arg_fail(1)) SWIG_fail;
13263 {
13264 PyThreadState* __tstate = wxPyBeginAllowThreads();
13265 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13266
13267 wxPyEndAllowThreads(__tstate);
13268 if (PyErr_Occurred()) SWIG_fail;
13269 }
13270 {
13271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13272 }
13273 return resultobj;
13274 fail:
13275 return NULL;
13276 }
13277
13278
13279 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13280 PyObject *resultobj;
13281 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13282 bool result;
13283 PyObject * obj0 = 0 ;
13284 char *kwnames[] = {
13285 (char *) "self", NULL
13286 };
13287
13288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13290 if (SWIG_arg_fail(1)) SWIG_fail;
13291 {
13292 PyThreadState* __tstate = wxPyBeginAllowThreads();
13293 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13294
13295 wxPyEndAllowThreads(__tstate);
13296 if (PyErr_Occurred()) SWIG_fail;
13297 }
13298 {
13299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13300 }
13301 return resultobj;
13302 fail:
13303 return NULL;
13304 }
13305
13306
13307 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13308 PyObject *resultobj;
13309 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13310 bool result;
13311 PyObject * obj0 = 0 ;
13312 char *kwnames[] = {
13313 (char *) "self", NULL
13314 };
13315
13316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13318 if (SWIG_arg_fail(1)) SWIG_fail;
13319 {
13320 PyThreadState* __tstate = wxPyBeginAllowThreads();
13321 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13322
13323 wxPyEndAllowThreads(__tstate);
13324 if (PyErr_Occurred()) SWIG_fail;
13325 }
13326 {
13327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13328 }
13329 return resultobj;
13330 fail:
13331 return NULL;
13332 }
13333
13334
13335 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13336 PyObject *resultobj;
13337 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13338 int arg2 = (int) wxJOY_BUTTON_ANY ;
13339 bool result;
13340 PyObject * obj0 = 0 ;
13341 PyObject * obj1 = 0 ;
13342 char *kwnames[] = {
13343 (char *) "self",(char *) "but", NULL
13344 };
13345
13346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13348 if (SWIG_arg_fail(1)) SWIG_fail;
13349 if (obj1) {
13350 {
13351 arg2 = (int)(SWIG_As_int(obj1));
13352 if (SWIG_arg_fail(2)) SWIG_fail;
13353 }
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13358
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 {
13363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13364 }
13365 return resultobj;
13366 fail:
13367 return NULL;
13368 }
13369
13370
13371 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13372 PyObject *resultobj;
13373 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13374 int arg2 = (int) wxJOY_BUTTON_ANY ;
13375 bool result;
13376 PyObject * obj0 = 0 ;
13377 PyObject * obj1 = 0 ;
13378 char *kwnames[] = {
13379 (char *) "self",(char *) "but", NULL
13380 };
13381
13382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13384 if (SWIG_arg_fail(1)) SWIG_fail;
13385 if (obj1) {
13386 {
13387 arg2 = (int)(SWIG_As_int(obj1));
13388 if (SWIG_arg_fail(2)) SWIG_fail;
13389 }
13390 }
13391 {
13392 PyThreadState* __tstate = wxPyBeginAllowThreads();
13393 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13394
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 {
13399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13400 }
13401 return resultobj;
13402 fail:
13403 return NULL;
13404 }
13405
13406
13407 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13408 PyObject *resultobj;
13409 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13410 int arg2 = (int) wxJOY_BUTTON_ANY ;
13411 bool result;
13412 PyObject * obj0 = 0 ;
13413 PyObject * obj1 = 0 ;
13414 char *kwnames[] = {
13415 (char *) "self",(char *) "but", NULL
13416 };
13417
13418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13420 if (SWIG_arg_fail(1)) SWIG_fail;
13421 if (obj1) {
13422 {
13423 arg2 = (int)(SWIG_As_int(obj1));
13424 if (SWIG_arg_fail(2)) SWIG_fail;
13425 }
13426 }
13427 {
13428 PyThreadState* __tstate = wxPyBeginAllowThreads();
13429 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13430
13431 wxPyEndAllowThreads(__tstate);
13432 if (PyErr_Occurred()) SWIG_fail;
13433 }
13434 {
13435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13436 }
13437 return resultobj;
13438 fail:
13439 return NULL;
13440 }
13441
13442
13443 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13444 PyObject *obj;
13445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13446 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13447 Py_INCREF(obj);
13448 return Py_BuildValue((char *)"");
13449 }
13450 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj;
13452 wxString const &arg1_defvalue = wxPyEmptyString ;
13453 wxString *arg1 = (wxString *) &arg1_defvalue ;
13454 wxSound *result;
13455 bool temp1 = false ;
13456 PyObject * obj0 = 0 ;
13457 char *kwnames[] = {
13458 (char *) "fileName", NULL
13459 };
13460
13461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13462 if (obj0) {
13463 {
13464 arg1 = wxString_in_helper(obj0);
13465 if (arg1 == NULL) SWIG_fail;
13466 temp1 = true;
13467 }
13468 }
13469 {
13470 if (!wxPyCheckForApp()) SWIG_fail;
13471 PyThreadState* __tstate = wxPyBeginAllowThreads();
13472 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13473
13474 wxPyEndAllowThreads(__tstate);
13475 if (PyErr_Occurred()) SWIG_fail;
13476 }
13477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13478 {
13479 if (temp1)
13480 delete arg1;
13481 }
13482 return resultobj;
13483 fail:
13484 {
13485 if (temp1)
13486 delete arg1;
13487 }
13488 return NULL;
13489 }
13490
13491
13492 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13493 PyObject *resultobj;
13494 PyObject *arg1 = (PyObject *) 0 ;
13495 wxSound *result;
13496 PyObject * obj0 = 0 ;
13497 char *kwnames[] = {
13498 (char *) "data", NULL
13499 };
13500
13501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13502 arg1 = obj0;
13503 {
13504 if (!wxPyCheckForApp()) SWIG_fail;
13505 PyThreadState* __tstate = wxPyBeginAllowThreads();
13506 result = (wxSound *)new_wxSound(arg1);
13507
13508 wxPyEndAllowThreads(__tstate);
13509 if (PyErr_Occurred()) SWIG_fail;
13510 }
13511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13512 return resultobj;
13513 fail:
13514 return NULL;
13515 }
13516
13517
13518 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13519 PyObject *resultobj;
13520 wxSound *arg1 = (wxSound *) 0 ;
13521 PyObject * obj0 = 0 ;
13522 char *kwnames[] = {
13523 (char *) "self", NULL
13524 };
13525
13526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13528 if (SWIG_arg_fail(1)) SWIG_fail;
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 delete arg1;
13532
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 Py_INCREF(Py_None); resultobj = Py_None;
13537 return resultobj;
13538 fail:
13539 return NULL;
13540 }
13541
13542
13543 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13544 PyObject *resultobj;
13545 wxSound *arg1 = (wxSound *) 0 ;
13546 wxString *arg2 = 0 ;
13547 bool result;
13548 bool temp2 = false ;
13549 PyObject * obj0 = 0 ;
13550 PyObject * obj1 = 0 ;
13551 char *kwnames[] = {
13552 (char *) "self",(char *) "fileName", NULL
13553 };
13554
13555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13557 if (SWIG_arg_fail(1)) SWIG_fail;
13558 {
13559 arg2 = wxString_in_helper(obj1);
13560 if (arg2 == NULL) SWIG_fail;
13561 temp2 = true;
13562 }
13563 {
13564 PyThreadState* __tstate = wxPyBeginAllowThreads();
13565 result = (bool)(arg1)->Create((wxString const &)*arg2);
13566
13567 wxPyEndAllowThreads(__tstate);
13568 if (PyErr_Occurred()) SWIG_fail;
13569 }
13570 {
13571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13572 }
13573 {
13574 if (temp2)
13575 delete arg2;
13576 }
13577 return resultobj;
13578 fail:
13579 {
13580 if (temp2)
13581 delete arg2;
13582 }
13583 return NULL;
13584 }
13585
13586
13587 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13588 PyObject *resultobj;
13589 wxSound *arg1 = (wxSound *) 0 ;
13590 PyObject *arg2 = (PyObject *) 0 ;
13591 bool result;
13592 PyObject * obj0 = 0 ;
13593 PyObject * obj1 = 0 ;
13594 char *kwnames[] = {
13595 (char *) "self",(char *) "data", NULL
13596 };
13597
13598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13600 if (SWIG_arg_fail(1)) SWIG_fail;
13601 arg2 = obj1;
13602 {
13603 PyThreadState* __tstate = wxPyBeginAllowThreads();
13604 result = (bool)wxSound_CreateFromData(arg1,arg2);
13605
13606 wxPyEndAllowThreads(__tstate);
13607 if (PyErr_Occurred()) SWIG_fail;
13608 }
13609 {
13610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13611 }
13612 return resultobj;
13613 fail:
13614 return NULL;
13615 }
13616
13617
13618 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj;
13620 wxSound *arg1 = (wxSound *) 0 ;
13621 bool result;
13622 PyObject * obj0 = 0 ;
13623 char *kwnames[] = {
13624 (char *) "self", NULL
13625 };
13626
13627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13629 if (SWIG_arg_fail(1)) SWIG_fail;
13630 {
13631 PyThreadState* __tstate = wxPyBeginAllowThreads();
13632 result = (bool)(arg1)->IsOk();
13633
13634 wxPyEndAllowThreads(__tstate);
13635 if (PyErr_Occurred()) SWIG_fail;
13636 }
13637 {
13638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13639 }
13640 return resultobj;
13641 fail:
13642 return NULL;
13643 }
13644
13645
13646 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13647 PyObject *resultobj;
13648 wxSound *arg1 = (wxSound *) 0 ;
13649 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13650 bool result;
13651 PyObject * obj0 = 0 ;
13652 PyObject * obj1 = 0 ;
13653 char *kwnames[] = {
13654 (char *) "self",(char *) "flags", NULL
13655 };
13656
13657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13659 if (SWIG_arg_fail(1)) SWIG_fail;
13660 if (obj1) {
13661 {
13662 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13663 if (SWIG_arg_fail(2)) SWIG_fail;
13664 }
13665 }
13666 {
13667 if (!wxPyCheckForApp()) SWIG_fail;
13668 PyThreadState* __tstate = wxPyBeginAllowThreads();
13669 result = (bool)((wxSound const *)arg1)->Play(arg2);
13670
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 {
13675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13676 }
13677 return resultobj;
13678 fail:
13679 return NULL;
13680 }
13681
13682
13683 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13684 PyObject *resultobj;
13685 wxString *arg1 = 0 ;
13686 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13687 bool result;
13688 bool temp1 = false ;
13689 PyObject * obj0 = 0 ;
13690 PyObject * obj1 = 0 ;
13691 char *kwnames[] = {
13692 (char *) "filename",(char *) "flags", NULL
13693 };
13694
13695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13696 {
13697 arg1 = wxString_in_helper(obj0);
13698 if (arg1 == NULL) SWIG_fail;
13699 temp1 = true;
13700 }
13701 if (obj1) {
13702 {
13703 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13704 if (SWIG_arg_fail(2)) SWIG_fail;
13705 }
13706 }
13707 {
13708 if (!wxPyCheckForApp()) SWIG_fail;
13709 PyThreadState* __tstate = wxPyBeginAllowThreads();
13710 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13711
13712 wxPyEndAllowThreads(__tstate);
13713 if (PyErr_Occurred()) SWIG_fail;
13714 }
13715 {
13716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13717 }
13718 {
13719 if (temp1)
13720 delete arg1;
13721 }
13722 return resultobj;
13723 fail:
13724 {
13725 if (temp1)
13726 delete arg1;
13727 }
13728 return NULL;
13729 }
13730
13731
13732 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13733 PyObject *resultobj;
13734 char *kwnames[] = {
13735 NULL
13736 };
13737
13738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13739 {
13740 if (!wxPyCheckForApp()) SWIG_fail;
13741 PyThreadState* __tstate = wxPyBeginAllowThreads();
13742 wxSound::Stop();
13743
13744 wxPyEndAllowThreads(__tstate);
13745 if (PyErr_Occurred()) SWIG_fail;
13746 }
13747 Py_INCREF(Py_None); resultobj = Py_None;
13748 return resultobj;
13749 fail:
13750 return NULL;
13751 }
13752
13753
13754 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13755 PyObject *obj;
13756 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13757 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13758 Py_INCREF(obj);
13759 return Py_BuildValue((char *)"");
13760 }
13761 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13762 PyObject *resultobj;
13763 wxString *arg1 = 0 ;
13764 wxString *arg2 = 0 ;
13765 wxString *arg3 = 0 ;
13766 wxString *arg4 = 0 ;
13767 wxFileTypeInfo *result;
13768 bool temp1 = false ;
13769 bool temp2 = false ;
13770 bool temp3 = false ;
13771 bool temp4 = false ;
13772 PyObject * obj0 = 0 ;
13773 PyObject * obj1 = 0 ;
13774 PyObject * obj2 = 0 ;
13775 PyObject * obj3 = 0 ;
13776 char *kwnames[] = {
13777 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13778 };
13779
13780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13781 {
13782 arg1 = wxString_in_helper(obj0);
13783 if (arg1 == NULL) SWIG_fail;
13784 temp1 = true;
13785 }
13786 {
13787 arg2 = wxString_in_helper(obj1);
13788 if (arg2 == NULL) SWIG_fail;
13789 temp2 = true;
13790 }
13791 {
13792 arg3 = wxString_in_helper(obj2);
13793 if (arg3 == NULL) SWIG_fail;
13794 temp3 = true;
13795 }
13796 {
13797 arg4 = wxString_in_helper(obj3);
13798 if (arg4 == NULL) SWIG_fail;
13799 temp4 = true;
13800 }
13801 {
13802 PyThreadState* __tstate = wxPyBeginAllowThreads();
13803 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13804
13805 wxPyEndAllowThreads(__tstate);
13806 if (PyErr_Occurred()) SWIG_fail;
13807 }
13808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13809 {
13810 if (temp1)
13811 delete arg1;
13812 }
13813 {
13814 if (temp2)
13815 delete arg2;
13816 }
13817 {
13818 if (temp3)
13819 delete arg3;
13820 }
13821 {
13822 if (temp4)
13823 delete arg4;
13824 }
13825 return resultobj;
13826 fail:
13827 {
13828 if (temp1)
13829 delete arg1;
13830 }
13831 {
13832 if (temp2)
13833 delete arg2;
13834 }
13835 {
13836 if (temp3)
13837 delete arg3;
13838 }
13839 {
13840 if (temp4)
13841 delete arg4;
13842 }
13843 return NULL;
13844 }
13845
13846
13847 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13848 PyObject *resultobj;
13849 wxArrayString *arg1 = 0 ;
13850 wxFileTypeInfo *result;
13851 bool temp1 = false ;
13852 PyObject * obj0 = 0 ;
13853 char *kwnames[] = {
13854 (char *) "sArray", NULL
13855 };
13856
13857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13858 {
13859 if (! PySequence_Check(obj0)) {
13860 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13861 SWIG_fail;
13862 }
13863 arg1 = new wxArrayString;
13864 temp1 = true;
13865 int i, len=PySequence_Length(obj0);
13866 for (i=0; i<len; i++) {
13867 PyObject* item = PySequence_GetItem(obj0, i);
13868 wxString* s = wxString_in_helper(item);
13869 if (PyErr_Occurred()) SWIG_fail;
13870 arg1->Add(*s);
13871 delete s;
13872 Py_DECREF(item);
13873 }
13874 }
13875 {
13876 PyThreadState* __tstate = wxPyBeginAllowThreads();
13877 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13878
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13883 {
13884 if (temp1) delete arg1;
13885 }
13886 return resultobj;
13887 fail:
13888 {
13889 if (temp1) delete arg1;
13890 }
13891 return NULL;
13892 }
13893
13894
13895 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13896 PyObject *resultobj;
13897 wxFileTypeInfo *result;
13898 char *kwnames[] = {
13899 NULL
13900 };
13901
13902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13903 {
13904 PyThreadState* __tstate = wxPyBeginAllowThreads();
13905 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13906
13907 wxPyEndAllowThreads(__tstate);
13908 if (PyErr_Occurred()) SWIG_fail;
13909 }
13910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13911 return resultobj;
13912 fail:
13913 return NULL;
13914 }
13915
13916
13917 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13918 PyObject *resultobj;
13919 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13920 bool result;
13921 PyObject * obj0 = 0 ;
13922 char *kwnames[] = {
13923 (char *) "self", NULL
13924 };
13925
13926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13928 if (SWIG_arg_fail(1)) SWIG_fail;
13929 {
13930 PyThreadState* __tstate = wxPyBeginAllowThreads();
13931 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13932
13933 wxPyEndAllowThreads(__tstate);
13934 if (PyErr_Occurred()) SWIG_fail;
13935 }
13936 {
13937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13938 }
13939 return resultobj;
13940 fail:
13941 return NULL;
13942 }
13943
13944
13945 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13946 PyObject *resultobj;
13947 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13948 wxString *arg2 = 0 ;
13949 int arg3 = (int) 0 ;
13950 bool temp2 = false ;
13951 PyObject * obj0 = 0 ;
13952 PyObject * obj1 = 0 ;
13953 PyObject * obj2 = 0 ;
13954 char *kwnames[] = {
13955 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13956 };
13957
13958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13960 if (SWIG_arg_fail(1)) SWIG_fail;
13961 {
13962 arg2 = wxString_in_helper(obj1);
13963 if (arg2 == NULL) SWIG_fail;
13964 temp2 = true;
13965 }
13966 if (obj2) {
13967 {
13968 arg3 = (int)(SWIG_As_int(obj2));
13969 if (SWIG_arg_fail(3)) SWIG_fail;
13970 }
13971 }
13972 {
13973 PyThreadState* __tstate = wxPyBeginAllowThreads();
13974 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13975
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 Py_INCREF(Py_None); resultobj = Py_None;
13980 {
13981 if (temp2)
13982 delete arg2;
13983 }
13984 return resultobj;
13985 fail:
13986 {
13987 if (temp2)
13988 delete arg2;
13989 }
13990 return NULL;
13991 }
13992
13993
13994 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13995 PyObject *resultobj;
13996 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13997 wxString *arg2 = 0 ;
13998 bool temp2 = false ;
13999 PyObject * obj0 = 0 ;
14000 PyObject * obj1 = 0 ;
14001 char *kwnames[] = {
14002 (char *) "self",(char *) "shortDesc", NULL
14003 };
14004
14005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14007 if (SWIG_arg_fail(1)) SWIG_fail;
14008 {
14009 arg2 = wxString_in_helper(obj1);
14010 if (arg2 == NULL) SWIG_fail;
14011 temp2 = true;
14012 }
14013 {
14014 PyThreadState* __tstate = wxPyBeginAllowThreads();
14015 (arg1)->SetShortDesc((wxString const &)*arg2);
14016
14017 wxPyEndAllowThreads(__tstate);
14018 if (PyErr_Occurred()) SWIG_fail;
14019 }
14020 Py_INCREF(Py_None); resultobj = Py_None;
14021 {
14022 if (temp2)
14023 delete arg2;
14024 }
14025 return resultobj;
14026 fail:
14027 {
14028 if (temp2)
14029 delete arg2;
14030 }
14031 return NULL;
14032 }
14033
14034
14035 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14036 PyObject *resultobj;
14037 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14038 wxString *result;
14039 PyObject * obj0 = 0 ;
14040 char *kwnames[] = {
14041 (char *) "self", NULL
14042 };
14043
14044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14046 if (SWIG_arg_fail(1)) SWIG_fail;
14047 {
14048 PyThreadState* __tstate = wxPyBeginAllowThreads();
14049 {
14050 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14051 result = (wxString *) &_result_ref;
14052 }
14053
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 {
14058 #if wxUSE_UNICODE
14059 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14060 #else
14061 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14062 #endif
14063 }
14064 return resultobj;
14065 fail:
14066 return NULL;
14067 }
14068
14069
14070 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14071 PyObject *resultobj;
14072 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14073 wxString *result;
14074 PyObject * obj0 = 0 ;
14075 char *kwnames[] = {
14076 (char *) "self", NULL
14077 };
14078
14079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14081 if (SWIG_arg_fail(1)) SWIG_fail;
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 {
14085 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14086 result = (wxString *) &_result_ref;
14087 }
14088
14089 wxPyEndAllowThreads(__tstate);
14090 if (PyErr_Occurred()) SWIG_fail;
14091 }
14092 {
14093 #if wxUSE_UNICODE
14094 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14095 #else
14096 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14097 #endif
14098 }
14099 return resultobj;
14100 fail:
14101 return NULL;
14102 }
14103
14104
14105 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14106 PyObject *resultobj;
14107 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14108 wxString *result;
14109 PyObject * obj0 = 0 ;
14110 char *kwnames[] = {
14111 (char *) "self", NULL
14112 };
14113
14114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14116 if (SWIG_arg_fail(1)) SWIG_fail;
14117 {
14118 PyThreadState* __tstate = wxPyBeginAllowThreads();
14119 {
14120 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14121 result = (wxString *) &_result_ref;
14122 }
14123
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 {
14128 #if wxUSE_UNICODE
14129 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14130 #else
14131 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14132 #endif
14133 }
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14141 PyObject *resultobj;
14142 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14143 wxString *result;
14144 PyObject * obj0 = 0 ;
14145 char *kwnames[] = {
14146 (char *) "self", NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14151 if (SWIG_arg_fail(1)) SWIG_fail;
14152 {
14153 PyThreadState* __tstate = wxPyBeginAllowThreads();
14154 {
14155 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14156 result = (wxString *) &_result_ref;
14157 }
14158
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 {
14163 #if wxUSE_UNICODE
14164 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14165 #else
14166 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14167 #endif
14168 }
14169 return resultobj;
14170 fail:
14171 return NULL;
14172 }
14173
14174
14175 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14176 PyObject *resultobj;
14177 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14178 wxString *result;
14179 PyObject * obj0 = 0 ;
14180 char *kwnames[] = {
14181 (char *) "self", NULL
14182 };
14183
14184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14186 if (SWIG_arg_fail(1)) SWIG_fail;
14187 {
14188 PyThreadState* __tstate = wxPyBeginAllowThreads();
14189 {
14190 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14191 result = (wxString *) &_result_ref;
14192 }
14193
14194 wxPyEndAllowThreads(__tstate);
14195 if (PyErr_Occurred()) SWIG_fail;
14196 }
14197 {
14198 #if wxUSE_UNICODE
14199 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14200 #else
14201 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14202 #endif
14203 }
14204 return resultobj;
14205 fail:
14206 return NULL;
14207 }
14208
14209
14210 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14211 PyObject *resultobj;
14212 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14213 wxArrayString *result;
14214 PyObject * obj0 = 0 ;
14215 char *kwnames[] = {
14216 (char *) "self", NULL
14217 };
14218
14219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14221 if (SWIG_arg_fail(1)) SWIG_fail;
14222 {
14223 PyThreadState* __tstate = wxPyBeginAllowThreads();
14224 {
14225 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14226 result = (wxArrayString *) &_result_ref;
14227 }
14228
14229 wxPyEndAllowThreads(__tstate);
14230 if (PyErr_Occurred()) SWIG_fail;
14231 }
14232 {
14233 resultobj = wxArrayString2PyList_helper(*result);
14234 }
14235 return resultobj;
14236 fail:
14237 return NULL;
14238 }
14239
14240
14241 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14242 PyObject *resultobj;
14243 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14244 int result;
14245 PyObject * obj0 = 0 ;
14246 char *kwnames[] = {
14247 (char *) "self", NULL
14248 };
14249
14250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14252 if (SWIG_arg_fail(1)) SWIG_fail;
14253 {
14254 PyThreadState* __tstate = wxPyBeginAllowThreads();
14255 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14256
14257 wxPyEndAllowThreads(__tstate);
14258 if (PyErr_Occurred()) SWIG_fail;
14259 }
14260 {
14261 resultobj = SWIG_From_int((int)(result));
14262 }
14263 return resultobj;
14264 fail:
14265 return NULL;
14266 }
14267
14268
14269 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14270 PyObject *resultobj;
14271 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14272 wxString *result;
14273 PyObject * obj0 = 0 ;
14274 char *kwnames[] = {
14275 (char *) "self", NULL
14276 };
14277
14278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14280 if (SWIG_arg_fail(1)) SWIG_fail;
14281 {
14282 PyThreadState* __tstate = wxPyBeginAllowThreads();
14283 {
14284 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14285 result = (wxString *) &_result_ref;
14286 }
14287
14288 wxPyEndAllowThreads(__tstate);
14289 if (PyErr_Occurred()) SWIG_fail;
14290 }
14291 {
14292 #if wxUSE_UNICODE
14293 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14294 #else
14295 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14296 #endif
14297 }
14298 return resultobj;
14299 fail:
14300 return NULL;
14301 }
14302
14303
14304 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14305 PyObject *resultobj;
14306 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14307 int result;
14308 PyObject * obj0 = 0 ;
14309 char *kwnames[] = {
14310 (char *) "self", NULL
14311 };
14312
14313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14315 if (SWIG_arg_fail(1)) SWIG_fail;
14316 {
14317 PyThreadState* __tstate = wxPyBeginAllowThreads();
14318 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14319
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 {
14324 resultobj = SWIG_From_int((int)(result));
14325 }
14326 return resultobj;
14327 fail:
14328 return NULL;
14329 }
14330
14331
14332 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14333 PyObject *obj;
14334 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14335 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14336 Py_INCREF(obj);
14337 return Py_BuildValue((char *)"");
14338 }
14339 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14340 PyObject *resultobj;
14341 wxFileTypeInfo *arg1 = 0 ;
14342 wxFileType *result;
14343 PyObject * obj0 = 0 ;
14344 char *kwnames[] = {
14345 (char *) "ftInfo", NULL
14346 };
14347
14348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14349 {
14350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14351 if (SWIG_arg_fail(1)) SWIG_fail;
14352 if (arg1 == NULL) {
14353 SWIG_null_ref("wxFileTypeInfo");
14354 }
14355 if (SWIG_arg_fail(1)) SWIG_fail;
14356 }
14357 {
14358 PyThreadState* __tstate = wxPyBeginAllowThreads();
14359 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14360
14361 wxPyEndAllowThreads(__tstate);
14362 if (PyErr_Occurred()) SWIG_fail;
14363 }
14364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14365 return resultobj;
14366 fail:
14367 return NULL;
14368 }
14369
14370
14371 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14372 PyObject *resultobj;
14373 wxFileType *arg1 = (wxFileType *) 0 ;
14374 PyObject * obj0 = 0 ;
14375 char *kwnames[] = {
14376 (char *) "self", NULL
14377 };
14378
14379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14381 if (SWIG_arg_fail(1)) SWIG_fail;
14382 {
14383 PyThreadState* __tstate = wxPyBeginAllowThreads();
14384 delete arg1;
14385
14386 wxPyEndAllowThreads(__tstate);
14387 if (PyErr_Occurred()) SWIG_fail;
14388 }
14389 Py_INCREF(Py_None); resultobj = Py_None;
14390 return resultobj;
14391 fail:
14392 return NULL;
14393 }
14394
14395
14396 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14397 PyObject *resultobj;
14398 wxFileType *arg1 = (wxFileType *) 0 ;
14399 PyObject *result;
14400 PyObject * obj0 = 0 ;
14401 char *kwnames[] = {
14402 (char *) "self", NULL
14403 };
14404
14405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14407 if (SWIG_arg_fail(1)) SWIG_fail;
14408 {
14409 PyThreadState* __tstate = wxPyBeginAllowThreads();
14410 result = (PyObject *)wxFileType_GetMimeType(arg1);
14411
14412 wxPyEndAllowThreads(__tstate);
14413 if (PyErr_Occurred()) SWIG_fail;
14414 }
14415 resultobj = result;
14416 return resultobj;
14417 fail:
14418 return NULL;
14419 }
14420
14421
14422 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14423 PyObject *resultobj;
14424 wxFileType *arg1 = (wxFileType *) 0 ;
14425 PyObject *result;
14426 PyObject * obj0 = 0 ;
14427 char *kwnames[] = {
14428 (char *) "self", NULL
14429 };
14430
14431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14433 if (SWIG_arg_fail(1)) SWIG_fail;
14434 {
14435 PyThreadState* __tstate = wxPyBeginAllowThreads();
14436 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14437
14438 wxPyEndAllowThreads(__tstate);
14439 if (PyErr_Occurred()) SWIG_fail;
14440 }
14441 resultobj = result;
14442 return resultobj;
14443 fail:
14444 return NULL;
14445 }
14446
14447
14448 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14449 PyObject *resultobj;
14450 wxFileType *arg1 = (wxFileType *) 0 ;
14451 PyObject *result;
14452 PyObject * obj0 = 0 ;
14453 char *kwnames[] = {
14454 (char *) "self", NULL
14455 };
14456
14457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14459 if (SWIG_arg_fail(1)) SWIG_fail;
14460 {
14461 PyThreadState* __tstate = wxPyBeginAllowThreads();
14462 result = (PyObject *)wxFileType_GetExtensions(arg1);
14463
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 resultobj = result;
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj;
14476 wxFileType *arg1 = (wxFileType *) 0 ;
14477 wxIcon *result;
14478 PyObject * obj0 = 0 ;
14479 char *kwnames[] = {
14480 (char *) "self", NULL
14481 };
14482
14483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14485 if (SWIG_arg_fail(1)) SWIG_fail;
14486 {
14487 PyThreadState* __tstate = wxPyBeginAllowThreads();
14488 result = (wxIcon *)wxFileType_GetIcon(arg1);
14489
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14494 return resultobj;
14495 fail:
14496 return NULL;
14497 }
14498
14499
14500 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14501 PyObject *resultobj;
14502 wxFileType *arg1 = (wxFileType *) 0 ;
14503 PyObject *result;
14504 PyObject * obj0 = 0 ;
14505 char *kwnames[] = {
14506 (char *) "self", NULL
14507 };
14508
14509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14511 if (SWIG_arg_fail(1)) SWIG_fail;
14512 {
14513 PyThreadState* __tstate = wxPyBeginAllowThreads();
14514 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14515
14516 wxPyEndAllowThreads(__tstate);
14517 if (PyErr_Occurred()) SWIG_fail;
14518 }
14519 resultobj = result;
14520 return resultobj;
14521 fail:
14522 return NULL;
14523 }
14524
14525
14526 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14527 PyObject *resultobj;
14528 wxFileType *arg1 = (wxFileType *) 0 ;
14529 PyObject *result;
14530 PyObject * obj0 = 0 ;
14531 char *kwnames[] = {
14532 (char *) "self", NULL
14533 };
14534
14535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14537 if (SWIG_arg_fail(1)) SWIG_fail;
14538 {
14539 PyThreadState* __tstate = wxPyBeginAllowThreads();
14540 result = (PyObject *)wxFileType_GetDescription(arg1);
14541
14542 wxPyEndAllowThreads(__tstate);
14543 if (PyErr_Occurred()) SWIG_fail;
14544 }
14545 resultobj = result;
14546 return resultobj;
14547 fail:
14548 return NULL;
14549 }
14550
14551
14552 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14553 PyObject *resultobj;
14554 wxFileType *arg1 = (wxFileType *) 0 ;
14555 wxString *arg2 = 0 ;
14556 wxString const &arg3_defvalue = wxPyEmptyString ;
14557 wxString *arg3 = (wxString *) &arg3_defvalue ;
14558 PyObject *result;
14559 bool temp2 = false ;
14560 bool temp3 = false ;
14561 PyObject * obj0 = 0 ;
14562 PyObject * obj1 = 0 ;
14563 PyObject * obj2 = 0 ;
14564 char *kwnames[] = {
14565 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14566 };
14567
14568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14570 if (SWIG_arg_fail(1)) SWIG_fail;
14571 {
14572 arg2 = wxString_in_helper(obj1);
14573 if (arg2 == NULL) SWIG_fail;
14574 temp2 = true;
14575 }
14576 if (obj2) {
14577 {
14578 arg3 = wxString_in_helper(obj2);
14579 if (arg3 == NULL) SWIG_fail;
14580 temp3 = true;
14581 }
14582 }
14583 {
14584 PyThreadState* __tstate = wxPyBeginAllowThreads();
14585 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14586
14587 wxPyEndAllowThreads(__tstate);
14588 if (PyErr_Occurred()) SWIG_fail;
14589 }
14590 resultobj = result;
14591 {
14592 if (temp2)
14593 delete arg2;
14594 }
14595 {
14596 if (temp3)
14597 delete arg3;
14598 }
14599 return resultobj;
14600 fail:
14601 {
14602 if (temp2)
14603 delete arg2;
14604 }
14605 {
14606 if (temp3)
14607 delete arg3;
14608 }
14609 return NULL;
14610 }
14611
14612
14613 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14614 PyObject *resultobj;
14615 wxFileType *arg1 = (wxFileType *) 0 ;
14616 wxString *arg2 = 0 ;
14617 wxString const &arg3_defvalue = wxPyEmptyString ;
14618 wxString *arg3 = (wxString *) &arg3_defvalue ;
14619 PyObject *result;
14620 bool temp2 = false ;
14621 bool temp3 = false ;
14622 PyObject * obj0 = 0 ;
14623 PyObject * obj1 = 0 ;
14624 PyObject * obj2 = 0 ;
14625 char *kwnames[] = {
14626 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14627 };
14628
14629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14631 if (SWIG_arg_fail(1)) SWIG_fail;
14632 {
14633 arg2 = wxString_in_helper(obj1);
14634 if (arg2 == NULL) SWIG_fail;
14635 temp2 = true;
14636 }
14637 if (obj2) {
14638 {
14639 arg3 = wxString_in_helper(obj2);
14640 if (arg3 == NULL) SWIG_fail;
14641 temp3 = true;
14642 }
14643 }
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14647
14648 wxPyEndAllowThreads(__tstate);
14649 if (PyErr_Occurred()) SWIG_fail;
14650 }
14651 resultobj = result;
14652 {
14653 if (temp2)
14654 delete arg2;
14655 }
14656 {
14657 if (temp3)
14658 delete arg3;
14659 }
14660 return resultobj;
14661 fail:
14662 {
14663 if (temp2)
14664 delete arg2;
14665 }
14666 {
14667 if (temp3)
14668 delete arg3;
14669 }
14670 return NULL;
14671 }
14672
14673
14674 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14675 PyObject *resultobj;
14676 wxFileType *arg1 = (wxFileType *) 0 ;
14677 wxString *arg2 = 0 ;
14678 wxString const &arg3_defvalue = wxPyEmptyString ;
14679 wxString *arg3 = (wxString *) &arg3_defvalue ;
14680 PyObject *result;
14681 bool temp2 = false ;
14682 bool temp3 = false ;
14683 PyObject * obj0 = 0 ;
14684 PyObject * obj1 = 0 ;
14685 PyObject * obj2 = 0 ;
14686 char *kwnames[] = {
14687 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14688 };
14689
14690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14692 if (SWIG_arg_fail(1)) SWIG_fail;
14693 {
14694 arg2 = wxString_in_helper(obj1);
14695 if (arg2 == NULL) SWIG_fail;
14696 temp2 = true;
14697 }
14698 if (obj2) {
14699 {
14700 arg3 = wxString_in_helper(obj2);
14701 if (arg3 == NULL) SWIG_fail;
14702 temp3 = true;
14703 }
14704 }
14705 {
14706 PyThreadState* __tstate = wxPyBeginAllowThreads();
14707 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14708
14709 wxPyEndAllowThreads(__tstate);
14710 if (PyErr_Occurred()) SWIG_fail;
14711 }
14712 resultobj = result;
14713 {
14714 if (temp2)
14715 delete arg2;
14716 }
14717 {
14718 if (temp3)
14719 delete arg3;
14720 }
14721 return resultobj;
14722 fail:
14723 {
14724 if (temp2)
14725 delete arg2;
14726 }
14727 {
14728 if (temp3)
14729 delete arg3;
14730 }
14731 return NULL;
14732 }
14733
14734
14735 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14736 PyObject *resultobj;
14737 wxFileType *arg1 = (wxFileType *) 0 ;
14738 wxString *arg2 = 0 ;
14739 wxString *arg3 = 0 ;
14740 bool arg4 = (bool) true ;
14741 bool result;
14742 bool temp2 = false ;
14743 bool temp3 = false ;
14744 PyObject * obj0 = 0 ;
14745 PyObject * obj1 = 0 ;
14746 PyObject * obj2 = 0 ;
14747 PyObject * obj3 = 0 ;
14748 char *kwnames[] = {
14749 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14750 };
14751
14752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14754 if (SWIG_arg_fail(1)) SWIG_fail;
14755 {
14756 arg2 = wxString_in_helper(obj1);
14757 if (arg2 == NULL) SWIG_fail;
14758 temp2 = true;
14759 }
14760 {
14761 arg3 = wxString_in_helper(obj2);
14762 if (arg3 == NULL) SWIG_fail;
14763 temp3 = true;
14764 }
14765 if (obj3) {
14766 {
14767 arg4 = (bool)(SWIG_As_bool(obj3));
14768 if (SWIG_arg_fail(4)) SWIG_fail;
14769 }
14770 }
14771 {
14772 PyThreadState* __tstate = wxPyBeginAllowThreads();
14773 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14774
14775 wxPyEndAllowThreads(__tstate);
14776 if (PyErr_Occurred()) SWIG_fail;
14777 }
14778 {
14779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14780 }
14781 {
14782 if (temp2)
14783 delete arg2;
14784 }
14785 {
14786 if (temp3)
14787 delete arg3;
14788 }
14789 return resultobj;
14790 fail:
14791 {
14792 if (temp2)
14793 delete arg2;
14794 }
14795 {
14796 if (temp3)
14797 delete arg3;
14798 }
14799 return NULL;
14800 }
14801
14802
14803 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14804 PyObject *resultobj;
14805 wxFileType *arg1 = (wxFileType *) 0 ;
14806 wxString const &arg2_defvalue = wxPyEmptyString ;
14807 wxString *arg2 = (wxString *) &arg2_defvalue ;
14808 int arg3 = (int) 0 ;
14809 bool result;
14810 bool temp2 = false ;
14811 PyObject * obj0 = 0 ;
14812 PyObject * obj1 = 0 ;
14813 PyObject * obj2 = 0 ;
14814 char *kwnames[] = {
14815 (char *) "self",(char *) "cmd",(char *) "index", NULL
14816 };
14817
14818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14820 if (SWIG_arg_fail(1)) SWIG_fail;
14821 if (obj1) {
14822 {
14823 arg2 = wxString_in_helper(obj1);
14824 if (arg2 == NULL) SWIG_fail;
14825 temp2 = true;
14826 }
14827 }
14828 if (obj2) {
14829 {
14830 arg3 = (int)(SWIG_As_int(obj2));
14831 if (SWIG_arg_fail(3)) SWIG_fail;
14832 }
14833 }
14834 {
14835 PyThreadState* __tstate = wxPyBeginAllowThreads();
14836 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14837
14838 wxPyEndAllowThreads(__tstate);
14839 if (PyErr_Occurred()) SWIG_fail;
14840 }
14841 {
14842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14843 }
14844 {
14845 if (temp2)
14846 delete arg2;
14847 }
14848 return resultobj;
14849 fail:
14850 {
14851 if (temp2)
14852 delete arg2;
14853 }
14854 return NULL;
14855 }
14856
14857
14858 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14859 PyObject *resultobj;
14860 wxFileType *arg1 = (wxFileType *) 0 ;
14861 bool result;
14862 PyObject * obj0 = 0 ;
14863 char *kwnames[] = {
14864 (char *) "self", NULL
14865 };
14866
14867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14869 if (SWIG_arg_fail(1)) SWIG_fail;
14870 {
14871 PyThreadState* __tstate = wxPyBeginAllowThreads();
14872 result = (bool)(arg1)->Unassociate();
14873
14874 wxPyEndAllowThreads(__tstate);
14875 if (PyErr_Occurred()) SWIG_fail;
14876 }
14877 {
14878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14879 }
14880 return resultobj;
14881 fail:
14882 return NULL;
14883 }
14884
14885
14886 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14887 PyObject *resultobj;
14888 wxString *arg1 = 0 ;
14889 wxString *arg2 = 0 ;
14890 wxString const &arg3_defvalue = wxPyEmptyString ;
14891 wxString *arg3 = (wxString *) &arg3_defvalue ;
14892 wxString result;
14893 bool temp1 = false ;
14894 bool temp2 = false ;
14895 bool temp3 = false ;
14896 PyObject * obj0 = 0 ;
14897 PyObject * obj1 = 0 ;
14898 PyObject * obj2 = 0 ;
14899 char *kwnames[] = {
14900 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14901 };
14902
14903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14904 {
14905 arg1 = wxString_in_helper(obj0);
14906 if (arg1 == NULL) SWIG_fail;
14907 temp1 = true;
14908 }
14909 {
14910 arg2 = wxString_in_helper(obj1);
14911 if (arg2 == NULL) SWIG_fail;
14912 temp2 = true;
14913 }
14914 if (obj2) {
14915 {
14916 arg3 = wxString_in_helper(obj2);
14917 if (arg3 == NULL) SWIG_fail;
14918 temp3 = true;
14919 }
14920 }
14921 {
14922 PyThreadState* __tstate = wxPyBeginAllowThreads();
14923 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14924
14925 wxPyEndAllowThreads(__tstate);
14926 if (PyErr_Occurred()) SWIG_fail;
14927 }
14928 {
14929 #if wxUSE_UNICODE
14930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14931 #else
14932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14933 #endif
14934 }
14935 {
14936 if (temp1)
14937 delete arg1;
14938 }
14939 {
14940 if (temp2)
14941 delete arg2;
14942 }
14943 {
14944 if (temp3)
14945 delete arg3;
14946 }
14947 return resultobj;
14948 fail:
14949 {
14950 if (temp1)
14951 delete arg1;
14952 }
14953 {
14954 if (temp2)
14955 delete arg2;
14956 }
14957 {
14958 if (temp3)
14959 delete arg3;
14960 }
14961 return NULL;
14962 }
14963
14964
14965 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14966 PyObject *obj;
14967 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14968 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14969 Py_INCREF(obj);
14970 return Py_BuildValue((char *)"");
14971 }
14972 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14973 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14974 return 1;
14975 }
14976
14977
14978 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14979 PyObject *pyobj;
14980
14981 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14982 return pyobj;
14983 }
14984
14985
14986 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14987 PyObject *resultobj;
14988 wxString *arg1 = 0 ;
14989 wxString *arg2 = 0 ;
14990 bool result;
14991 bool temp1 = false ;
14992 bool temp2 = false ;
14993 PyObject * obj0 = 0 ;
14994 PyObject * obj1 = 0 ;
14995 char *kwnames[] = {
14996 (char *) "mimeType",(char *) "wildcard", NULL
14997 };
14998
14999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15000 {
15001 arg1 = wxString_in_helper(obj0);
15002 if (arg1 == NULL) SWIG_fail;
15003 temp1 = true;
15004 }
15005 {
15006 arg2 = wxString_in_helper(obj1);
15007 if (arg2 == NULL) SWIG_fail;
15008 temp2 = true;
15009 }
15010 {
15011 PyThreadState* __tstate = wxPyBeginAllowThreads();
15012 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15013
15014 wxPyEndAllowThreads(__tstate);
15015 if (PyErr_Occurred()) SWIG_fail;
15016 }
15017 {
15018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15019 }
15020 {
15021 if (temp1)
15022 delete arg1;
15023 }
15024 {
15025 if (temp2)
15026 delete arg2;
15027 }
15028 return resultobj;
15029 fail:
15030 {
15031 if (temp1)
15032 delete arg1;
15033 }
15034 {
15035 if (temp2)
15036 delete arg2;
15037 }
15038 return NULL;
15039 }
15040
15041
15042 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15043 PyObject *resultobj;
15044 wxMimeTypesManager *result;
15045 char *kwnames[] = {
15046 NULL
15047 };
15048
15049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15050 {
15051 PyThreadState* __tstate = wxPyBeginAllowThreads();
15052 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15053
15054 wxPyEndAllowThreads(__tstate);
15055 if (PyErr_Occurred()) SWIG_fail;
15056 }
15057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15058 return resultobj;
15059 fail:
15060 return NULL;
15061 }
15062
15063
15064 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj;
15066 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15067 int arg2 = (int) wxMAILCAP_ALL ;
15068 wxString const &arg3_defvalue = wxPyEmptyString ;
15069 wxString *arg3 = (wxString *) &arg3_defvalue ;
15070 bool temp3 = false ;
15071 PyObject * obj0 = 0 ;
15072 PyObject * obj1 = 0 ;
15073 PyObject * obj2 = 0 ;
15074 char *kwnames[] = {
15075 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15076 };
15077
15078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15080 if (SWIG_arg_fail(1)) SWIG_fail;
15081 if (obj1) {
15082 {
15083 arg2 = (int)(SWIG_As_int(obj1));
15084 if (SWIG_arg_fail(2)) SWIG_fail;
15085 }
15086 }
15087 if (obj2) {
15088 {
15089 arg3 = wxString_in_helper(obj2);
15090 if (arg3 == NULL) SWIG_fail;
15091 temp3 = true;
15092 }
15093 }
15094 {
15095 PyThreadState* __tstate = wxPyBeginAllowThreads();
15096 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15097
15098 wxPyEndAllowThreads(__tstate);
15099 if (PyErr_Occurred()) SWIG_fail;
15100 }
15101 Py_INCREF(Py_None); resultobj = Py_None;
15102 {
15103 if (temp3)
15104 delete arg3;
15105 }
15106 return resultobj;
15107 fail:
15108 {
15109 if (temp3)
15110 delete arg3;
15111 }
15112 return NULL;
15113 }
15114
15115
15116 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15117 PyObject *resultobj;
15118 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15119 PyObject * obj0 = 0 ;
15120 char *kwnames[] = {
15121 (char *) "self", NULL
15122 };
15123
15124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15126 if (SWIG_arg_fail(1)) SWIG_fail;
15127 {
15128 PyThreadState* __tstate = wxPyBeginAllowThreads();
15129 (arg1)->ClearData();
15130
15131 wxPyEndAllowThreads(__tstate);
15132 if (PyErr_Occurred()) SWIG_fail;
15133 }
15134 Py_INCREF(Py_None); resultobj = Py_None;
15135 return resultobj;
15136 fail:
15137 return NULL;
15138 }
15139
15140
15141 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15142 PyObject *resultobj;
15143 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15144 wxString *arg2 = 0 ;
15145 wxFileType *result;
15146 bool temp2 = false ;
15147 PyObject * obj0 = 0 ;
15148 PyObject * obj1 = 0 ;
15149 char *kwnames[] = {
15150 (char *) "self",(char *) "ext", NULL
15151 };
15152
15153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15155 if (SWIG_arg_fail(1)) SWIG_fail;
15156 {
15157 arg2 = wxString_in_helper(obj1);
15158 if (arg2 == NULL) SWIG_fail;
15159 temp2 = true;
15160 }
15161 {
15162 PyThreadState* __tstate = wxPyBeginAllowThreads();
15163 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15164
15165 wxPyEndAllowThreads(__tstate);
15166 if (PyErr_Occurred()) SWIG_fail;
15167 }
15168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15169 {
15170 if (temp2)
15171 delete arg2;
15172 }
15173 return resultobj;
15174 fail:
15175 {
15176 if (temp2)
15177 delete arg2;
15178 }
15179 return NULL;
15180 }
15181
15182
15183 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15184 PyObject *resultobj;
15185 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15186 wxString *arg2 = 0 ;
15187 wxFileType *result;
15188 bool temp2 = false ;
15189 PyObject * obj0 = 0 ;
15190 PyObject * obj1 = 0 ;
15191 char *kwnames[] = {
15192 (char *) "self",(char *) "mimeType", NULL
15193 };
15194
15195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15197 if (SWIG_arg_fail(1)) SWIG_fail;
15198 {
15199 arg2 = wxString_in_helper(obj1);
15200 if (arg2 == NULL) SWIG_fail;
15201 temp2 = true;
15202 }
15203 {
15204 PyThreadState* __tstate = wxPyBeginAllowThreads();
15205 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15206
15207 wxPyEndAllowThreads(__tstate);
15208 if (PyErr_Occurred()) SWIG_fail;
15209 }
15210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15211 {
15212 if (temp2)
15213 delete arg2;
15214 }
15215 return resultobj;
15216 fail:
15217 {
15218 if (temp2)
15219 delete arg2;
15220 }
15221 return NULL;
15222 }
15223
15224
15225 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15226 PyObject *resultobj;
15227 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15228 wxString *arg2 = 0 ;
15229 bool arg3 = (bool) false ;
15230 bool result;
15231 bool temp2 = false ;
15232 PyObject * obj0 = 0 ;
15233 PyObject * obj1 = 0 ;
15234 PyObject * obj2 = 0 ;
15235 char *kwnames[] = {
15236 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15237 };
15238
15239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15241 if (SWIG_arg_fail(1)) SWIG_fail;
15242 {
15243 arg2 = wxString_in_helper(obj1);
15244 if (arg2 == NULL) SWIG_fail;
15245 temp2 = true;
15246 }
15247 if (obj2) {
15248 {
15249 arg3 = (bool)(SWIG_As_bool(obj2));
15250 if (SWIG_arg_fail(3)) SWIG_fail;
15251 }
15252 }
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15256
15257 wxPyEndAllowThreads(__tstate);
15258 if (PyErr_Occurred()) SWIG_fail;
15259 }
15260 {
15261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15262 }
15263 {
15264 if (temp2)
15265 delete arg2;
15266 }
15267 return resultobj;
15268 fail:
15269 {
15270 if (temp2)
15271 delete arg2;
15272 }
15273 return NULL;
15274 }
15275
15276
15277 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15278 PyObject *resultobj;
15279 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15280 wxString *arg2 = 0 ;
15281 bool result;
15282 bool temp2 = false ;
15283 PyObject * obj0 = 0 ;
15284 PyObject * obj1 = 0 ;
15285 char *kwnames[] = {
15286 (char *) "self",(char *) "filename", NULL
15287 };
15288
15289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15291 if (SWIG_arg_fail(1)) SWIG_fail;
15292 {
15293 arg2 = wxString_in_helper(obj1);
15294 if (arg2 == NULL) SWIG_fail;
15295 temp2 = true;
15296 }
15297 {
15298 PyThreadState* __tstate = wxPyBeginAllowThreads();
15299 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15300
15301 wxPyEndAllowThreads(__tstate);
15302 if (PyErr_Occurred()) SWIG_fail;
15303 }
15304 {
15305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15306 }
15307 {
15308 if (temp2)
15309 delete arg2;
15310 }
15311 return resultobj;
15312 fail:
15313 {
15314 if (temp2)
15315 delete arg2;
15316 }
15317 return NULL;
15318 }
15319
15320
15321 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15322 PyObject *resultobj;
15323 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15324 PyObject *result;
15325 PyObject * obj0 = 0 ;
15326 char *kwnames[] = {
15327 (char *) "self", NULL
15328 };
15329
15330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15332 if (SWIG_arg_fail(1)) SWIG_fail;
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15336
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 resultobj = result;
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15348 PyObject *resultobj;
15349 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15350 wxFileTypeInfo *arg2 = 0 ;
15351 PyObject * obj0 = 0 ;
15352 PyObject * obj1 = 0 ;
15353 char *kwnames[] = {
15354 (char *) "self",(char *) "ft", NULL
15355 };
15356
15357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15359 if (SWIG_arg_fail(1)) SWIG_fail;
15360 {
15361 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15362 if (SWIG_arg_fail(2)) SWIG_fail;
15363 if (arg2 == NULL) {
15364 SWIG_null_ref("wxFileTypeInfo");
15365 }
15366 if (SWIG_arg_fail(2)) SWIG_fail;
15367 }
15368 {
15369 PyThreadState* __tstate = wxPyBeginAllowThreads();
15370 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15371
15372 wxPyEndAllowThreads(__tstate);
15373 if (PyErr_Occurred()) SWIG_fail;
15374 }
15375 Py_INCREF(Py_None); resultobj = Py_None;
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15383 PyObject *resultobj;
15384 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15385 wxFileTypeInfo *arg2 = 0 ;
15386 wxFileType *result;
15387 PyObject * obj0 = 0 ;
15388 PyObject * obj1 = 0 ;
15389 char *kwnames[] = {
15390 (char *) "self",(char *) "ftInfo", NULL
15391 };
15392
15393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15395 if (SWIG_arg_fail(1)) SWIG_fail;
15396 {
15397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15398 if (SWIG_arg_fail(2)) SWIG_fail;
15399 if (arg2 == NULL) {
15400 SWIG_null_ref("wxFileTypeInfo");
15401 }
15402 if (SWIG_arg_fail(2)) SWIG_fail;
15403 }
15404 {
15405 PyThreadState* __tstate = wxPyBeginAllowThreads();
15406 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15407
15408 wxPyEndAllowThreads(__tstate);
15409 if (PyErr_Occurred()) SWIG_fail;
15410 }
15411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15412 return resultobj;
15413 fail:
15414 return NULL;
15415 }
15416
15417
15418 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15419 PyObject *resultobj;
15420 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15421 wxFileType *arg2 = (wxFileType *) 0 ;
15422 bool result;
15423 PyObject * obj0 = 0 ;
15424 PyObject * obj1 = 0 ;
15425 char *kwnames[] = {
15426 (char *) "self",(char *) "ft", NULL
15427 };
15428
15429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15431 if (SWIG_arg_fail(1)) SWIG_fail;
15432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15433 if (SWIG_arg_fail(2)) SWIG_fail;
15434 {
15435 PyThreadState* __tstate = wxPyBeginAllowThreads();
15436 result = (bool)(arg1)->Unassociate(arg2);
15437
15438 wxPyEndAllowThreads(__tstate);
15439 if (PyErr_Occurred()) SWIG_fail;
15440 }
15441 {
15442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15443 }
15444 return resultobj;
15445 fail:
15446 return NULL;
15447 }
15448
15449
15450 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15451 PyObject *resultobj;
15452 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15453 PyObject * obj0 = 0 ;
15454 char *kwnames[] = {
15455 (char *) "self", NULL
15456 };
15457
15458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15460 if (SWIG_arg_fail(1)) SWIG_fail;
15461 {
15462 PyThreadState* __tstate = wxPyBeginAllowThreads();
15463 delete arg1;
15464
15465 wxPyEndAllowThreads(__tstate);
15466 if (PyErr_Occurred()) SWIG_fail;
15467 }
15468 Py_INCREF(Py_None); resultobj = Py_None;
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15476 PyObject *obj;
15477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15478 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15479 Py_INCREF(obj);
15480 return Py_BuildValue((char *)"");
15481 }
15482 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15483 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15484 return 1;
15485 }
15486
15487
15488 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15489 PyObject *pyobj;
15490
15491 {
15492 #if wxUSE_UNICODE
15493 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15494 #else
15495 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15496 #endif
15497 }
15498 return pyobj;
15499 }
15500
15501
15502 static int _wrap_ART_MENU_set(PyObject *) {
15503 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15504 return 1;
15505 }
15506
15507
15508 static PyObject *_wrap_ART_MENU_get(void) {
15509 PyObject *pyobj;
15510
15511 {
15512 #if wxUSE_UNICODE
15513 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15514 #else
15515 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15516 #endif
15517 }
15518 return pyobj;
15519 }
15520
15521
15522 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15523 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15524 return 1;
15525 }
15526
15527
15528 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15529 PyObject *pyobj;
15530
15531 {
15532 #if wxUSE_UNICODE
15533 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15534 #else
15535 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15536 #endif
15537 }
15538 return pyobj;
15539 }
15540
15541
15542 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15543 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15544 return 1;
15545 }
15546
15547
15548 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15549 PyObject *pyobj;
15550
15551 {
15552 #if wxUSE_UNICODE
15553 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15554 #else
15555 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15556 #endif
15557 }
15558 return pyobj;
15559 }
15560
15561
15562 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15563 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15564 return 1;
15565 }
15566
15567
15568 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15569 PyObject *pyobj;
15570
15571 {
15572 #if wxUSE_UNICODE
15573 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15574 #else
15575 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15576 #endif
15577 }
15578 return pyobj;
15579 }
15580
15581
15582 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15583 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15584 return 1;
15585 }
15586
15587
15588 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15589 PyObject *pyobj;
15590
15591 {
15592 #if wxUSE_UNICODE
15593 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15594 #else
15595 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15596 #endif
15597 }
15598 return pyobj;
15599 }
15600
15601
15602 static int _wrap_ART_BUTTON_set(PyObject *) {
15603 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15604 return 1;
15605 }
15606
15607
15608 static PyObject *_wrap_ART_BUTTON_get(void) {
15609 PyObject *pyobj;
15610
15611 {
15612 #if wxUSE_UNICODE
15613 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15614 #else
15615 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15616 #endif
15617 }
15618 return pyobj;
15619 }
15620
15621
15622 static int _wrap_ART_OTHER_set(PyObject *) {
15623 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15624 return 1;
15625 }
15626
15627
15628 static PyObject *_wrap_ART_OTHER_get(void) {
15629 PyObject *pyobj;
15630
15631 {
15632 #if wxUSE_UNICODE
15633 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15634 #else
15635 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15636 #endif
15637 }
15638 return pyobj;
15639 }
15640
15641
15642 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15643 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15644 return 1;
15645 }
15646
15647
15648 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15649 PyObject *pyobj;
15650
15651 {
15652 #if wxUSE_UNICODE
15653 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15654 #else
15655 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15656 #endif
15657 }
15658 return pyobj;
15659 }
15660
15661
15662 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15663 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15664 return 1;
15665 }
15666
15667
15668 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15669 PyObject *pyobj;
15670
15671 {
15672 #if wxUSE_UNICODE
15673 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15674 #else
15675 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15676 #endif
15677 }
15678 return pyobj;
15679 }
15680
15681
15682 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15683 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15684 return 1;
15685 }
15686
15687
15688 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15689 PyObject *pyobj;
15690
15691 {
15692 #if wxUSE_UNICODE
15693 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15694 #else
15695 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15696 #endif
15697 }
15698 return pyobj;
15699 }
15700
15701
15702 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15703 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15704 return 1;
15705 }
15706
15707
15708 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15709 PyObject *pyobj;
15710
15711 {
15712 #if wxUSE_UNICODE
15713 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15714 #else
15715 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15716 #endif
15717 }
15718 return pyobj;
15719 }
15720
15721
15722 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15723 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15724 return 1;
15725 }
15726
15727
15728 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15729 PyObject *pyobj;
15730
15731 {
15732 #if wxUSE_UNICODE
15733 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15734 #else
15735 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15736 #endif
15737 }
15738 return pyobj;
15739 }
15740
15741
15742 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15743 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15744 return 1;
15745 }
15746
15747
15748 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15749 PyObject *pyobj;
15750
15751 {
15752 #if wxUSE_UNICODE
15753 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15754 #else
15755 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15756 #endif
15757 }
15758 return pyobj;
15759 }
15760
15761
15762 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15763 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15764 return 1;
15765 }
15766
15767
15768 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15769 PyObject *pyobj;
15770
15771 {
15772 #if wxUSE_UNICODE
15773 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15774 #else
15775 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15776 #endif
15777 }
15778 return pyobj;
15779 }
15780
15781
15782 static int _wrap_ART_GO_BACK_set(PyObject *) {
15783 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15784 return 1;
15785 }
15786
15787
15788 static PyObject *_wrap_ART_GO_BACK_get(void) {
15789 PyObject *pyobj;
15790
15791 {
15792 #if wxUSE_UNICODE
15793 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15794 #else
15795 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15796 #endif
15797 }
15798 return pyobj;
15799 }
15800
15801
15802 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15803 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15804 return 1;
15805 }
15806
15807
15808 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15809 PyObject *pyobj;
15810
15811 {
15812 #if wxUSE_UNICODE
15813 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15814 #else
15815 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15816 #endif
15817 }
15818 return pyobj;
15819 }
15820
15821
15822 static int _wrap_ART_GO_UP_set(PyObject *) {
15823 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15824 return 1;
15825 }
15826
15827
15828 static PyObject *_wrap_ART_GO_UP_get(void) {
15829 PyObject *pyobj;
15830
15831 {
15832 #if wxUSE_UNICODE
15833 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15834 #else
15835 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15836 #endif
15837 }
15838 return pyobj;
15839 }
15840
15841
15842 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15843 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15844 return 1;
15845 }
15846
15847
15848 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15849 PyObject *pyobj;
15850
15851 {
15852 #if wxUSE_UNICODE
15853 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15854 #else
15855 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15856 #endif
15857 }
15858 return pyobj;
15859 }
15860
15861
15862 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15863 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15864 return 1;
15865 }
15866
15867
15868 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15869 PyObject *pyobj;
15870
15871 {
15872 #if wxUSE_UNICODE
15873 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15874 #else
15875 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15876 #endif
15877 }
15878 return pyobj;
15879 }
15880
15881
15882 static int _wrap_ART_GO_HOME_set(PyObject *) {
15883 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15884 return 1;
15885 }
15886
15887
15888 static PyObject *_wrap_ART_GO_HOME_get(void) {
15889 PyObject *pyobj;
15890
15891 {
15892 #if wxUSE_UNICODE
15893 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15894 #else
15895 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15896 #endif
15897 }
15898 return pyobj;
15899 }
15900
15901
15902 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15903 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15904 return 1;
15905 }
15906
15907
15908 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15909 PyObject *pyobj;
15910
15911 {
15912 #if wxUSE_UNICODE
15913 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15914 #else
15915 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15916 #endif
15917 }
15918 return pyobj;
15919 }
15920
15921
15922 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15923 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15924 return 1;
15925 }
15926
15927
15928 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15929 PyObject *pyobj;
15930
15931 {
15932 #if wxUSE_UNICODE
15933 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15934 #else
15935 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15936 #endif
15937 }
15938 return pyobj;
15939 }
15940
15941
15942 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15943 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15944 return 1;
15945 }
15946
15947
15948 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15949 PyObject *pyobj;
15950
15951 {
15952 #if wxUSE_UNICODE
15953 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15954 #else
15955 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15956 #endif
15957 }
15958 return pyobj;
15959 }
15960
15961
15962 static int _wrap_ART_PRINT_set(PyObject *) {
15963 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15964 return 1;
15965 }
15966
15967
15968 static PyObject *_wrap_ART_PRINT_get(void) {
15969 PyObject *pyobj;
15970
15971 {
15972 #if wxUSE_UNICODE
15973 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15974 #else
15975 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15976 #endif
15977 }
15978 return pyobj;
15979 }
15980
15981
15982 static int _wrap_ART_HELP_set(PyObject *) {
15983 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15984 return 1;
15985 }
15986
15987
15988 static PyObject *_wrap_ART_HELP_get(void) {
15989 PyObject *pyobj;
15990
15991 {
15992 #if wxUSE_UNICODE
15993 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15994 #else
15995 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15996 #endif
15997 }
15998 return pyobj;
15999 }
16000
16001
16002 static int _wrap_ART_TIP_set(PyObject *) {
16003 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16004 return 1;
16005 }
16006
16007
16008 static PyObject *_wrap_ART_TIP_get(void) {
16009 PyObject *pyobj;
16010
16011 {
16012 #if wxUSE_UNICODE
16013 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16014 #else
16015 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16016 #endif
16017 }
16018 return pyobj;
16019 }
16020
16021
16022 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16023 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16024 return 1;
16025 }
16026
16027
16028 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16029 PyObject *pyobj;
16030
16031 {
16032 #if wxUSE_UNICODE
16033 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16034 #else
16035 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16036 #endif
16037 }
16038 return pyobj;
16039 }
16040
16041
16042 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16043 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16044 return 1;
16045 }
16046
16047
16048 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16049 PyObject *pyobj;
16050
16051 {
16052 #if wxUSE_UNICODE
16053 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16054 #else
16055 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16056 #endif
16057 }
16058 return pyobj;
16059 }
16060
16061
16062 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16063 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16064 return 1;
16065 }
16066
16067
16068 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16069 PyObject *pyobj;
16070
16071 {
16072 #if wxUSE_UNICODE
16073 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16074 #else
16075 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16076 #endif
16077 }
16078 return pyobj;
16079 }
16080
16081
16082 static int _wrap_ART_HARDDISK_set(PyObject *) {
16083 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16084 return 1;
16085 }
16086
16087
16088 static PyObject *_wrap_ART_HARDDISK_get(void) {
16089 PyObject *pyobj;
16090
16091 {
16092 #if wxUSE_UNICODE
16093 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16094 #else
16095 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16096 #endif
16097 }
16098 return pyobj;
16099 }
16100
16101
16102 static int _wrap_ART_FLOPPY_set(PyObject *) {
16103 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16104 return 1;
16105 }
16106
16107
16108 static PyObject *_wrap_ART_FLOPPY_get(void) {
16109 PyObject *pyobj;
16110
16111 {
16112 #if wxUSE_UNICODE
16113 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16114 #else
16115 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16116 #endif
16117 }
16118 return pyobj;
16119 }
16120
16121
16122 static int _wrap_ART_CDROM_set(PyObject *) {
16123 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16124 return 1;
16125 }
16126
16127
16128 static PyObject *_wrap_ART_CDROM_get(void) {
16129 PyObject *pyobj;
16130
16131 {
16132 #if wxUSE_UNICODE
16133 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16134 #else
16135 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16136 #endif
16137 }
16138 return pyobj;
16139 }
16140
16141
16142 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16143 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16144 return 1;
16145 }
16146
16147
16148 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16149 PyObject *pyobj;
16150
16151 {
16152 #if wxUSE_UNICODE
16153 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16154 #else
16155 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16156 #endif
16157 }
16158 return pyobj;
16159 }
16160
16161
16162 static int _wrap_ART_FOLDER_set(PyObject *) {
16163 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16164 return 1;
16165 }
16166
16167
16168 static PyObject *_wrap_ART_FOLDER_get(void) {
16169 PyObject *pyobj;
16170
16171 {
16172 #if wxUSE_UNICODE
16173 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16174 #else
16175 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16176 #endif
16177 }
16178 return pyobj;
16179 }
16180
16181
16182 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16183 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16184 return 1;
16185 }
16186
16187
16188 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16189 PyObject *pyobj;
16190
16191 {
16192 #if wxUSE_UNICODE
16193 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16194 #else
16195 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16196 #endif
16197 }
16198 return pyobj;
16199 }
16200
16201
16202 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16203 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16204 return 1;
16205 }
16206
16207
16208 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16209 PyObject *pyobj;
16210
16211 {
16212 #if wxUSE_UNICODE
16213 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16214 #else
16215 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16216 #endif
16217 }
16218 return pyobj;
16219 }
16220
16221
16222 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16223 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16224 return 1;
16225 }
16226
16227
16228 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16229 PyObject *pyobj;
16230
16231 {
16232 #if wxUSE_UNICODE
16233 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16234 #else
16235 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16236 #endif
16237 }
16238 return pyobj;
16239 }
16240
16241
16242 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16243 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16244 return 1;
16245 }
16246
16247
16248 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16249 PyObject *pyobj;
16250
16251 {
16252 #if wxUSE_UNICODE
16253 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16254 #else
16255 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16256 #endif
16257 }
16258 return pyobj;
16259 }
16260
16261
16262 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16263 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16264 return 1;
16265 }
16266
16267
16268 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16269 PyObject *pyobj;
16270
16271 {
16272 #if wxUSE_UNICODE
16273 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16274 #else
16275 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16276 #endif
16277 }
16278 return pyobj;
16279 }
16280
16281
16282 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16283 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16284 return 1;
16285 }
16286
16287
16288 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16289 PyObject *pyobj;
16290
16291 {
16292 #if wxUSE_UNICODE
16293 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16294 #else
16295 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16296 #endif
16297 }
16298 return pyobj;
16299 }
16300
16301
16302 static int _wrap_ART_ERROR_set(PyObject *) {
16303 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16304 return 1;
16305 }
16306
16307
16308 static PyObject *_wrap_ART_ERROR_get(void) {
16309 PyObject *pyobj;
16310
16311 {
16312 #if wxUSE_UNICODE
16313 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16314 #else
16315 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16316 #endif
16317 }
16318 return pyobj;
16319 }
16320
16321
16322 static int _wrap_ART_QUESTION_set(PyObject *) {
16323 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16324 return 1;
16325 }
16326
16327
16328 static PyObject *_wrap_ART_QUESTION_get(void) {
16329 PyObject *pyobj;
16330
16331 {
16332 #if wxUSE_UNICODE
16333 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16334 #else
16335 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16336 #endif
16337 }
16338 return pyobj;
16339 }
16340
16341
16342 static int _wrap_ART_WARNING_set(PyObject *) {
16343 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16344 return 1;
16345 }
16346
16347
16348 static PyObject *_wrap_ART_WARNING_get(void) {
16349 PyObject *pyobj;
16350
16351 {
16352 #if wxUSE_UNICODE
16353 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16354 #else
16355 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16356 #endif
16357 }
16358 return pyobj;
16359 }
16360
16361
16362 static int _wrap_ART_INFORMATION_set(PyObject *) {
16363 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16364 return 1;
16365 }
16366
16367
16368 static PyObject *_wrap_ART_INFORMATION_get(void) {
16369 PyObject *pyobj;
16370
16371 {
16372 #if wxUSE_UNICODE
16373 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16374 #else
16375 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16376 #endif
16377 }
16378 return pyobj;
16379 }
16380
16381
16382 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16383 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16384 return 1;
16385 }
16386
16387
16388 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16389 PyObject *pyobj;
16390
16391 {
16392 #if wxUSE_UNICODE
16393 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16394 #else
16395 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16396 #endif
16397 }
16398 return pyobj;
16399 }
16400
16401
16402 static int _wrap_ART_COPY_set(PyObject *) {
16403 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16404 return 1;
16405 }
16406
16407
16408 static PyObject *_wrap_ART_COPY_get(void) {
16409 PyObject *pyobj;
16410
16411 {
16412 #if wxUSE_UNICODE
16413 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16414 #else
16415 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16416 #endif
16417 }
16418 return pyobj;
16419 }
16420
16421
16422 static int _wrap_ART_CUT_set(PyObject *) {
16423 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16424 return 1;
16425 }
16426
16427
16428 static PyObject *_wrap_ART_CUT_get(void) {
16429 PyObject *pyobj;
16430
16431 {
16432 #if wxUSE_UNICODE
16433 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16434 #else
16435 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16436 #endif
16437 }
16438 return pyobj;
16439 }
16440
16441
16442 static int _wrap_ART_PASTE_set(PyObject *) {
16443 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16444 return 1;
16445 }
16446
16447
16448 static PyObject *_wrap_ART_PASTE_get(void) {
16449 PyObject *pyobj;
16450
16451 {
16452 #if wxUSE_UNICODE
16453 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16454 #else
16455 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16456 #endif
16457 }
16458 return pyobj;
16459 }
16460
16461
16462 static int _wrap_ART_DELETE_set(PyObject *) {
16463 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16464 return 1;
16465 }
16466
16467
16468 static PyObject *_wrap_ART_DELETE_get(void) {
16469 PyObject *pyobj;
16470
16471 {
16472 #if wxUSE_UNICODE
16473 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16474 #else
16475 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16476 #endif
16477 }
16478 return pyobj;
16479 }
16480
16481
16482 static int _wrap_ART_UNDO_set(PyObject *) {
16483 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16484 return 1;
16485 }
16486
16487
16488 static PyObject *_wrap_ART_UNDO_get(void) {
16489 PyObject *pyobj;
16490
16491 {
16492 #if wxUSE_UNICODE
16493 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16494 #else
16495 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16496 #endif
16497 }
16498 return pyobj;
16499 }
16500
16501
16502 static int _wrap_ART_REDO_set(PyObject *) {
16503 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16504 return 1;
16505 }
16506
16507
16508 static PyObject *_wrap_ART_REDO_get(void) {
16509 PyObject *pyobj;
16510
16511 {
16512 #if wxUSE_UNICODE
16513 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16514 #else
16515 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16516 #endif
16517 }
16518 return pyobj;
16519 }
16520
16521
16522 static int _wrap_ART_QUIT_set(PyObject *) {
16523 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16524 return 1;
16525 }
16526
16527
16528 static PyObject *_wrap_ART_QUIT_get(void) {
16529 PyObject *pyobj;
16530
16531 {
16532 #if wxUSE_UNICODE
16533 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16534 #else
16535 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16536 #endif
16537 }
16538 return pyobj;
16539 }
16540
16541
16542 static int _wrap_ART_FIND_set(PyObject *) {
16543 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16544 return 1;
16545 }
16546
16547
16548 static PyObject *_wrap_ART_FIND_get(void) {
16549 PyObject *pyobj;
16550
16551 {
16552 #if wxUSE_UNICODE
16553 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16554 #else
16555 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16556 #endif
16557 }
16558 return pyobj;
16559 }
16560
16561
16562 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16563 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16564 return 1;
16565 }
16566
16567
16568 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16569 PyObject *pyobj;
16570
16571 {
16572 #if wxUSE_UNICODE
16573 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16574 #else
16575 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16576 #endif
16577 }
16578 return pyobj;
16579 }
16580
16581
16582 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16583 PyObject *resultobj;
16584 wxPyArtProvider *result;
16585 char *kwnames[] = {
16586 NULL
16587 };
16588
16589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16590 {
16591 if (!wxPyCheckForApp()) SWIG_fail;
16592 PyThreadState* __tstate = wxPyBeginAllowThreads();
16593 result = (wxPyArtProvider *)new wxPyArtProvider();
16594
16595 wxPyEndAllowThreads(__tstate);
16596 if (PyErr_Occurred()) SWIG_fail;
16597 }
16598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16599 return resultobj;
16600 fail:
16601 return NULL;
16602 }
16603
16604
16605 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16606 PyObject *resultobj;
16607 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16608 PyObject *arg2 = (PyObject *) 0 ;
16609 PyObject *arg3 = (PyObject *) 0 ;
16610 PyObject * obj0 = 0 ;
16611 PyObject * obj1 = 0 ;
16612 PyObject * obj2 = 0 ;
16613 char *kwnames[] = {
16614 (char *) "self",(char *) "self",(char *) "_class", NULL
16615 };
16616
16617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16619 if (SWIG_arg_fail(1)) SWIG_fail;
16620 arg2 = obj1;
16621 arg3 = obj2;
16622 {
16623 PyThreadState* __tstate = wxPyBeginAllowThreads();
16624 (arg1)->_setCallbackInfo(arg2,arg3);
16625
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 Py_INCREF(Py_None); resultobj = Py_None;
16630 return resultobj;
16631 fail:
16632 return NULL;
16633 }
16634
16635
16636 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16637 PyObject *resultobj;
16638 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16639 PyObject * obj0 = 0 ;
16640 char *kwnames[] = {
16641 (char *) "provider", NULL
16642 };
16643
16644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16646 if (SWIG_arg_fail(1)) SWIG_fail;
16647 {
16648 PyThreadState* __tstate = wxPyBeginAllowThreads();
16649 wxPyArtProvider::PushProvider(arg1);
16650
16651 wxPyEndAllowThreads(__tstate);
16652 if (PyErr_Occurred()) SWIG_fail;
16653 }
16654 Py_INCREF(Py_None); resultobj = Py_None;
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16662 PyObject *resultobj;
16663 bool result;
16664 char *kwnames[] = {
16665 NULL
16666 };
16667
16668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16669 {
16670 PyThreadState* __tstate = wxPyBeginAllowThreads();
16671 result = (bool)wxPyArtProvider::PopProvider();
16672
16673 wxPyEndAllowThreads(__tstate);
16674 if (PyErr_Occurred()) SWIG_fail;
16675 }
16676 {
16677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16678 }
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16686 PyObject *resultobj;
16687 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16688 bool result;
16689 PyObject * obj0 = 0 ;
16690 char *kwnames[] = {
16691 (char *) "provider", NULL
16692 };
16693
16694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16696 if (SWIG_arg_fail(1)) SWIG_fail;
16697 {
16698 PyThreadState* __tstate = wxPyBeginAllowThreads();
16699 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16700
16701 wxPyEndAllowThreads(__tstate);
16702 if (PyErr_Occurred()) SWIG_fail;
16703 }
16704 {
16705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16706 }
16707 return resultobj;
16708 fail:
16709 return NULL;
16710 }
16711
16712
16713 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16714 PyObject *resultobj;
16715 wxString *arg1 = 0 ;
16716 wxString const &arg2_defvalue = wxPyART_OTHER ;
16717 wxString *arg2 = (wxString *) &arg2_defvalue ;
16718 wxSize const &arg3_defvalue = wxDefaultSize ;
16719 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16720 wxBitmap result;
16721 bool temp1 = false ;
16722 bool temp2 = false ;
16723 wxSize temp3 ;
16724 PyObject * obj0 = 0 ;
16725 PyObject * obj1 = 0 ;
16726 PyObject * obj2 = 0 ;
16727 char *kwnames[] = {
16728 (char *) "id",(char *) "client",(char *) "size", NULL
16729 };
16730
16731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16732 {
16733 arg1 = wxString_in_helper(obj0);
16734 if (arg1 == NULL) SWIG_fail;
16735 temp1 = true;
16736 }
16737 if (obj1) {
16738 {
16739 arg2 = wxString_in_helper(obj1);
16740 if (arg2 == NULL) SWIG_fail;
16741 temp2 = true;
16742 }
16743 }
16744 if (obj2) {
16745 {
16746 arg3 = &temp3;
16747 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16748 }
16749 }
16750 {
16751 if (!wxPyCheckForApp()) SWIG_fail;
16752 PyThreadState* __tstate = wxPyBeginAllowThreads();
16753 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16754
16755 wxPyEndAllowThreads(__tstate);
16756 if (PyErr_Occurred()) SWIG_fail;
16757 }
16758 {
16759 wxBitmap * resultptr;
16760 resultptr = new wxBitmap((wxBitmap &)(result));
16761 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16762 }
16763 {
16764 if (temp1)
16765 delete arg1;
16766 }
16767 {
16768 if (temp2)
16769 delete arg2;
16770 }
16771 return resultobj;
16772 fail:
16773 {
16774 if (temp1)
16775 delete arg1;
16776 }
16777 {
16778 if (temp2)
16779 delete arg2;
16780 }
16781 return NULL;
16782 }
16783
16784
16785 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16786 PyObject *resultobj;
16787 wxString *arg1 = 0 ;
16788 wxString const &arg2_defvalue = wxPyART_OTHER ;
16789 wxString *arg2 = (wxString *) &arg2_defvalue ;
16790 wxSize const &arg3_defvalue = wxDefaultSize ;
16791 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16792 wxIcon result;
16793 bool temp1 = false ;
16794 bool temp2 = false ;
16795 wxSize temp3 ;
16796 PyObject * obj0 = 0 ;
16797 PyObject * obj1 = 0 ;
16798 PyObject * obj2 = 0 ;
16799 char *kwnames[] = {
16800 (char *) "id",(char *) "client",(char *) "size", NULL
16801 };
16802
16803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16804 {
16805 arg1 = wxString_in_helper(obj0);
16806 if (arg1 == NULL) SWIG_fail;
16807 temp1 = true;
16808 }
16809 if (obj1) {
16810 {
16811 arg2 = wxString_in_helper(obj1);
16812 if (arg2 == NULL) SWIG_fail;
16813 temp2 = true;
16814 }
16815 }
16816 if (obj2) {
16817 {
16818 arg3 = &temp3;
16819 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16820 }
16821 }
16822 {
16823 if (!wxPyCheckForApp()) SWIG_fail;
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16826
16827 wxPyEndAllowThreads(__tstate);
16828 if (PyErr_Occurred()) SWIG_fail;
16829 }
16830 {
16831 wxIcon * resultptr;
16832 resultptr = new wxIcon((wxIcon &)(result));
16833 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16834 }
16835 {
16836 if (temp1)
16837 delete arg1;
16838 }
16839 {
16840 if (temp2)
16841 delete arg2;
16842 }
16843 return resultobj;
16844 fail:
16845 {
16846 if (temp1)
16847 delete arg1;
16848 }
16849 {
16850 if (temp2)
16851 delete arg2;
16852 }
16853 return NULL;
16854 }
16855
16856
16857 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16858 PyObject *resultobj;
16859 wxString *arg1 = 0 ;
16860 bool arg2 = (bool) false ;
16861 wxSize result;
16862 bool temp1 = false ;
16863 PyObject * obj0 = 0 ;
16864 PyObject * obj1 = 0 ;
16865 char *kwnames[] = {
16866 (char *) "client",(char *) "platform_dependent", NULL
16867 };
16868
16869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16870 {
16871 arg1 = wxString_in_helper(obj0);
16872 if (arg1 == NULL) SWIG_fail;
16873 temp1 = true;
16874 }
16875 if (obj1) {
16876 {
16877 arg2 = (bool)(SWIG_As_bool(obj1));
16878 if (SWIG_arg_fail(2)) SWIG_fail;
16879 }
16880 }
16881 {
16882 PyThreadState* __tstate = wxPyBeginAllowThreads();
16883 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16884
16885 wxPyEndAllowThreads(__tstate);
16886 if (PyErr_Occurred()) SWIG_fail;
16887 }
16888 {
16889 wxSize * resultptr;
16890 resultptr = new wxSize((wxSize &)(result));
16891 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16892 }
16893 {
16894 if (temp1)
16895 delete arg1;
16896 }
16897 return resultobj;
16898 fail:
16899 {
16900 if (temp1)
16901 delete arg1;
16902 }
16903 return NULL;
16904 }
16905
16906
16907 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16908 PyObject *resultobj;
16909 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16910 PyObject * obj0 = 0 ;
16911 char *kwnames[] = {
16912 (char *) "self", NULL
16913 };
16914
16915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16917 if (SWIG_arg_fail(1)) SWIG_fail;
16918 {
16919 PyThreadState* __tstate = wxPyBeginAllowThreads();
16920 wxPyArtProvider_Destroy(arg1);
16921
16922 wxPyEndAllowThreads(__tstate);
16923 if (PyErr_Occurred()) SWIG_fail;
16924 }
16925 Py_INCREF(Py_None); resultobj = Py_None;
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16933 PyObject *obj;
16934 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16935 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16936 Py_INCREF(obj);
16937 return Py_BuildValue((char *)"");
16938 }
16939 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16940 PyObject *resultobj;
16941 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16942 PyObject * obj0 = 0 ;
16943 char *kwnames[] = {
16944 (char *) "self", NULL
16945 };
16946
16947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16949 if (SWIG_arg_fail(1)) SWIG_fail;
16950 {
16951 PyThreadState* __tstate = wxPyBeginAllowThreads();
16952 delete arg1;
16953
16954 wxPyEndAllowThreads(__tstate);
16955 if (PyErr_Occurred()) SWIG_fail;
16956 }
16957 Py_INCREF(Py_None); resultobj = Py_None;
16958 return resultobj;
16959 fail:
16960 return NULL;
16961 }
16962
16963
16964 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16965 PyObject *resultobj;
16966 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16967 wxConfigBase *result;
16968 PyObject * obj0 = 0 ;
16969 char *kwnames[] = {
16970 (char *) "config", NULL
16971 };
16972
16973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16975 if (SWIG_arg_fail(1)) SWIG_fail;
16976 {
16977 PyThreadState* __tstate = wxPyBeginAllowThreads();
16978 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16979
16980 wxPyEndAllowThreads(__tstate);
16981 if (PyErr_Occurred()) SWIG_fail;
16982 }
16983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16984 return resultobj;
16985 fail:
16986 return NULL;
16987 }
16988
16989
16990 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16991 PyObject *resultobj;
16992 bool arg1 = (bool) true ;
16993 wxConfigBase *result;
16994 PyObject * obj0 = 0 ;
16995 char *kwnames[] = {
16996 (char *) "createOnDemand", NULL
16997 };
16998
16999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17000 if (obj0) {
17001 {
17002 arg1 = (bool)(SWIG_As_bool(obj0));
17003 if (SWIG_arg_fail(1)) SWIG_fail;
17004 }
17005 }
17006 {
17007 PyThreadState* __tstate = wxPyBeginAllowThreads();
17008 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17009
17010 wxPyEndAllowThreads(__tstate);
17011 if (PyErr_Occurred()) SWIG_fail;
17012 }
17013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17014 return resultobj;
17015 fail:
17016 return NULL;
17017 }
17018
17019
17020 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17021 PyObject *resultobj;
17022 wxConfigBase *result;
17023 char *kwnames[] = {
17024 NULL
17025 };
17026
17027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17028 {
17029 PyThreadState* __tstate = wxPyBeginAllowThreads();
17030 result = (wxConfigBase *)wxConfigBase::Create();
17031
17032 wxPyEndAllowThreads(__tstate);
17033 if (PyErr_Occurred()) SWIG_fail;
17034 }
17035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj;
17044 char *kwnames[] = {
17045 NULL
17046 };
17047
17048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17049 {
17050 PyThreadState* __tstate = wxPyBeginAllowThreads();
17051 wxConfigBase::DontCreateOnDemand();
17052
17053 wxPyEndAllowThreads(__tstate);
17054 if (PyErr_Occurred()) SWIG_fail;
17055 }
17056 Py_INCREF(Py_None); resultobj = Py_None;
17057 return resultobj;
17058 fail:
17059 return NULL;
17060 }
17061
17062
17063 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17064 PyObject *resultobj;
17065 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17066 wxString *arg2 = 0 ;
17067 bool temp2 = false ;
17068 PyObject * obj0 = 0 ;
17069 PyObject * obj1 = 0 ;
17070 char *kwnames[] = {
17071 (char *) "self",(char *) "path", NULL
17072 };
17073
17074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17076 if (SWIG_arg_fail(1)) SWIG_fail;
17077 {
17078 arg2 = wxString_in_helper(obj1);
17079 if (arg2 == NULL) SWIG_fail;
17080 temp2 = true;
17081 }
17082 {
17083 PyThreadState* __tstate = wxPyBeginAllowThreads();
17084 (arg1)->SetPath((wxString const &)*arg2);
17085
17086 wxPyEndAllowThreads(__tstate);
17087 if (PyErr_Occurred()) SWIG_fail;
17088 }
17089 Py_INCREF(Py_None); resultobj = Py_None;
17090 {
17091 if (temp2)
17092 delete arg2;
17093 }
17094 return resultobj;
17095 fail:
17096 {
17097 if (temp2)
17098 delete arg2;
17099 }
17100 return NULL;
17101 }
17102
17103
17104 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17105 PyObject *resultobj;
17106 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17107 wxString *result;
17108 PyObject * obj0 = 0 ;
17109 char *kwnames[] = {
17110 (char *) "self", NULL
17111 };
17112
17113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17115 if (SWIG_arg_fail(1)) SWIG_fail;
17116 {
17117 PyThreadState* __tstate = wxPyBeginAllowThreads();
17118 {
17119 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17120 result = (wxString *) &_result_ref;
17121 }
17122
17123 wxPyEndAllowThreads(__tstate);
17124 if (PyErr_Occurred()) SWIG_fail;
17125 }
17126 {
17127 #if wxUSE_UNICODE
17128 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17129 #else
17130 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17131 #endif
17132 }
17133 return resultobj;
17134 fail:
17135 return NULL;
17136 }
17137
17138
17139 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17140 PyObject *resultobj;
17141 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17142 PyObject *result;
17143 PyObject * obj0 = 0 ;
17144 char *kwnames[] = {
17145 (char *) "self", NULL
17146 };
17147
17148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17150 if (SWIG_arg_fail(1)) SWIG_fail;
17151 {
17152 PyThreadState* __tstate = wxPyBeginAllowThreads();
17153 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17154
17155 wxPyEndAllowThreads(__tstate);
17156 if (PyErr_Occurred()) SWIG_fail;
17157 }
17158 resultobj = result;
17159 return resultobj;
17160 fail:
17161 return NULL;
17162 }
17163
17164
17165 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17166 PyObject *resultobj;
17167 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17168 long arg2 ;
17169 PyObject *result;
17170 PyObject * obj0 = 0 ;
17171 PyObject * obj1 = 0 ;
17172 char *kwnames[] = {
17173 (char *) "self",(char *) "index", NULL
17174 };
17175
17176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17178 if (SWIG_arg_fail(1)) SWIG_fail;
17179 {
17180 arg2 = (long)(SWIG_As_long(obj1));
17181 if (SWIG_arg_fail(2)) SWIG_fail;
17182 }
17183 {
17184 PyThreadState* __tstate = wxPyBeginAllowThreads();
17185 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17186
17187 wxPyEndAllowThreads(__tstate);
17188 if (PyErr_Occurred()) SWIG_fail;
17189 }
17190 resultobj = result;
17191 return resultobj;
17192 fail:
17193 return NULL;
17194 }
17195
17196
17197 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17198 PyObject *resultobj;
17199 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17200 PyObject *result;
17201 PyObject * obj0 = 0 ;
17202 char *kwnames[] = {
17203 (char *) "self", NULL
17204 };
17205
17206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17208 if (SWIG_arg_fail(1)) SWIG_fail;
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17212
17213 wxPyEndAllowThreads(__tstate);
17214 if (PyErr_Occurred()) SWIG_fail;
17215 }
17216 resultobj = result;
17217 return resultobj;
17218 fail:
17219 return NULL;
17220 }
17221
17222
17223 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17224 PyObject *resultobj;
17225 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17226 long arg2 ;
17227 PyObject *result;
17228 PyObject * obj0 = 0 ;
17229 PyObject * obj1 = 0 ;
17230 char *kwnames[] = {
17231 (char *) "self",(char *) "index", NULL
17232 };
17233
17234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17236 if (SWIG_arg_fail(1)) SWIG_fail;
17237 {
17238 arg2 = (long)(SWIG_As_long(obj1));
17239 if (SWIG_arg_fail(2)) SWIG_fail;
17240 }
17241 {
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17244
17245 wxPyEndAllowThreads(__tstate);
17246 if (PyErr_Occurred()) SWIG_fail;
17247 }
17248 resultobj = result;
17249 return resultobj;
17250 fail:
17251 return NULL;
17252 }
17253
17254
17255 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17256 PyObject *resultobj;
17257 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17258 bool arg2 = (bool) false ;
17259 size_t result;
17260 PyObject * obj0 = 0 ;
17261 PyObject * obj1 = 0 ;
17262 char *kwnames[] = {
17263 (char *) "self",(char *) "recursive", NULL
17264 };
17265
17266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17268 if (SWIG_arg_fail(1)) SWIG_fail;
17269 if (obj1) {
17270 {
17271 arg2 = (bool)(SWIG_As_bool(obj1));
17272 if (SWIG_arg_fail(2)) SWIG_fail;
17273 }
17274 }
17275 {
17276 PyThreadState* __tstate = wxPyBeginAllowThreads();
17277 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17278
17279 wxPyEndAllowThreads(__tstate);
17280 if (PyErr_Occurred()) SWIG_fail;
17281 }
17282 {
17283 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17284 }
17285 return resultobj;
17286 fail:
17287 return NULL;
17288 }
17289
17290
17291 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17292 PyObject *resultobj;
17293 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17294 bool arg2 = (bool) false ;
17295 size_t result;
17296 PyObject * obj0 = 0 ;
17297 PyObject * obj1 = 0 ;
17298 char *kwnames[] = {
17299 (char *) "self",(char *) "recursive", NULL
17300 };
17301
17302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",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 if (obj1) {
17306 {
17307 arg2 = (bool)(SWIG_As_bool(obj1));
17308 if (SWIG_arg_fail(2)) SWIG_fail;
17309 }
17310 }
17311 {
17312 PyThreadState* __tstate = wxPyBeginAllowThreads();
17313 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17314
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 {
17319 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17320 }
17321 return resultobj;
17322 fail:
17323 return NULL;
17324 }
17325
17326
17327 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17328 PyObject *resultobj;
17329 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17330 wxString *arg2 = 0 ;
17331 bool result;
17332 bool temp2 = false ;
17333 PyObject * obj0 = 0 ;
17334 PyObject * obj1 = 0 ;
17335 char *kwnames[] = {
17336 (char *) "self",(char *) "name", NULL
17337 };
17338
17339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17341 if (SWIG_arg_fail(1)) SWIG_fail;
17342 {
17343 arg2 = wxString_in_helper(obj1);
17344 if (arg2 == NULL) SWIG_fail;
17345 temp2 = true;
17346 }
17347 {
17348 PyThreadState* __tstate = wxPyBeginAllowThreads();
17349 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17350
17351 wxPyEndAllowThreads(__tstate);
17352 if (PyErr_Occurred()) SWIG_fail;
17353 }
17354 {
17355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17356 }
17357 {
17358 if (temp2)
17359 delete arg2;
17360 }
17361 return resultobj;
17362 fail:
17363 {
17364 if (temp2)
17365 delete arg2;
17366 }
17367 return NULL;
17368 }
17369
17370
17371 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17372 PyObject *resultobj;
17373 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17374 wxString *arg2 = 0 ;
17375 bool result;
17376 bool temp2 = false ;
17377 PyObject * obj0 = 0 ;
17378 PyObject * obj1 = 0 ;
17379 char *kwnames[] = {
17380 (char *) "self",(char *) "name", NULL
17381 };
17382
17383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17385 if (SWIG_arg_fail(1)) SWIG_fail;
17386 {
17387 arg2 = wxString_in_helper(obj1);
17388 if (arg2 == NULL) SWIG_fail;
17389 temp2 = true;
17390 }
17391 {
17392 PyThreadState* __tstate = wxPyBeginAllowThreads();
17393 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17394
17395 wxPyEndAllowThreads(__tstate);
17396 if (PyErr_Occurred()) SWIG_fail;
17397 }
17398 {
17399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17400 }
17401 {
17402 if (temp2)
17403 delete arg2;
17404 }
17405 return resultobj;
17406 fail:
17407 {
17408 if (temp2)
17409 delete arg2;
17410 }
17411 return NULL;
17412 }
17413
17414
17415 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17416 PyObject *resultobj;
17417 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17418 wxString *arg2 = 0 ;
17419 bool result;
17420 bool temp2 = false ;
17421 PyObject * obj0 = 0 ;
17422 PyObject * obj1 = 0 ;
17423 char *kwnames[] = {
17424 (char *) "self",(char *) "name", NULL
17425 };
17426
17427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17429 if (SWIG_arg_fail(1)) SWIG_fail;
17430 {
17431 arg2 = wxString_in_helper(obj1);
17432 if (arg2 == NULL) SWIG_fail;
17433 temp2 = true;
17434 }
17435 {
17436 PyThreadState* __tstate = wxPyBeginAllowThreads();
17437 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17438
17439 wxPyEndAllowThreads(__tstate);
17440 if (PyErr_Occurred()) SWIG_fail;
17441 }
17442 {
17443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17444 }
17445 {
17446 if (temp2)
17447 delete arg2;
17448 }
17449 return resultobj;
17450 fail:
17451 {
17452 if (temp2)
17453 delete arg2;
17454 }
17455 return NULL;
17456 }
17457
17458
17459 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17460 PyObject *resultobj;
17461 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17462 wxString *arg2 = 0 ;
17463 wxConfigBase::EntryType result;
17464 bool temp2 = false ;
17465 PyObject * obj0 = 0 ;
17466 PyObject * obj1 = 0 ;
17467 char *kwnames[] = {
17468 (char *) "self",(char *) "name", NULL
17469 };
17470
17471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17473 if (SWIG_arg_fail(1)) SWIG_fail;
17474 {
17475 arg2 = wxString_in_helper(obj1);
17476 if (arg2 == NULL) SWIG_fail;
17477 temp2 = true;
17478 }
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17482
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 resultobj = SWIG_From_int((result));
17487 {
17488 if (temp2)
17489 delete arg2;
17490 }
17491 return resultobj;
17492 fail:
17493 {
17494 if (temp2)
17495 delete arg2;
17496 }
17497 return NULL;
17498 }
17499
17500
17501 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17502 PyObject *resultobj;
17503 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17504 wxString *arg2 = 0 ;
17505 wxString const &arg3_defvalue = wxPyEmptyString ;
17506 wxString *arg3 = (wxString *) &arg3_defvalue ;
17507 wxString result;
17508 bool temp2 = false ;
17509 bool temp3 = 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_Read",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 = wxString_in_helper(obj2);
17528 if (arg3 == NULL) SWIG_fail;
17529 temp3 = true;
17530 }
17531 }
17532 {
17533 PyThreadState* __tstate = wxPyBeginAllowThreads();
17534 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17535
17536 wxPyEndAllowThreads(__tstate);
17537 if (PyErr_Occurred()) SWIG_fail;
17538 }
17539 {
17540 #if wxUSE_UNICODE
17541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17542 #else
17543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17544 #endif
17545 }
17546 {
17547 if (temp2)
17548 delete arg2;
17549 }
17550 {
17551 if (temp3)
17552 delete arg3;
17553 }
17554 return resultobj;
17555 fail:
17556 {
17557 if (temp2)
17558 delete arg2;
17559 }
17560 {
17561 if (temp3)
17562 delete arg3;
17563 }
17564 return NULL;
17565 }
17566
17567
17568 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17569 PyObject *resultobj;
17570 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17571 wxString *arg2 = 0 ;
17572 long arg3 = (long) 0 ;
17573 long result;
17574 bool temp2 = false ;
17575 PyObject * obj0 = 0 ;
17576 PyObject * obj1 = 0 ;
17577 PyObject * obj2 = 0 ;
17578 char *kwnames[] = {
17579 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17580 };
17581
17582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17584 if (SWIG_arg_fail(1)) SWIG_fail;
17585 {
17586 arg2 = wxString_in_helper(obj1);
17587 if (arg2 == NULL) SWIG_fail;
17588 temp2 = true;
17589 }
17590 if (obj2) {
17591 {
17592 arg3 = (long)(SWIG_As_long(obj2));
17593 if (SWIG_arg_fail(3)) SWIG_fail;
17594 }
17595 }
17596 {
17597 PyThreadState* __tstate = wxPyBeginAllowThreads();
17598 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17599
17600 wxPyEndAllowThreads(__tstate);
17601 if (PyErr_Occurred()) SWIG_fail;
17602 }
17603 {
17604 resultobj = SWIG_From_long((long)(result));
17605 }
17606 {
17607 if (temp2)
17608 delete arg2;
17609 }
17610 return resultobj;
17611 fail:
17612 {
17613 if (temp2)
17614 delete arg2;
17615 }
17616 return NULL;
17617 }
17618
17619
17620 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17621 PyObject *resultobj;
17622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17623 wxString *arg2 = 0 ;
17624 double arg3 = (double) 0.0 ;
17625 double result;
17626 bool temp2 = false ;
17627 PyObject * obj0 = 0 ;
17628 PyObject * obj1 = 0 ;
17629 PyObject * obj2 = 0 ;
17630 char *kwnames[] = {
17631 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17632 };
17633
17634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17636 if (SWIG_arg_fail(1)) SWIG_fail;
17637 {
17638 arg2 = wxString_in_helper(obj1);
17639 if (arg2 == NULL) SWIG_fail;
17640 temp2 = true;
17641 }
17642 if (obj2) {
17643 {
17644 arg3 = (double)(SWIG_As_double(obj2));
17645 if (SWIG_arg_fail(3)) SWIG_fail;
17646 }
17647 }
17648 {
17649 PyThreadState* __tstate = wxPyBeginAllowThreads();
17650 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17651
17652 wxPyEndAllowThreads(__tstate);
17653 if (PyErr_Occurred()) SWIG_fail;
17654 }
17655 {
17656 resultobj = SWIG_From_double((double)(result));
17657 }
17658 {
17659 if (temp2)
17660 delete arg2;
17661 }
17662 return resultobj;
17663 fail:
17664 {
17665 if (temp2)
17666 delete arg2;
17667 }
17668 return NULL;
17669 }
17670
17671
17672 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17673 PyObject *resultobj;
17674 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17675 wxString *arg2 = 0 ;
17676 bool arg3 = (bool) false ;
17677 bool result;
17678 bool temp2 = false ;
17679 PyObject * obj0 = 0 ;
17680 PyObject * obj1 = 0 ;
17681 PyObject * obj2 = 0 ;
17682 char *kwnames[] = {
17683 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17684 };
17685
17686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17688 if (SWIG_arg_fail(1)) SWIG_fail;
17689 {
17690 arg2 = wxString_in_helper(obj1);
17691 if (arg2 == NULL) SWIG_fail;
17692 temp2 = true;
17693 }
17694 if (obj2) {
17695 {
17696 arg3 = (bool)(SWIG_As_bool(obj2));
17697 if (SWIG_arg_fail(3)) SWIG_fail;
17698 }
17699 }
17700 {
17701 PyThreadState* __tstate = wxPyBeginAllowThreads();
17702 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17703
17704 wxPyEndAllowThreads(__tstate);
17705 if (PyErr_Occurred()) SWIG_fail;
17706 }
17707 {
17708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17709 }
17710 {
17711 if (temp2)
17712 delete arg2;
17713 }
17714 return resultobj;
17715 fail:
17716 {
17717 if (temp2)
17718 delete arg2;
17719 }
17720 return NULL;
17721 }
17722
17723
17724 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17725 PyObject *resultobj;
17726 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17727 wxString *arg2 = 0 ;
17728 wxString *arg3 = 0 ;
17729 bool result;
17730 bool temp2 = false ;
17731 bool temp3 = false ;
17732 PyObject * obj0 = 0 ;
17733 PyObject * obj1 = 0 ;
17734 PyObject * obj2 = 0 ;
17735 char *kwnames[] = {
17736 (char *) "self",(char *) "key",(char *) "value", NULL
17737 };
17738
17739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17741 if (SWIG_arg_fail(1)) SWIG_fail;
17742 {
17743 arg2 = wxString_in_helper(obj1);
17744 if (arg2 == NULL) SWIG_fail;
17745 temp2 = true;
17746 }
17747 {
17748 arg3 = wxString_in_helper(obj2);
17749 if (arg3 == NULL) SWIG_fail;
17750 temp3 = true;
17751 }
17752 {
17753 PyThreadState* __tstate = wxPyBeginAllowThreads();
17754 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17755
17756 wxPyEndAllowThreads(__tstate);
17757 if (PyErr_Occurred()) SWIG_fail;
17758 }
17759 {
17760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17761 }
17762 {
17763 if (temp2)
17764 delete arg2;
17765 }
17766 {
17767 if (temp3)
17768 delete arg3;
17769 }
17770 return resultobj;
17771 fail:
17772 {
17773 if (temp2)
17774 delete arg2;
17775 }
17776 {
17777 if (temp3)
17778 delete arg3;
17779 }
17780 return NULL;
17781 }
17782
17783
17784 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17785 PyObject *resultobj;
17786 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17787 wxString *arg2 = 0 ;
17788 long arg3 ;
17789 bool result;
17790 bool temp2 = false ;
17791 PyObject * obj0 = 0 ;
17792 PyObject * obj1 = 0 ;
17793 PyObject * obj2 = 0 ;
17794 char *kwnames[] = {
17795 (char *) "self",(char *) "key",(char *) "value", NULL
17796 };
17797
17798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17800 if (SWIG_arg_fail(1)) SWIG_fail;
17801 {
17802 arg2 = wxString_in_helper(obj1);
17803 if (arg2 == NULL) SWIG_fail;
17804 temp2 = true;
17805 }
17806 {
17807 arg3 = (long)(SWIG_As_long(obj2));
17808 if (SWIG_arg_fail(3)) SWIG_fail;
17809 }
17810 {
17811 PyThreadState* __tstate = wxPyBeginAllowThreads();
17812 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17813
17814 wxPyEndAllowThreads(__tstate);
17815 if (PyErr_Occurred()) SWIG_fail;
17816 }
17817 {
17818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17819 }
17820 {
17821 if (temp2)
17822 delete arg2;
17823 }
17824 return resultobj;
17825 fail:
17826 {
17827 if (temp2)
17828 delete arg2;
17829 }
17830 return NULL;
17831 }
17832
17833
17834 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17835 PyObject *resultobj;
17836 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17837 wxString *arg2 = 0 ;
17838 double arg3 ;
17839 bool result;
17840 bool temp2 = false ;
17841 PyObject * obj0 = 0 ;
17842 PyObject * obj1 = 0 ;
17843 PyObject * obj2 = 0 ;
17844 char *kwnames[] = {
17845 (char *) "self",(char *) "key",(char *) "value", NULL
17846 };
17847
17848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17850 if (SWIG_arg_fail(1)) SWIG_fail;
17851 {
17852 arg2 = wxString_in_helper(obj1);
17853 if (arg2 == NULL) SWIG_fail;
17854 temp2 = true;
17855 }
17856 {
17857 arg3 = (double)(SWIG_As_double(obj2));
17858 if (SWIG_arg_fail(3)) SWIG_fail;
17859 }
17860 {
17861 PyThreadState* __tstate = wxPyBeginAllowThreads();
17862 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17863
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 {
17868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17869 }
17870 {
17871 if (temp2)
17872 delete arg2;
17873 }
17874 return resultobj;
17875 fail:
17876 {
17877 if (temp2)
17878 delete arg2;
17879 }
17880 return NULL;
17881 }
17882
17883
17884 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17885 PyObject *resultobj;
17886 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17887 wxString *arg2 = 0 ;
17888 bool arg3 ;
17889 bool result;
17890 bool temp2 = false ;
17891 PyObject * obj0 = 0 ;
17892 PyObject * obj1 = 0 ;
17893 PyObject * obj2 = 0 ;
17894 char *kwnames[] = {
17895 (char *) "self",(char *) "key",(char *) "value", NULL
17896 };
17897
17898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17900 if (SWIG_arg_fail(1)) SWIG_fail;
17901 {
17902 arg2 = wxString_in_helper(obj1);
17903 if (arg2 == NULL) SWIG_fail;
17904 temp2 = true;
17905 }
17906 {
17907 arg3 = (bool)(SWIG_As_bool(obj2));
17908 if (SWIG_arg_fail(3)) SWIG_fail;
17909 }
17910 {
17911 PyThreadState* __tstate = wxPyBeginAllowThreads();
17912 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17913
17914 wxPyEndAllowThreads(__tstate);
17915 if (PyErr_Occurred()) SWIG_fail;
17916 }
17917 {
17918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17919 }
17920 {
17921 if (temp2)
17922 delete arg2;
17923 }
17924 return resultobj;
17925 fail:
17926 {
17927 if (temp2)
17928 delete arg2;
17929 }
17930 return NULL;
17931 }
17932
17933
17934 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17935 PyObject *resultobj;
17936 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17937 bool arg2 = (bool) false ;
17938 bool result;
17939 PyObject * obj0 = 0 ;
17940 PyObject * obj1 = 0 ;
17941 char *kwnames[] = {
17942 (char *) "self",(char *) "currentOnly", NULL
17943 };
17944
17945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17947 if (SWIG_arg_fail(1)) SWIG_fail;
17948 if (obj1) {
17949 {
17950 arg2 = (bool)(SWIG_As_bool(obj1));
17951 if (SWIG_arg_fail(2)) SWIG_fail;
17952 }
17953 }
17954 {
17955 PyThreadState* __tstate = wxPyBeginAllowThreads();
17956 result = (bool)(arg1)->Flush(arg2);
17957
17958 wxPyEndAllowThreads(__tstate);
17959 if (PyErr_Occurred()) SWIG_fail;
17960 }
17961 {
17962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17963 }
17964 return resultobj;
17965 fail:
17966 return NULL;
17967 }
17968
17969
17970 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17971 PyObject *resultobj;
17972 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17973 wxString *arg2 = 0 ;
17974 wxString *arg3 = 0 ;
17975 bool result;
17976 bool temp2 = false ;
17977 bool temp3 = false ;
17978 PyObject * obj0 = 0 ;
17979 PyObject * obj1 = 0 ;
17980 PyObject * obj2 = 0 ;
17981 char *kwnames[] = {
17982 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17983 };
17984
17985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) 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 arg3 = wxString_in_helper(obj2);
17995 if (arg3 == NULL) SWIG_fail;
17996 temp3 = true;
17997 }
17998 {
17999 PyThreadState* __tstate = wxPyBeginAllowThreads();
18000 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18001
18002 wxPyEndAllowThreads(__tstate);
18003 if (PyErr_Occurred()) SWIG_fail;
18004 }
18005 {
18006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18007 }
18008 {
18009 if (temp2)
18010 delete arg2;
18011 }
18012 {
18013 if (temp3)
18014 delete arg3;
18015 }
18016 return resultobj;
18017 fail:
18018 {
18019 if (temp2)
18020 delete arg2;
18021 }
18022 {
18023 if (temp3)
18024 delete arg3;
18025 }
18026 return NULL;
18027 }
18028
18029
18030 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18031 PyObject *resultobj;
18032 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18033 wxString *arg2 = 0 ;
18034 wxString *arg3 = 0 ;
18035 bool result;
18036 bool temp2 = false ;
18037 bool temp3 = false ;
18038 PyObject * obj0 = 0 ;
18039 PyObject * obj1 = 0 ;
18040 PyObject * obj2 = 0 ;
18041 char *kwnames[] = {
18042 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18043 };
18044
18045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18047 if (SWIG_arg_fail(1)) SWIG_fail;
18048 {
18049 arg2 = wxString_in_helper(obj1);
18050 if (arg2 == NULL) SWIG_fail;
18051 temp2 = true;
18052 }
18053 {
18054 arg3 = wxString_in_helper(obj2);
18055 if (arg3 == NULL) SWIG_fail;
18056 temp3 = true;
18057 }
18058 {
18059 PyThreadState* __tstate = wxPyBeginAllowThreads();
18060 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18061
18062 wxPyEndAllowThreads(__tstate);
18063 if (PyErr_Occurred()) SWIG_fail;
18064 }
18065 {
18066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18067 }
18068 {
18069 if (temp2)
18070 delete arg2;
18071 }
18072 {
18073 if (temp3)
18074 delete arg3;
18075 }
18076 return resultobj;
18077 fail:
18078 {
18079 if (temp2)
18080 delete arg2;
18081 }
18082 {
18083 if (temp3)
18084 delete arg3;
18085 }
18086 return NULL;
18087 }
18088
18089
18090 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj;
18092 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18093 wxString *arg2 = 0 ;
18094 bool arg3 = (bool) true ;
18095 bool result;
18096 bool temp2 = false ;
18097 PyObject * obj0 = 0 ;
18098 PyObject * obj1 = 0 ;
18099 PyObject * obj2 = 0 ;
18100 char *kwnames[] = {
18101 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18102 };
18103
18104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18106 if (SWIG_arg_fail(1)) SWIG_fail;
18107 {
18108 arg2 = wxString_in_helper(obj1);
18109 if (arg2 == NULL) SWIG_fail;
18110 temp2 = true;
18111 }
18112 if (obj2) {
18113 {
18114 arg3 = (bool)(SWIG_As_bool(obj2));
18115 if (SWIG_arg_fail(3)) SWIG_fail;
18116 }
18117 }
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18121
18122 wxPyEndAllowThreads(__tstate);
18123 if (PyErr_Occurred()) SWIG_fail;
18124 }
18125 {
18126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18127 }
18128 {
18129 if (temp2)
18130 delete arg2;
18131 }
18132 return resultobj;
18133 fail:
18134 {
18135 if (temp2)
18136 delete arg2;
18137 }
18138 return NULL;
18139 }
18140
18141
18142 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18143 PyObject *resultobj;
18144 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18145 wxString *arg2 = 0 ;
18146 bool result;
18147 bool temp2 = false ;
18148 PyObject * obj0 = 0 ;
18149 PyObject * obj1 = 0 ;
18150 char *kwnames[] = {
18151 (char *) "self",(char *) "key", NULL
18152 };
18153
18154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18156 if (SWIG_arg_fail(1)) SWIG_fail;
18157 {
18158 arg2 = wxString_in_helper(obj1);
18159 if (arg2 == NULL) SWIG_fail;
18160 temp2 = true;
18161 }
18162 {
18163 PyThreadState* __tstate = wxPyBeginAllowThreads();
18164 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18165
18166 wxPyEndAllowThreads(__tstate);
18167 if (PyErr_Occurred()) SWIG_fail;
18168 }
18169 {
18170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18171 }
18172 {
18173 if (temp2)
18174 delete arg2;
18175 }
18176 return resultobj;
18177 fail:
18178 {
18179 if (temp2)
18180 delete arg2;
18181 }
18182 return NULL;
18183 }
18184
18185
18186 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18187 PyObject *resultobj;
18188 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18189 bool result;
18190 PyObject * obj0 = 0 ;
18191 char *kwnames[] = {
18192 (char *) "self", NULL
18193 };
18194
18195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18197 if (SWIG_arg_fail(1)) SWIG_fail;
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 result = (bool)(arg1)->DeleteAll();
18201
18202 wxPyEndAllowThreads(__tstate);
18203 if (PyErr_Occurred()) SWIG_fail;
18204 }
18205 {
18206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18207 }
18208 return resultobj;
18209 fail:
18210 return NULL;
18211 }
18212
18213
18214 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18215 PyObject *resultobj;
18216 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18217 bool arg2 = (bool) true ;
18218 PyObject * obj0 = 0 ;
18219 PyObject * obj1 = 0 ;
18220 char *kwnames[] = {
18221 (char *) "self",(char *) "doIt", NULL
18222 };
18223
18224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) 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 if (obj1) {
18228 {
18229 arg2 = (bool)(SWIG_As_bool(obj1));
18230 if (SWIG_arg_fail(2)) SWIG_fail;
18231 }
18232 }
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 (arg1)->SetExpandEnvVars(arg2);
18236
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 Py_INCREF(Py_None); resultobj = Py_None;
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18248 PyObject *resultobj;
18249 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18250 bool result;
18251 PyObject * obj0 = 0 ;
18252 char *kwnames[] = {
18253 (char *) "self", NULL
18254 };
18255
18256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",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 = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18262
18263 wxPyEndAllowThreads(__tstate);
18264 if (PyErr_Occurred()) SWIG_fail;
18265 }
18266 {
18267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18268 }
18269 return resultobj;
18270 fail:
18271 return NULL;
18272 }
18273
18274
18275 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18276 PyObject *resultobj;
18277 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18278 bool arg2 = (bool) true ;
18279 PyObject * obj0 = 0 ;
18280 PyObject * obj1 = 0 ;
18281 char *kwnames[] = {
18282 (char *) "self",(char *) "doIt", NULL
18283 };
18284
18285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18287 if (SWIG_arg_fail(1)) SWIG_fail;
18288 if (obj1) {
18289 {
18290 arg2 = (bool)(SWIG_As_bool(obj1));
18291 if (SWIG_arg_fail(2)) SWIG_fail;
18292 }
18293 }
18294 {
18295 PyThreadState* __tstate = wxPyBeginAllowThreads();
18296 (arg1)->SetRecordDefaults(arg2);
18297
18298 wxPyEndAllowThreads(__tstate);
18299 if (PyErr_Occurred()) SWIG_fail;
18300 }
18301 Py_INCREF(Py_None); resultobj = Py_None;
18302 return resultobj;
18303 fail:
18304 return NULL;
18305 }
18306
18307
18308 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18309 PyObject *resultobj;
18310 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18311 bool result;
18312 PyObject * obj0 = 0 ;
18313 char *kwnames[] = {
18314 (char *) "self", NULL
18315 };
18316
18317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18319 if (SWIG_arg_fail(1)) SWIG_fail;
18320 {
18321 PyThreadState* __tstate = wxPyBeginAllowThreads();
18322 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18323
18324 wxPyEndAllowThreads(__tstate);
18325 if (PyErr_Occurred()) SWIG_fail;
18326 }
18327 {
18328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18329 }
18330 return resultobj;
18331 fail:
18332 return NULL;
18333 }
18334
18335
18336 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18337 PyObject *resultobj;
18338 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18339 wxString *arg2 = 0 ;
18340 wxString result;
18341 bool temp2 = false ;
18342 PyObject * obj0 = 0 ;
18343 PyObject * obj1 = 0 ;
18344 char *kwnames[] = {
18345 (char *) "self",(char *) "str", NULL
18346 };
18347
18348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18350 if (SWIG_arg_fail(1)) SWIG_fail;
18351 {
18352 arg2 = wxString_in_helper(obj1);
18353 if (arg2 == NULL) SWIG_fail;
18354 temp2 = true;
18355 }
18356 {
18357 PyThreadState* __tstate = wxPyBeginAllowThreads();
18358 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18359
18360 wxPyEndAllowThreads(__tstate);
18361 if (PyErr_Occurred()) SWIG_fail;
18362 }
18363 {
18364 #if wxUSE_UNICODE
18365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18366 #else
18367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18368 #endif
18369 }
18370 {
18371 if (temp2)
18372 delete arg2;
18373 }
18374 return resultobj;
18375 fail:
18376 {
18377 if (temp2)
18378 delete arg2;
18379 }
18380 return NULL;
18381 }
18382
18383
18384 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj;
18386 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18387 wxString result;
18388 PyObject * obj0 = 0 ;
18389 char *kwnames[] = {
18390 (char *) "self", NULL
18391 };
18392
18393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18395 if (SWIG_arg_fail(1)) SWIG_fail;
18396 {
18397 PyThreadState* __tstate = wxPyBeginAllowThreads();
18398 result = ((wxConfigBase const *)arg1)->GetAppName();
18399
18400 wxPyEndAllowThreads(__tstate);
18401 if (PyErr_Occurred()) SWIG_fail;
18402 }
18403 {
18404 #if wxUSE_UNICODE
18405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18406 #else
18407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18408 #endif
18409 }
18410 return resultobj;
18411 fail:
18412 return NULL;
18413 }
18414
18415
18416 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18417 PyObject *resultobj;
18418 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18419 wxString result;
18420 PyObject * obj0 = 0 ;
18421 char *kwnames[] = {
18422 (char *) "self", NULL
18423 };
18424
18425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18427 if (SWIG_arg_fail(1)) SWIG_fail;
18428 {
18429 PyThreadState* __tstate = wxPyBeginAllowThreads();
18430 result = ((wxConfigBase const *)arg1)->GetVendorName();
18431
18432 wxPyEndAllowThreads(__tstate);
18433 if (PyErr_Occurred()) SWIG_fail;
18434 }
18435 {
18436 #if wxUSE_UNICODE
18437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18438 #else
18439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18440 #endif
18441 }
18442 return resultobj;
18443 fail:
18444 return NULL;
18445 }
18446
18447
18448 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18449 PyObject *resultobj;
18450 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18451 wxString *arg2 = 0 ;
18452 bool temp2 = false ;
18453 PyObject * obj0 = 0 ;
18454 PyObject * obj1 = 0 ;
18455 char *kwnames[] = {
18456 (char *) "self",(char *) "appName", NULL
18457 };
18458
18459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18461 if (SWIG_arg_fail(1)) SWIG_fail;
18462 {
18463 arg2 = wxString_in_helper(obj1);
18464 if (arg2 == NULL) SWIG_fail;
18465 temp2 = true;
18466 }
18467 {
18468 PyThreadState* __tstate = wxPyBeginAllowThreads();
18469 (arg1)->SetAppName((wxString const &)*arg2);
18470
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 Py_INCREF(Py_None); resultobj = Py_None;
18475 {
18476 if (temp2)
18477 delete arg2;
18478 }
18479 return resultobj;
18480 fail:
18481 {
18482 if (temp2)
18483 delete arg2;
18484 }
18485 return NULL;
18486 }
18487
18488
18489 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18490 PyObject *resultobj;
18491 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18492 wxString *arg2 = 0 ;
18493 bool temp2 = false ;
18494 PyObject * obj0 = 0 ;
18495 PyObject * obj1 = 0 ;
18496 char *kwnames[] = {
18497 (char *) "self",(char *) "vendorName", NULL
18498 };
18499
18500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18502 if (SWIG_arg_fail(1)) SWIG_fail;
18503 {
18504 arg2 = wxString_in_helper(obj1);
18505 if (arg2 == NULL) SWIG_fail;
18506 temp2 = true;
18507 }
18508 {
18509 PyThreadState* __tstate = wxPyBeginAllowThreads();
18510 (arg1)->SetVendorName((wxString const &)*arg2);
18511
18512 wxPyEndAllowThreads(__tstate);
18513 if (PyErr_Occurred()) SWIG_fail;
18514 }
18515 Py_INCREF(Py_None); resultobj = Py_None;
18516 {
18517 if (temp2)
18518 delete arg2;
18519 }
18520 return resultobj;
18521 fail:
18522 {
18523 if (temp2)
18524 delete arg2;
18525 }
18526 return NULL;
18527 }
18528
18529
18530 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18531 PyObject *resultobj;
18532 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18533 long arg2 ;
18534 PyObject * obj0 = 0 ;
18535 PyObject * obj1 = 0 ;
18536 char *kwnames[] = {
18537 (char *) "self",(char *) "style", NULL
18538 };
18539
18540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18542 if (SWIG_arg_fail(1)) SWIG_fail;
18543 {
18544 arg2 = (long)(SWIG_As_long(obj1));
18545 if (SWIG_arg_fail(2)) SWIG_fail;
18546 }
18547 {
18548 PyThreadState* __tstate = wxPyBeginAllowThreads();
18549 (arg1)->SetStyle(arg2);
18550
18551 wxPyEndAllowThreads(__tstate);
18552 if (PyErr_Occurred()) SWIG_fail;
18553 }
18554 Py_INCREF(Py_None); resultobj = Py_None;
18555 return resultobj;
18556 fail:
18557 return NULL;
18558 }
18559
18560
18561 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18562 PyObject *resultobj;
18563 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18564 long result;
18565 PyObject * obj0 = 0 ;
18566 char *kwnames[] = {
18567 (char *) "self", NULL
18568 };
18569
18570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18572 if (SWIG_arg_fail(1)) SWIG_fail;
18573 {
18574 PyThreadState* __tstate = wxPyBeginAllowThreads();
18575 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18576
18577 wxPyEndAllowThreads(__tstate);
18578 if (PyErr_Occurred()) SWIG_fail;
18579 }
18580 {
18581 resultobj = SWIG_From_long((long)(result));
18582 }
18583 return resultobj;
18584 fail:
18585 return NULL;
18586 }
18587
18588
18589 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18590 PyObject *obj;
18591 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18592 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18593 Py_INCREF(obj);
18594 return Py_BuildValue((char *)"");
18595 }
18596 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18597 PyObject *resultobj;
18598 wxString const &arg1_defvalue = wxPyEmptyString ;
18599 wxString *arg1 = (wxString *) &arg1_defvalue ;
18600 wxString const &arg2_defvalue = wxPyEmptyString ;
18601 wxString *arg2 = (wxString *) &arg2_defvalue ;
18602 wxString const &arg3_defvalue = wxPyEmptyString ;
18603 wxString *arg3 = (wxString *) &arg3_defvalue ;
18604 wxString const &arg4_defvalue = wxPyEmptyString ;
18605 wxString *arg4 = (wxString *) &arg4_defvalue ;
18606 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18607 wxConfig *result;
18608 bool temp1 = false ;
18609 bool temp2 = false ;
18610 bool temp3 = false ;
18611 bool temp4 = false ;
18612 PyObject * obj0 = 0 ;
18613 PyObject * obj1 = 0 ;
18614 PyObject * obj2 = 0 ;
18615 PyObject * obj3 = 0 ;
18616 PyObject * obj4 = 0 ;
18617 char *kwnames[] = {
18618 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18619 };
18620
18621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18622 if (obj0) {
18623 {
18624 arg1 = wxString_in_helper(obj0);
18625 if (arg1 == NULL) SWIG_fail;
18626 temp1 = true;
18627 }
18628 }
18629 if (obj1) {
18630 {
18631 arg2 = wxString_in_helper(obj1);
18632 if (arg2 == NULL) SWIG_fail;
18633 temp2 = true;
18634 }
18635 }
18636 if (obj2) {
18637 {
18638 arg3 = wxString_in_helper(obj2);
18639 if (arg3 == NULL) SWIG_fail;
18640 temp3 = true;
18641 }
18642 }
18643 if (obj3) {
18644 {
18645 arg4 = wxString_in_helper(obj3);
18646 if (arg4 == NULL) SWIG_fail;
18647 temp4 = true;
18648 }
18649 }
18650 if (obj4) {
18651 {
18652 arg5 = (long)(SWIG_As_long(obj4));
18653 if (SWIG_arg_fail(5)) SWIG_fail;
18654 }
18655 }
18656 {
18657 PyThreadState* __tstate = wxPyBeginAllowThreads();
18658 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18659
18660 wxPyEndAllowThreads(__tstate);
18661 if (PyErr_Occurred()) SWIG_fail;
18662 }
18663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18664 {
18665 if (temp1)
18666 delete arg1;
18667 }
18668 {
18669 if (temp2)
18670 delete arg2;
18671 }
18672 {
18673 if (temp3)
18674 delete arg3;
18675 }
18676 {
18677 if (temp4)
18678 delete arg4;
18679 }
18680 return resultobj;
18681 fail:
18682 {
18683 if (temp1)
18684 delete arg1;
18685 }
18686 {
18687 if (temp2)
18688 delete arg2;
18689 }
18690 {
18691 if (temp3)
18692 delete arg3;
18693 }
18694 {
18695 if (temp4)
18696 delete arg4;
18697 }
18698 return NULL;
18699 }
18700
18701
18702 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18703 PyObject *resultobj;
18704 wxConfig *arg1 = (wxConfig *) 0 ;
18705 PyObject * obj0 = 0 ;
18706 char *kwnames[] = {
18707 (char *) "self", NULL
18708 };
18709
18710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18712 if (SWIG_arg_fail(1)) SWIG_fail;
18713 {
18714 PyThreadState* __tstate = wxPyBeginAllowThreads();
18715 delete arg1;
18716
18717 wxPyEndAllowThreads(__tstate);
18718 if (PyErr_Occurred()) SWIG_fail;
18719 }
18720 Py_INCREF(Py_None); resultobj = Py_None;
18721 return resultobj;
18722 fail:
18723 return NULL;
18724 }
18725
18726
18727 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18728 PyObject *obj;
18729 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18730 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18731 Py_INCREF(obj);
18732 return Py_BuildValue((char *)"");
18733 }
18734 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18735 PyObject *resultobj;
18736 wxString const &arg1_defvalue = wxPyEmptyString ;
18737 wxString *arg1 = (wxString *) &arg1_defvalue ;
18738 wxString const &arg2_defvalue = wxPyEmptyString ;
18739 wxString *arg2 = (wxString *) &arg2_defvalue ;
18740 wxString const &arg3_defvalue = wxPyEmptyString ;
18741 wxString *arg3 = (wxString *) &arg3_defvalue ;
18742 wxString const &arg4_defvalue = wxPyEmptyString ;
18743 wxString *arg4 = (wxString *) &arg4_defvalue ;
18744 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18745 wxFileConfig *result;
18746 bool temp1 = false ;
18747 bool temp2 = false ;
18748 bool temp3 = false ;
18749 bool temp4 = false ;
18750 PyObject * obj0 = 0 ;
18751 PyObject * obj1 = 0 ;
18752 PyObject * obj2 = 0 ;
18753 PyObject * obj3 = 0 ;
18754 PyObject * obj4 = 0 ;
18755 char *kwnames[] = {
18756 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18757 };
18758
18759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18760 if (obj0) {
18761 {
18762 arg1 = wxString_in_helper(obj0);
18763 if (arg1 == NULL) SWIG_fail;
18764 temp1 = true;
18765 }
18766 }
18767 if (obj1) {
18768 {
18769 arg2 = wxString_in_helper(obj1);
18770 if (arg2 == NULL) SWIG_fail;
18771 temp2 = true;
18772 }
18773 }
18774 if (obj2) {
18775 {
18776 arg3 = wxString_in_helper(obj2);
18777 if (arg3 == NULL) SWIG_fail;
18778 temp3 = true;
18779 }
18780 }
18781 if (obj3) {
18782 {
18783 arg4 = wxString_in_helper(obj3);
18784 if (arg4 == NULL) SWIG_fail;
18785 temp4 = true;
18786 }
18787 }
18788 if (obj4) {
18789 {
18790 arg5 = (long)(SWIG_As_long(obj4));
18791 if (SWIG_arg_fail(5)) SWIG_fail;
18792 }
18793 }
18794 {
18795 PyThreadState* __tstate = wxPyBeginAllowThreads();
18796 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18797
18798 wxPyEndAllowThreads(__tstate);
18799 if (PyErr_Occurred()) SWIG_fail;
18800 }
18801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18802 {
18803 if (temp1)
18804 delete arg1;
18805 }
18806 {
18807 if (temp2)
18808 delete arg2;
18809 }
18810 {
18811 if (temp3)
18812 delete arg3;
18813 }
18814 {
18815 if (temp4)
18816 delete arg4;
18817 }
18818 return resultobj;
18819 fail:
18820 {
18821 if (temp1)
18822 delete arg1;
18823 }
18824 {
18825 if (temp2)
18826 delete arg2;
18827 }
18828 {
18829 if (temp3)
18830 delete arg3;
18831 }
18832 {
18833 if (temp4)
18834 delete arg4;
18835 }
18836 return NULL;
18837 }
18838
18839
18840 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18841 PyObject *resultobj;
18842 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18843 PyObject * obj0 = 0 ;
18844 char *kwnames[] = {
18845 (char *) "self", NULL
18846 };
18847
18848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18850 if (SWIG_arg_fail(1)) SWIG_fail;
18851 {
18852 PyThreadState* __tstate = wxPyBeginAllowThreads();
18853 delete arg1;
18854
18855 wxPyEndAllowThreads(__tstate);
18856 if (PyErr_Occurred()) SWIG_fail;
18857 }
18858 Py_INCREF(Py_None); resultobj = Py_None;
18859 return resultobj;
18860 fail:
18861 return NULL;
18862 }
18863
18864
18865 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18866 PyObject *obj;
18867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18868 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18869 Py_INCREF(obj);
18870 return Py_BuildValue((char *)"");
18871 }
18872 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj;
18874 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18875 wxString *arg2 = 0 ;
18876 wxConfigPathChanger *result;
18877 bool temp2 = false ;
18878 PyObject * obj0 = 0 ;
18879 PyObject * obj1 = 0 ;
18880 char *kwnames[] = {
18881 (char *) "config",(char *) "entry", NULL
18882 };
18883
18884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18886 if (SWIG_arg_fail(1)) SWIG_fail;
18887 {
18888 arg2 = wxString_in_helper(obj1);
18889 if (arg2 == NULL) SWIG_fail;
18890 temp2 = true;
18891 }
18892 {
18893 PyThreadState* __tstate = wxPyBeginAllowThreads();
18894 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18895
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18900 {
18901 if (temp2)
18902 delete arg2;
18903 }
18904 return resultobj;
18905 fail:
18906 {
18907 if (temp2)
18908 delete arg2;
18909 }
18910 return NULL;
18911 }
18912
18913
18914 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18915 PyObject *resultobj;
18916 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18917 PyObject * obj0 = 0 ;
18918 char *kwnames[] = {
18919 (char *) "self", NULL
18920 };
18921
18922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18924 if (SWIG_arg_fail(1)) SWIG_fail;
18925 {
18926 PyThreadState* __tstate = wxPyBeginAllowThreads();
18927 delete arg1;
18928
18929 wxPyEndAllowThreads(__tstate);
18930 if (PyErr_Occurred()) SWIG_fail;
18931 }
18932 Py_INCREF(Py_None); resultobj = Py_None;
18933 return resultobj;
18934 fail:
18935 return NULL;
18936 }
18937
18938
18939 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18940 PyObject *resultobj;
18941 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18942 wxString *result;
18943 PyObject * obj0 = 0 ;
18944 char *kwnames[] = {
18945 (char *) "self", NULL
18946 };
18947
18948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18950 if (SWIG_arg_fail(1)) SWIG_fail;
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 {
18954 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18955 result = (wxString *) &_result_ref;
18956 }
18957
18958 wxPyEndAllowThreads(__tstate);
18959 if (PyErr_Occurred()) SWIG_fail;
18960 }
18961 {
18962 #if wxUSE_UNICODE
18963 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18964 #else
18965 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18966 #endif
18967 }
18968 return resultobj;
18969 fail:
18970 return NULL;
18971 }
18972
18973
18974 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18975 PyObject *obj;
18976 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18977 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18978 Py_INCREF(obj);
18979 return Py_BuildValue((char *)"");
18980 }
18981 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18982 PyObject *resultobj;
18983 wxString *arg1 = 0 ;
18984 wxString result;
18985 bool temp1 = false ;
18986 PyObject * obj0 = 0 ;
18987 char *kwnames[] = {
18988 (char *) "sz", NULL
18989 };
18990
18991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18992 {
18993 arg1 = wxString_in_helper(obj0);
18994 if (arg1 == NULL) SWIG_fail;
18995 temp1 = true;
18996 }
18997 {
18998 PyThreadState* __tstate = wxPyBeginAllowThreads();
18999 result = wxExpandEnvVars((wxString const &)*arg1);
19000
19001 wxPyEndAllowThreads(__tstate);
19002 if (PyErr_Occurred()) SWIG_fail;
19003 }
19004 {
19005 #if wxUSE_UNICODE
19006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19007 #else
19008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19009 #endif
19010 }
19011 {
19012 if (temp1)
19013 delete arg1;
19014 }
19015 return resultobj;
19016 fail:
19017 {
19018 if (temp1)
19019 delete arg1;
19020 }
19021 return NULL;
19022 }
19023
19024
19025 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19026 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19027 return 1;
19028 }
19029
19030
19031 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19032 PyObject *pyobj;
19033
19034 {
19035 #if wxUSE_UNICODE
19036 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19037 #else
19038 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19039 #endif
19040 }
19041 return pyobj;
19042 }
19043
19044
19045 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19046 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19047 return 1;
19048 }
19049
19050
19051 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19052 PyObject *pyobj;
19053
19054 {
19055 #if wxUSE_UNICODE
19056 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19057 #else
19058 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19059 #endif
19060 }
19061 return pyobj;
19062 }
19063
19064
19065 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19066 PyObject *resultobj;
19067 wxDateTime::Country arg1 ;
19068 PyObject * obj0 = 0 ;
19069 char *kwnames[] = {
19070 (char *) "country", NULL
19071 };
19072
19073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19074 {
19075 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19076 if (SWIG_arg_fail(1)) SWIG_fail;
19077 }
19078 {
19079 PyThreadState* __tstate = wxPyBeginAllowThreads();
19080 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19081
19082 wxPyEndAllowThreads(__tstate);
19083 if (PyErr_Occurred()) SWIG_fail;
19084 }
19085 Py_INCREF(Py_None); resultobj = Py_None;
19086 return resultobj;
19087 fail:
19088 return NULL;
19089 }
19090
19091
19092 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19093 PyObject *resultobj;
19094 wxDateTime::Country result;
19095 char *kwnames[] = {
19096 NULL
19097 };
19098
19099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19100 {
19101 PyThreadState* __tstate = wxPyBeginAllowThreads();
19102 result = (wxDateTime::Country)wxDateTime::GetCountry();
19103
19104 wxPyEndAllowThreads(__tstate);
19105 if (PyErr_Occurred()) SWIG_fail;
19106 }
19107 resultobj = SWIG_From_int((result));
19108 return resultobj;
19109 fail:
19110 return NULL;
19111 }
19112
19113
19114 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19115 PyObject *resultobj;
19116 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19117 bool result;
19118 PyObject * obj0 = 0 ;
19119 char *kwnames[] = {
19120 (char *) "country", NULL
19121 };
19122
19123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19124 if (obj0) {
19125 {
19126 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19127 if (SWIG_arg_fail(1)) SWIG_fail;
19128 }
19129 }
19130 {
19131 PyThreadState* __tstate = wxPyBeginAllowThreads();
19132 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19133
19134 wxPyEndAllowThreads(__tstate);
19135 if (PyErr_Occurred()) SWIG_fail;
19136 }
19137 {
19138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19139 }
19140 return resultobj;
19141 fail:
19142 return NULL;
19143 }
19144
19145
19146 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19147 PyObject *resultobj;
19148 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19149 int result;
19150 PyObject * obj0 = 0 ;
19151 char *kwnames[] = {
19152 (char *) "cal", NULL
19153 };
19154
19155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19156 if (obj0) {
19157 {
19158 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19159 if (SWIG_arg_fail(1)) SWIG_fail;
19160 }
19161 }
19162 {
19163 PyThreadState* __tstate = wxPyBeginAllowThreads();
19164 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19165
19166 wxPyEndAllowThreads(__tstate);
19167 if (PyErr_Occurred()) SWIG_fail;
19168 }
19169 {
19170 resultobj = SWIG_From_int((int)(result));
19171 }
19172 return resultobj;
19173 fail:
19174 return NULL;
19175 }
19176
19177
19178 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19179 PyObject *resultobj;
19180 int arg1 ;
19181 int result;
19182 PyObject * obj0 = 0 ;
19183 char *kwnames[] = {
19184 (char *) "year", NULL
19185 };
19186
19187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19188 {
19189 arg1 = (int)(SWIG_As_int(obj0));
19190 if (SWIG_arg_fail(1)) SWIG_fail;
19191 }
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (int)wxDateTime::ConvertYearToBC(arg1);
19195
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 {
19200 resultobj = SWIG_From_int((int)(result));
19201 }
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj;
19210 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19211 wxDateTime::Month result;
19212 PyObject * obj0 = 0 ;
19213 char *kwnames[] = {
19214 (char *) "cal", NULL
19215 };
19216
19217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19218 if (obj0) {
19219 {
19220 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19221 if (SWIG_arg_fail(1)) SWIG_fail;
19222 }
19223 }
19224 {
19225 PyThreadState* __tstate = wxPyBeginAllowThreads();
19226 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19227
19228 wxPyEndAllowThreads(__tstate);
19229 if (PyErr_Occurred()) SWIG_fail;
19230 }
19231 resultobj = SWIG_From_int((result));
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19239 PyObject *resultobj;
19240 int arg1 = (int) wxDateTime::Inv_Year ;
19241 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19242 bool result;
19243 PyObject * obj0 = 0 ;
19244 PyObject * obj1 = 0 ;
19245 char *kwnames[] = {
19246 (char *) "year",(char *) "cal", NULL
19247 };
19248
19249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19250 if (obj0) {
19251 {
19252 arg1 = (int)(SWIG_As_int(obj0));
19253 if (SWIG_arg_fail(1)) SWIG_fail;
19254 }
19255 }
19256 if (obj1) {
19257 {
19258 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19259 if (SWIG_arg_fail(2)) SWIG_fail;
19260 }
19261 }
19262 {
19263 PyThreadState* __tstate = wxPyBeginAllowThreads();
19264 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19265
19266 wxPyEndAllowThreads(__tstate);
19267 if (PyErr_Occurred()) SWIG_fail;
19268 }
19269 {
19270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19271 }
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19279 PyObject *resultobj;
19280 int arg1 = (int) wxDateTime::Inv_Year ;
19281 int result;
19282 PyObject * obj0 = 0 ;
19283 char *kwnames[] = {
19284 (char *) "year", NULL
19285 };
19286
19287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19288 if (obj0) {
19289 {
19290 arg1 = (int)(SWIG_As_int(obj0));
19291 if (SWIG_arg_fail(1)) SWIG_fail;
19292 }
19293 }
19294 {
19295 PyThreadState* __tstate = wxPyBeginAllowThreads();
19296 result = (int)wxDateTime::GetCentury(arg1);
19297
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 {
19302 resultobj = SWIG_From_int((int)(result));
19303 }
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19311 PyObject *resultobj;
19312 int arg1 ;
19313 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19314 int result;
19315 PyObject * obj0 = 0 ;
19316 PyObject * obj1 = 0 ;
19317 char *kwnames[] = {
19318 (char *) "year",(char *) "cal", NULL
19319 };
19320
19321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19322 {
19323 arg1 = (int)(SWIG_As_int(obj0));
19324 if (SWIG_arg_fail(1)) SWIG_fail;
19325 }
19326 if (obj1) {
19327 {
19328 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19329 if (SWIG_arg_fail(2)) SWIG_fail;
19330 }
19331 }
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19335
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 {
19340 resultobj = SWIG_From_int((int)(result));
19341 }
19342 return resultobj;
19343 fail:
19344 return NULL;
19345 }
19346
19347
19348 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19349 PyObject *resultobj;
19350 wxDateTime::Month arg1 ;
19351 int arg2 = (int) wxDateTime::Inv_Year ;
19352 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19353 int result;
19354 PyObject * obj0 = 0 ;
19355 PyObject * obj1 = 0 ;
19356 PyObject * obj2 = 0 ;
19357 char *kwnames[] = {
19358 (char *) "month",(char *) "year",(char *) "cal", NULL
19359 };
19360
19361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19362 {
19363 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19364 if (SWIG_arg_fail(1)) SWIG_fail;
19365 }
19366 if (obj1) {
19367 {
19368 arg2 = (int)(SWIG_As_int(obj1));
19369 if (SWIG_arg_fail(2)) SWIG_fail;
19370 }
19371 }
19372 if (obj2) {
19373 {
19374 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19375 if (SWIG_arg_fail(3)) SWIG_fail;
19376 }
19377 }
19378 {
19379 PyThreadState* __tstate = wxPyBeginAllowThreads();
19380 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19381
19382 wxPyEndAllowThreads(__tstate);
19383 if (PyErr_Occurred()) SWIG_fail;
19384 }
19385 {
19386 resultobj = SWIG_From_int((int)(result));
19387 }
19388 return resultobj;
19389 fail:
19390 return NULL;
19391 }
19392
19393
19394 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19395 PyObject *resultobj;
19396 wxDateTime::Month arg1 ;
19397 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19398 wxString result;
19399 PyObject * obj0 = 0 ;
19400 PyObject * obj1 = 0 ;
19401 char *kwnames[] = {
19402 (char *) "month",(char *) "flags", NULL
19403 };
19404
19405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19406 {
19407 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19408 if (SWIG_arg_fail(1)) SWIG_fail;
19409 }
19410 if (obj1) {
19411 {
19412 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19413 if (SWIG_arg_fail(2)) SWIG_fail;
19414 }
19415 }
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19419
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 {
19424 #if wxUSE_UNICODE
19425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19426 #else
19427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19428 #endif
19429 }
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj;
19438 wxDateTime::WeekDay arg1 ;
19439 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19440 wxString result;
19441 PyObject * obj0 = 0 ;
19442 PyObject * obj1 = 0 ;
19443 char *kwnames[] = {
19444 (char *) "weekday",(char *) "flags", NULL
19445 };
19446
19447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19448 {
19449 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19450 if (SWIG_arg_fail(1)) SWIG_fail;
19451 }
19452 if (obj1) {
19453 {
19454 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19455 if (SWIG_arg_fail(2)) SWIG_fail;
19456 }
19457 }
19458 {
19459 PyThreadState* __tstate = wxPyBeginAllowThreads();
19460 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19461
19462 wxPyEndAllowThreads(__tstate);
19463 if (PyErr_Occurred()) SWIG_fail;
19464 }
19465 {
19466 #if wxUSE_UNICODE
19467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19468 #else
19469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19470 #endif
19471 }
19472 return resultobj;
19473 fail:
19474 return NULL;
19475 }
19476
19477
19478 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19479 PyObject *resultobj;
19480 PyObject *result;
19481 char *kwnames[] = {
19482 NULL
19483 };
19484
19485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19486 {
19487 PyThreadState* __tstate = wxPyBeginAllowThreads();
19488 result = (PyObject *)DateTime_GetAmPmStrings();
19489
19490 wxPyEndAllowThreads(__tstate);
19491 if (PyErr_Occurred()) SWIG_fail;
19492 }
19493 resultobj = result;
19494 return resultobj;
19495 fail:
19496 return NULL;
19497 }
19498
19499
19500 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19501 PyObject *resultobj;
19502 int arg1 = (int) wxDateTime::Inv_Year ;
19503 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19504 bool result;
19505 PyObject * obj0 = 0 ;
19506 PyObject * obj1 = 0 ;
19507 char *kwnames[] = {
19508 (char *) "year",(char *) "country", NULL
19509 };
19510
19511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19512 if (obj0) {
19513 {
19514 arg1 = (int)(SWIG_As_int(obj0));
19515 if (SWIG_arg_fail(1)) SWIG_fail;
19516 }
19517 }
19518 if (obj1) {
19519 {
19520 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19521 if (SWIG_arg_fail(2)) SWIG_fail;
19522 }
19523 }
19524 {
19525 PyThreadState* __tstate = wxPyBeginAllowThreads();
19526 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19527
19528 wxPyEndAllowThreads(__tstate);
19529 if (PyErr_Occurred()) SWIG_fail;
19530 }
19531 {
19532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19533 }
19534 return resultobj;
19535 fail:
19536 return NULL;
19537 }
19538
19539
19540 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19541 PyObject *resultobj;
19542 int arg1 = (int) wxDateTime::Inv_Year ;
19543 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19544 wxDateTime result;
19545 PyObject * obj0 = 0 ;
19546 PyObject * obj1 = 0 ;
19547 char *kwnames[] = {
19548 (char *) "year",(char *) "country", NULL
19549 };
19550
19551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19552 if (obj0) {
19553 {
19554 arg1 = (int)(SWIG_As_int(obj0));
19555 if (SWIG_arg_fail(1)) SWIG_fail;
19556 }
19557 }
19558 if (obj1) {
19559 {
19560 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19561 if (SWIG_arg_fail(2)) SWIG_fail;
19562 }
19563 }
19564 {
19565 PyThreadState* __tstate = wxPyBeginAllowThreads();
19566 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19567
19568 wxPyEndAllowThreads(__tstate);
19569 if (PyErr_Occurred()) SWIG_fail;
19570 }
19571 {
19572 wxDateTime * resultptr;
19573 resultptr = new wxDateTime((wxDateTime &)(result));
19574 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19575 }
19576 return resultobj;
19577 fail:
19578 return NULL;
19579 }
19580
19581
19582 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19583 PyObject *resultobj;
19584 int arg1 = (int) wxDateTime::Inv_Year ;
19585 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19586 wxDateTime result;
19587 PyObject * obj0 = 0 ;
19588 PyObject * obj1 = 0 ;
19589 char *kwnames[] = {
19590 (char *) "year",(char *) "country", NULL
19591 };
19592
19593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19594 if (obj0) {
19595 {
19596 arg1 = (int)(SWIG_As_int(obj0));
19597 if (SWIG_arg_fail(1)) SWIG_fail;
19598 }
19599 }
19600 if (obj1) {
19601 {
19602 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19603 if (SWIG_arg_fail(2)) SWIG_fail;
19604 }
19605 }
19606 {
19607 PyThreadState* __tstate = wxPyBeginAllowThreads();
19608 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19609
19610 wxPyEndAllowThreads(__tstate);
19611 if (PyErr_Occurred()) SWIG_fail;
19612 }
19613 {
19614 wxDateTime * resultptr;
19615 resultptr = new wxDateTime((wxDateTime &)(result));
19616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19617 }
19618 return resultobj;
19619 fail:
19620 return NULL;
19621 }
19622
19623
19624 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19625 PyObject *resultobj;
19626 wxDateTime result;
19627 char *kwnames[] = {
19628 NULL
19629 };
19630
19631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19632 {
19633 PyThreadState* __tstate = wxPyBeginAllowThreads();
19634 result = wxDateTime::Now();
19635
19636 wxPyEndAllowThreads(__tstate);
19637 if (PyErr_Occurred()) SWIG_fail;
19638 }
19639 {
19640 wxDateTime * resultptr;
19641 resultptr = new wxDateTime((wxDateTime &)(result));
19642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19643 }
19644 return resultobj;
19645 fail:
19646 return NULL;
19647 }
19648
19649
19650 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19651 PyObject *resultobj;
19652 wxDateTime result;
19653 char *kwnames[] = {
19654 NULL
19655 };
19656
19657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19658 {
19659 PyThreadState* __tstate = wxPyBeginAllowThreads();
19660 result = wxDateTime::UNow();
19661
19662 wxPyEndAllowThreads(__tstate);
19663 if (PyErr_Occurred()) SWIG_fail;
19664 }
19665 {
19666 wxDateTime * resultptr;
19667 resultptr = new wxDateTime((wxDateTime &)(result));
19668 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19669 }
19670 return resultobj;
19671 fail:
19672 return NULL;
19673 }
19674
19675
19676 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19677 PyObject *resultobj;
19678 wxDateTime result;
19679 char *kwnames[] = {
19680 NULL
19681 };
19682
19683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19684 {
19685 PyThreadState* __tstate = wxPyBeginAllowThreads();
19686 result = wxDateTime::Today();
19687
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 {
19692 wxDateTime * resultptr;
19693 resultptr = new wxDateTime((wxDateTime &)(result));
19694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19695 }
19696 return resultobj;
19697 fail:
19698 return NULL;
19699 }
19700
19701
19702 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19703 PyObject *resultobj;
19704 wxDateTime *result;
19705 char *kwnames[] = {
19706 NULL
19707 };
19708
19709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19710 {
19711 PyThreadState* __tstate = wxPyBeginAllowThreads();
19712 result = (wxDateTime *)new wxDateTime();
19713
19714 wxPyEndAllowThreads(__tstate);
19715 if (PyErr_Occurred()) SWIG_fail;
19716 }
19717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19718 return resultobj;
19719 fail:
19720 return NULL;
19721 }
19722
19723
19724 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19725 PyObject *resultobj;
19726 time_t arg1 ;
19727 wxDateTime *result;
19728 PyObject * obj0 = 0 ;
19729 char *kwnames[] = {
19730 (char *) "timet", NULL
19731 };
19732
19733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19734 {
19735 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19736 if (SWIG_arg_fail(1)) SWIG_fail;
19737 }
19738 {
19739 PyThreadState* __tstate = wxPyBeginAllowThreads();
19740 result = (wxDateTime *)new wxDateTime(arg1);
19741
19742 wxPyEndAllowThreads(__tstate);
19743 if (PyErr_Occurred()) SWIG_fail;
19744 }
19745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19746 return resultobj;
19747 fail:
19748 return NULL;
19749 }
19750
19751
19752 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19753 PyObject *resultobj;
19754 double arg1 ;
19755 wxDateTime *result;
19756 PyObject * obj0 = 0 ;
19757 char *kwnames[] = {
19758 (char *) "jdn", NULL
19759 };
19760
19761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19762 {
19763 arg1 = (double)(SWIG_As_double(obj0));
19764 if (SWIG_arg_fail(1)) SWIG_fail;
19765 }
19766 {
19767 PyThreadState* __tstate = wxPyBeginAllowThreads();
19768 result = (wxDateTime *)new wxDateTime(arg1);
19769
19770 wxPyEndAllowThreads(__tstate);
19771 if (PyErr_Occurred()) SWIG_fail;
19772 }
19773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19774 return resultobj;
19775 fail:
19776 return NULL;
19777 }
19778
19779
19780 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19781 PyObject *resultobj;
19782 int arg1 ;
19783 int arg2 = (int) 0 ;
19784 int arg3 = (int) 0 ;
19785 int arg4 = (int) 0 ;
19786 wxDateTime *result;
19787 PyObject * obj0 = 0 ;
19788 PyObject * obj1 = 0 ;
19789 PyObject * obj2 = 0 ;
19790 PyObject * obj3 = 0 ;
19791 char *kwnames[] = {
19792 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19793 };
19794
19795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19796 {
19797 arg1 = (int)(SWIG_As_int(obj0));
19798 if (SWIG_arg_fail(1)) SWIG_fail;
19799 }
19800 if (obj1) {
19801 {
19802 arg2 = (int)(SWIG_As_int(obj1));
19803 if (SWIG_arg_fail(2)) SWIG_fail;
19804 }
19805 }
19806 if (obj2) {
19807 {
19808 arg3 = (int)(SWIG_As_int(obj2));
19809 if (SWIG_arg_fail(3)) SWIG_fail;
19810 }
19811 }
19812 if (obj3) {
19813 {
19814 arg4 = (int)(SWIG_As_int(obj3));
19815 if (SWIG_arg_fail(4)) SWIG_fail;
19816 }
19817 }
19818 {
19819 PyThreadState* __tstate = wxPyBeginAllowThreads();
19820 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19821
19822 wxPyEndAllowThreads(__tstate);
19823 if (PyErr_Occurred()) SWIG_fail;
19824 }
19825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19826 return resultobj;
19827 fail:
19828 return NULL;
19829 }
19830
19831
19832 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19833 PyObject *resultobj;
19834 int arg1 ;
19835 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19836 int arg3 = (int) wxDateTime::Inv_Year ;
19837 int arg4 = (int) 0 ;
19838 int arg5 = (int) 0 ;
19839 int arg6 = (int) 0 ;
19840 int arg7 = (int) 0 ;
19841 wxDateTime *result;
19842 PyObject * obj0 = 0 ;
19843 PyObject * obj1 = 0 ;
19844 PyObject * obj2 = 0 ;
19845 PyObject * obj3 = 0 ;
19846 PyObject * obj4 = 0 ;
19847 PyObject * obj5 = 0 ;
19848 PyObject * obj6 = 0 ;
19849 char *kwnames[] = {
19850 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19851 };
19852
19853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19854 {
19855 arg1 = (int)(SWIG_As_int(obj0));
19856 if (SWIG_arg_fail(1)) SWIG_fail;
19857 }
19858 if (obj1) {
19859 {
19860 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19861 if (SWIG_arg_fail(2)) SWIG_fail;
19862 }
19863 }
19864 if (obj2) {
19865 {
19866 arg3 = (int)(SWIG_As_int(obj2));
19867 if (SWIG_arg_fail(3)) SWIG_fail;
19868 }
19869 }
19870 if (obj3) {
19871 {
19872 arg4 = (int)(SWIG_As_int(obj3));
19873 if (SWIG_arg_fail(4)) SWIG_fail;
19874 }
19875 }
19876 if (obj4) {
19877 {
19878 arg5 = (int)(SWIG_As_int(obj4));
19879 if (SWIG_arg_fail(5)) SWIG_fail;
19880 }
19881 }
19882 if (obj5) {
19883 {
19884 arg6 = (int)(SWIG_As_int(obj5));
19885 if (SWIG_arg_fail(6)) SWIG_fail;
19886 }
19887 }
19888 if (obj6) {
19889 {
19890 arg7 = (int)(SWIG_As_int(obj6));
19891 if (SWIG_arg_fail(7)) SWIG_fail;
19892 }
19893 }
19894 {
19895 PyThreadState* __tstate = wxPyBeginAllowThreads();
19896 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19897
19898 wxPyEndAllowThreads(__tstate);
19899 if (PyErr_Occurred()) SWIG_fail;
19900 }
19901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19902 return resultobj;
19903 fail:
19904 return NULL;
19905 }
19906
19907
19908 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19909 PyObject *resultobj;
19910 wxDateTime *arg1 = (wxDateTime *) 0 ;
19911 PyObject * obj0 = 0 ;
19912 char *kwnames[] = {
19913 (char *) "self", NULL
19914 };
19915
19916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19918 if (SWIG_arg_fail(1)) SWIG_fail;
19919 {
19920 PyThreadState* __tstate = wxPyBeginAllowThreads();
19921 delete arg1;
19922
19923 wxPyEndAllowThreads(__tstate);
19924 if (PyErr_Occurred()) SWIG_fail;
19925 }
19926 Py_INCREF(Py_None); resultobj = Py_None;
19927 return resultobj;
19928 fail:
19929 return NULL;
19930 }
19931
19932
19933 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19934 PyObject *resultobj;
19935 wxDateTime *arg1 = (wxDateTime *) 0 ;
19936 wxDateTime *result;
19937 PyObject * obj0 = 0 ;
19938 char *kwnames[] = {
19939 (char *) "self", NULL
19940 };
19941
19942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19944 if (SWIG_arg_fail(1)) SWIG_fail;
19945 {
19946 PyThreadState* __tstate = wxPyBeginAllowThreads();
19947 {
19948 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19949 result = (wxDateTime *) &_result_ref;
19950 }
19951
19952 wxPyEndAllowThreads(__tstate);
19953 if (PyErr_Occurred()) SWIG_fail;
19954 }
19955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19956 return resultobj;
19957 fail:
19958 return NULL;
19959 }
19960
19961
19962 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19963 PyObject *resultobj;
19964 wxDateTime *arg1 = (wxDateTime *) 0 ;
19965 time_t arg2 ;
19966 wxDateTime *result;
19967 PyObject * obj0 = 0 ;
19968 PyObject * obj1 = 0 ;
19969 char *kwnames[] = {
19970 (char *) "self",(char *) "timet", NULL
19971 };
19972
19973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19975 if (SWIG_arg_fail(1)) SWIG_fail;
19976 {
19977 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19978 if (SWIG_arg_fail(2)) SWIG_fail;
19979 }
19980 {
19981 PyThreadState* __tstate = wxPyBeginAllowThreads();
19982 {
19983 wxDateTime &_result_ref = (arg1)->Set(arg2);
19984 result = (wxDateTime *) &_result_ref;
19985 }
19986
19987 wxPyEndAllowThreads(__tstate);
19988 if (PyErr_Occurred()) SWIG_fail;
19989 }
19990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19998 PyObject *resultobj;
19999 wxDateTime *arg1 = (wxDateTime *) 0 ;
20000 double arg2 ;
20001 wxDateTime *result;
20002 PyObject * obj0 = 0 ;
20003 PyObject * obj1 = 0 ;
20004 char *kwnames[] = {
20005 (char *) "self",(char *) "jdn", NULL
20006 };
20007
20008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20010 if (SWIG_arg_fail(1)) SWIG_fail;
20011 {
20012 arg2 = (double)(SWIG_As_double(obj1));
20013 if (SWIG_arg_fail(2)) SWIG_fail;
20014 }
20015 {
20016 PyThreadState* __tstate = wxPyBeginAllowThreads();
20017 {
20018 wxDateTime &_result_ref = (arg1)->Set(arg2);
20019 result = (wxDateTime *) &_result_ref;
20020 }
20021
20022 wxPyEndAllowThreads(__tstate);
20023 if (PyErr_Occurred()) SWIG_fail;
20024 }
20025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20026 return resultobj;
20027 fail:
20028 return NULL;
20029 }
20030
20031
20032 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20033 PyObject *resultobj;
20034 wxDateTime *arg1 = (wxDateTime *) 0 ;
20035 int arg2 ;
20036 int arg3 = (int) 0 ;
20037 int arg4 = (int) 0 ;
20038 int arg5 = (int) 0 ;
20039 wxDateTime *result;
20040 PyObject * obj0 = 0 ;
20041 PyObject * obj1 = 0 ;
20042 PyObject * obj2 = 0 ;
20043 PyObject * obj3 = 0 ;
20044 PyObject * obj4 = 0 ;
20045 char *kwnames[] = {
20046 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20047 };
20048
20049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20051 if (SWIG_arg_fail(1)) SWIG_fail;
20052 {
20053 arg2 = (int)(SWIG_As_int(obj1));
20054 if (SWIG_arg_fail(2)) SWIG_fail;
20055 }
20056 if (obj2) {
20057 {
20058 arg3 = (int)(SWIG_As_int(obj2));
20059 if (SWIG_arg_fail(3)) SWIG_fail;
20060 }
20061 }
20062 if (obj3) {
20063 {
20064 arg4 = (int)(SWIG_As_int(obj3));
20065 if (SWIG_arg_fail(4)) SWIG_fail;
20066 }
20067 }
20068 if (obj4) {
20069 {
20070 arg5 = (int)(SWIG_As_int(obj4));
20071 if (SWIG_arg_fail(5)) SWIG_fail;
20072 }
20073 }
20074 {
20075 PyThreadState* __tstate = wxPyBeginAllowThreads();
20076 {
20077 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20078 result = (wxDateTime *) &_result_ref;
20079 }
20080
20081 wxPyEndAllowThreads(__tstate);
20082 if (PyErr_Occurred()) SWIG_fail;
20083 }
20084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20085 return resultobj;
20086 fail:
20087 return NULL;
20088 }
20089
20090
20091 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20092 PyObject *resultobj;
20093 wxDateTime *arg1 = (wxDateTime *) 0 ;
20094 int arg2 ;
20095 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20096 int arg4 = (int) wxDateTime::Inv_Year ;
20097 int arg5 = (int) 0 ;
20098 int arg6 = (int) 0 ;
20099 int arg7 = (int) 0 ;
20100 int arg8 = (int) 0 ;
20101 wxDateTime *result;
20102 PyObject * obj0 = 0 ;
20103 PyObject * obj1 = 0 ;
20104 PyObject * obj2 = 0 ;
20105 PyObject * obj3 = 0 ;
20106 PyObject * obj4 = 0 ;
20107 PyObject * obj5 = 0 ;
20108 PyObject * obj6 = 0 ;
20109 PyObject * obj7 = 0 ;
20110 char *kwnames[] = {
20111 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20112 };
20113
20114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20116 if (SWIG_arg_fail(1)) SWIG_fail;
20117 {
20118 arg2 = (int)(SWIG_As_int(obj1));
20119 if (SWIG_arg_fail(2)) SWIG_fail;
20120 }
20121 if (obj2) {
20122 {
20123 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20124 if (SWIG_arg_fail(3)) SWIG_fail;
20125 }
20126 }
20127 if (obj3) {
20128 {
20129 arg4 = (int)(SWIG_As_int(obj3));
20130 if (SWIG_arg_fail(4)) SWIG_fail;
20131 }
20132 }
20133 if (obj4) {
20134 {
20135 arg5 = (int)(SWIG_As_int(obj4));
20136 if (SWIG_arg_fail(5)) SWIG_fail;
20137 }
20138 }
20139 if (obj5) {
20140 {
20141 arg6 = (int)(SWIG_As_int(obj5));
20142 if (SWIG_arg_fail(6)) SWIG_fail;
20143 }
20144 }
20145 if (obj6) {
20146 {
20147 arg7 = (int)(SWIG_As_int(obj6));
20148 if (SWIG_arg_fail(7)) SWIG_fail;
20149 }
20150 }
20151 if (obj7) {
20152 {
20153 arg8 = (int)(SWIG_As_int(obj7));
20154 if (SWIG_arg_fail(8)) SWIG_fail;
20155 }
20156 }
20157 {
20158 PyThreadState* __tstate = wxPyBeginAllowThreads();
20159 {
20160 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20161 result = (wxDateTime *) &_result_ref;
20162 }
20163
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20175 PyObject *resultobj;
20176 wxDateTime *arg1 = (wxDateTime *) 0 ;
20177 wxDateTime *result;
20178 PyObject * obj0 = 0 ;
20179 char *kwnames[] = {
20180 (char *) "self", NULL
20181 };
20182
20183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20185 if (SWIG_arg_fail(1)) SWIG_fail;
20186 {
20187 PyThreadState* __tstate = wxPyBeginAllowThreads();
20188 {
20189 wxDateTime &_result_ref = (arg1)->ResetTime();
20190 result = (wxDateTime *) &_result_ref;
20191 }
20192
20193 wxPyEndAllowThreads(__tstate);
20194 if (PyErr_Occurred()) SWIG_fail;
20195 }
20196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20204 PyObject *resultobj;
20205 wxDateTime *arg1 = (wxDateTime *) 0 ;
20206 int arg2 ;
20207 wxDateTime *result;
20208 PyObject * obj0 = 0 ;
20209 PyObject * obj1 = 0 ;
20210 char *kwnames[] = {
20211 (char *) "self",(char *) "year", NULL
20212 };
20213
20214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20216 if (SWIG_arg_fail(1)) SWIG_fail;
20217 {
20218 arg2 = (int)(SWIG_As_int(obj1));
20219 if (SWIG_arg_fail(2)) SWIG_fail;
20220 }
20221 {
20222 PyThreadState* __tstate = wxPyBeginAllowThreads();
20223 {
20224 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20225 result = (wxDateTime *) &_result_ref;
20226 }
20227
20228 wxPyEndAllowThreads(__tstate);
20229 if (PyErr_Occurred()) SWIG_fail;
20230 }
20231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20232 return resultobj;
20233 fail:
20234 return NULL;
20235 }
20236
20237
20238 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20239 PyObject *resultobj;
20240 wxDateTime *arg1 = (wxDateTime *) 0 ;
20241 wxDateTime::Month arg2 ;
20242 wxDateTime *result;
20243 PyObject * obj0 = 0 ;
20244 PyObject * obj1 = 0 ;
20245 char *kwnames[] = {
20246 (char *) "self",(char *) "month", NULL
20247 };
20248
20249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20251 if (SWIG_arg_fail(1)) SWIG_fail;
20252 {
20253 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20254 if (SWIG_arg_fail(2)) SWIG_fail;
20255 }
20256 {
20257 PyThreadState* __tstate = wxPyBeginAllowThreads();
20258 {
20259 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20260 result = (wxDateTime *) &_result_ref;
20261 }
20262
20263 wxPyEndAllowThreads(__tstate);
20264 if (PyErr_Occurred()) SWIG_fail;
20265 }
20266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20267 return resultobj;
20268 fail:
20269 return NULL;
20270 }
20271
20272
20273 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20274 PyObject *resultobj;
20275 wxDateTime *arg1 = (wxDateTime *) 0 ;
20276 int arg2 ;
20277 wxDateTime *result;
20278 PyObject * obj0 = 0 ;
20279 PyObject * obj1 = 0 ;
20280 char *kwnames[] = {
20281 (char *) "self",(char *) "day", NULL
20282 };
20283
20284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20286 if (SWIG_arg_fail(1)) SWIG_fail;
20287 {
20288 arg2 = (int)(SWIG_As_int(obj1));
20289 if (SWIG_arg_fail(2)) SWIG_fail;
20290 }
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 {
20294 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20295 result = (wxDateTime *) &_result_ref;
20296 }
20297
20298 wxPyEndAllowThreads(__tstate);
20299 if (PyErr_Occurred()) SWIG_fail;
20300 }
20301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20302 return resultobj;
20303 fail:
20304 return NULL;
20305 }
20306
20307
20308 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20309 PyObject *resultobj;
20310 wxDateTime *arg1 = (wxDateTime *) 0 ;
20311 int arg2 ;
20312 wxDateTime *result;
20313 PyObject * obj0 = 0 ;
20314 PyObject * obj1 = 0 ;
20315 char *kwnames[] = {
20316 (char *) "self",(char *) "hour", NULL
20317 };
20318
20319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20321 if (SWIG_arg_fail(1)) SWIG_fail;
20322 {
20323 arg2 = (int)(SWIG_As_int(obj1));
20324 if (SWIG_arg_fail(2)) SWIG_fail;
20325 }
20326 {
20327 PyThreadState* __tstate = wxPyBeginAllowThreads();
20328 {
20329 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20330 result = (wxDateTime *) &_result_ref;
20331 }
20332
20333 wxPyEndAllowThreads(__tstate);
20334 if (PyErr_Occurred()) SWIG_fail;
20335 }
20336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20337 return resultobj;
20338 fail:
20339 return NULL;
20340 }
20341
20342
20343 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20344 PyObject *resultobj;
20345 wxDateTime *arg1 = (wxDateTime *) 0 ;
20346 int arg2 ;
20347 wxDateTime *result;
20348 PyObject * obj0 = 0 ;
20349 PyObject * obj1 = 0 ;
20350 char *kwnames[] = {
20351 (char *) "self",(char *) "minute", NULL
20352 };
20353
20354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20356 if (SWIG_arg_fail(1)) SWIG_fail;
20357 {
20358 arg2 = (int)(SWIG_As_int(obj1));
20359 if (SWIG_arg_fail(2)) SWIG_fail;
20360 }
20361 {
20362 PyThreadState* __tstate = wxPyBeginAllowThreads();
20363 {
20364 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20365 result = (wxDateTime *) &_result_ref;
20366 }
20367
20368 wxPyEndAllowThreads(__tstate);
20369 if (PyErr_Occurred()) SWIG_fail;
20370 }
20371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20372 return resultobj;
20373 fail:
20374 return NULL;
20375 }
20376
20377
20378 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20379 PyObject *resultobj;
20380 wxDateTime *arg1 = (wxDateTime *) 0 ;
20381 int arg2 ;
20382 wxDateTime *result;
20383 PyObject * obj0 = 0 ;
20384 PyObject * obj1 = 0 ;
20385 char *kwnames[] = {
20386 (char *) "self",(char *) "second", NULL
20387 };
20388
20389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20391 if (SWIG_arg_fail(1)) SWIG_fail;
20392 {
20393 arg2 = (int)(SWIG_As_int(obj1));
20394 if (SWIG_arg_fail(2)) SWIG_fail;
20395 }
20396 {
20397 PyThreadState* __tstate = wxPyBeginAllowThreads();
20398 {
20399 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20400 result = (wxDateTime *) &_result_ref;
20401 }
20402
20403 wxPyEndAllowThreads(__tstate);
20404 if (PyErr_Occurred()) SWIG_fail;
20405 }
20406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20407 return resultobj;
20408 fail:
20409 return NULL;
20410 }
20411
20412
20413 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20414 PyObject *resultobj;
20415 wxDateTime *arg1 = (wxDateTime *) 0 ;
20416 int arg2 ;
20417 wxDateTime *result;
20418 PyObject * obj0 = 0 ;
20419 PyObject * obj1 = 0 ;
20420 char *kwnames[] = {
20421 (char *) "self",(char *) "millisecond", NULL
20422 };
20423
20424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20426 if (SWIG_arg_fail(1)) SWIG_fail;
20427 {
20428 arg2 = (int)(SWIG_As_int(obj1));
20429 if (SWIG_arg_fail(2)) SWIG_fail;
20430 }
20431 {
20432 PyThreadState* __tstate = wxPyBeginAllowThreads();
20433 {
20434 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20435 result = (wxDateTime *) &_result_ref;
20436 }
20437
20438 wxPyEndAllowThreads(__tstate);
20439 if (PyErr_Occurred()) SWIG_fail;
20440 }
20441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20442 return resultobj;
20443 fail:
20444 return NULL;
20445 }
20446
20447
20448 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20449 PyObject *resultobj;
20450 wxDateTime *arg1 = (wxDateTime *) 0 ;
20451 wxDateTime::WeekDay arg2 ;
20452 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20453 wxDateTime *result;
20454 PyObject * obj0 = 0 ;
20455 PyObject * obj1 = 0 ;
20456 PyObject * obj2 = 0 ;
20457 char *kwnames[] = {
20458 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20459 };
20460
20461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20463 if (SWIG_arg_fail(1)) SWIG_fail;
20464 {
20465 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20466 if (SWIG_arg_fail(2)) SWIG_fail;
20467 }
20468 if (obj2) {
20469 {
20470 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20471 if (SWIG_arg_fail(3)) SWIG_fail;
20472 }
20473 }
20474 {
20475 PyThreadState* __tstate = wxPyBeginAllowThreads();
20476 {
20477 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20478 result = (wxDateTime *) &_result_ref;
20479 }
20480
20481 wxPyEndAllowThreads(__tstate);
20482 if (PyErr_Occurred()) SWIG_fail;
20483 }
20484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20485 return resultobj;
20486 fail:
20487 return NULL;
20488 }
20489
20490
20491 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20492 PyObject *resultobj;
20493 wxDateTime *arg1 = (wxDateTime *) 0 ;
20494 wxDateTime::WeekDay arg2 ;
20495 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20496 wxDateTime result;
20497 PyObject * obj0 = 0 ;
20498 PyObject * obj1 = 0 ;
20499 PyObject * obj2 = 0 ;
20500 char *kwnames[] = {
20501 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20502 };
20503
20504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20506 if (SWIG_arg_fail(1)) SWIG_fail;
20507 {
20508 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20509 if (SWIG_arg_fail(2)) SWIG_fail;
20510 }
20511 if (obj2) {
20512 {
20513 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20514 if (SWIG_arg_fail(3)) SWIG_fail;
20515 }
20516 }
20517 {
20518 PyThreadState* __tstate = wxPyBeginAllowThreads();
20519 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20520
20521 wxPyEndAllowThreads(__tstate);
20522 if (PyErr_Occurred()) SWIG_fail;
20523 }
20524 {
20525 wxDateTime * resultptr;
20526 resultptr = new wxDateTime((wxDateTime &)(result));
20527 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20528 }
20529 return resultobj;
20530 fail:
20531 return NULL;
20532 }
20533
20534
20535 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20536 PyObject *resultobj;
20537 wxDateTime *arg1 = (wxDateTime *) 0 ;
20538 wxDateTime::WeekDay arg2 ;
20539 wxDateTime *result;
20540 PyObject * obj0 = 0 ;
20541 PyObject * obj1 = 0 ;
20542 char *kwnames[] = {
20543 (char *) "self",(char *) "weekday", NULL
20544 };
20545
20546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20548 if (SWIG_arg_fail(1)) SWIG_fail;
20549 {
20550 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20551 if (SWIG_arg_fail(2)) SWIG_fail;
20552 }
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 {
20556 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20557 result = (wxDateTime *) &_result_ref;
20558 }
20559
20560 wxPyEndAllowThreads(__tstate);
20561 if (PyErr_Occurred()) SWIG_fail;
20562 }
20563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20564 return resultobj;
20565 fail:
20566 return NULL;
20567 }
20568
20569
20570 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20571 PyObject *resultobj;
20572 wxDateTime *arg1 = (wxDateTime *) 0 ;
20573 wxDateTime::WeekDay arg2 ;
20574 wxDateTime result;
20575 PyObject * obj0 = 0 ;
20576 PyObject * obj1 = 0 ;
20577 char *kwnames[] = {
20578 (char *) "self",(char *) "weekday", NULL
20579 };
20580
20581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20583 if (SWIG_arg_fail(1)) SWIG_fail;
20584 {
20585 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20586 if (SWIG_arg_fail(2)) SWIG_fail;
20587 }
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20591
20592 wxPyEndAllowThreads(__tstate);
20593 if (PyErr_Occurred()) SWIG_fail;
20594 }
20595 {
20596 wxDateTime * resultptr;
20597 resultptr = new wxDateTime((wxDateTime &)(result));
20598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20599 }
20600 return resultobj;
20601 fail:
20602 return NULL;
20603 }
20604
20605
20606 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20607 PyObject *resultobj;
20608 wxDateTime *arg1 = (wxDateTime *) 0 ;
20609 wxDateTime::WeekDay arg2 ;
20610 wxDateTime *result;
20611 PyObject * obj0 = 0 ;
20612 PyObject * obj1 = 0 ;
20613 char *kwnames[] = {
20614 (char *) "self",(char *) "weekday", NULL
20615 };
20616
20617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20619 if (SWIG_arg_fail(1)) SWIG_fail;
20620 {
20621 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20622 if (SWIG_arg_fail(2)) SWIG_fail;
20623 }
20624 {
20625 PyThreadState* __tstate = wxPyBeginAllowThreads();
20626 {
20627 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20628 result = (wxDateTime *) &_result_ref;
20629 }
20630
20631 wxPyEndAllowThreads(__tstate);
20632 if (PyErr_Occurred()) SWIG_fail;
20633 }
20634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20642 PyObject *resultobj;
20643 wxDateTime *arg1 = (wxDateTime *) 0 ;
20644 wxDateTime::WeekDay arg2 ;
20645 wxDateTime result;
20646 PyObject * obj0 = 0 ;
20647 PyObject * obj1 = 0 ;
20648 char *kwnames[] = {
20649 (char *) "self",(char *) "weekday", NULL
20650 };
20651
20652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20654 if (SWIG_arg_fail(1)) SWIG_fail;
20655 {
20656 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20657 if (SWIG_arg_fail(2)) SWIG_fail;
20658 }
20659 {
20660 PyThreadState* __tstate = wxPyBeginAllowThreads();
20661 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20662
20663 wxPyEndAllowThreads(__tstate);
20664 if (PyErr_Occurred()) SWIG_fail;
20665 }
20666 {
20667 wxDateTime * resultptr;
20668 resultptr = new wxDateTime((wxDateTime &)(result));
20669 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20670 }
20671 return resultobj;
20672 fail:
20673 return NULL;
20674 }
20675
20676
20677 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20678 PyObject *resultobj;
20679 wxDateTime *arg1 = (wxDateTime *) 0 ;
20680 wxDateTime::WeekDay arg2 ;
20681 int arg3 = (int) 1 ;
20682 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20683 int arg5 = (int) wxDateTime::Inv_Year ;
20684 bool result;
20685 PyObject * obj0 = 0 ;
20686 PyObject * obj1 = 0 ;
20687 PyObject * obj2 = 0 ;
20688 PyObject * obj3 = 0 ;
20689 PyObject * obj4 = 0 ;
20690 char *kwnames[] = {
20691 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20692 };
20693
20694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20696 if (SWIG_arg_fail(1)) SWIG_fail;
20697 {
20698 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20699 if (SWIG_arg_fail(2)) SWIG_fail;
20700 }
20701 if (obj2) {
20702 {
20703 arg3 = (int)(SWIG_As_int(obj2));
20704 if (SWIG_arg_fail(3)) SWIG_fail;
20705 }
20706 }
20707 if (obj3) {
20708 {
20709 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20710 if (SWIG_arg_fail(4)) SWIG_fail;
20711 }
20712 }
20713 if (obj4) {
20714 {
20715 arg5 = (int)(SWIG_As_int(obj4));
20716 if (SWIG_arg_fail(5)) SWIG_fail;
20717 }
20718 }
20719 {
20720 PyThreadState* __tstate = wxPyBeginAllowThreads();
20721 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20722
20723 wxPyEndAllowThreads(__tstate);
20724 if (PyErr_Occurred()) SWIG_fail;
20725 }
20726 {
20727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20736 PyObject *resultobj;
20737 wxDateTime *arg1 = (wxDateTime *) 0 ;
20738 wxDateTime::WeekDay arg2 ;
20739 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20740 int arg4 = (int) wxDateTime::Inv_Year ;
20741 bool result;
20742 PyObject * obj0 = 0 ;
20743 PyObject * obj1 = 0 ;
20744 PyObject * obj2 = 0 ;
20745 PyObject * obj3 = 0 ;
20746 char *kwnames[] = {
20747 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20748 };
20749
20750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20752 if (SWIG_arg_fail(1)) SWIG_fail;
20753 {
20754 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20755 if (SWIG_arg_fail(2)) SWIG_fail;
20756 }
20757 if (obj2) {
20758 {
20759 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20760 if (SWIG_arg_fail(3)) SWIG_fail;
20761 }
20762 }
20763 if (obj3) {
20764 {
20765 arg4 = (int)(SWIG_As_int(obj3));
20766 if (SWIG_arg_fail(4)) SWIG_fail;
20767 }
20768 }
20769 {
20770 PyThreadState* __tstate = wxPyBeginAllowThreads();
20771 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20772
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 {
20777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20778 }
20779 return resultobj;
20780 fail:
20781 return NULL;
20782 }
20783
20784
20785 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20786 PyObject *resultobj;
20787 wxDateTime *arg1 = (wxDateTime *) 0 ;
20788 wxDateTime::WeekDay arg2 ;
20789 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20790 int arg4 = (int) wxDateTime::Inv_Year ;
20791 wxDateTime result;
20792 PyObject * obj0 = 0 ;
20793 PyObject * obj1 = 0 ;
20794 PyObject * obj2 = 0 ;
20795 PyObject * obj3 = 0 ;
20796 char *kwnames[] = {
20797 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20798 };
20799
20800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20802 if (SWIG_arg_fail(1)) SWIG_fail;
20803 {
20804 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20805 if (SWIG_arg_fail(2)) SWIG_fail;
20806 }
20807 if (obj2) {
20808 {
20809 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20810 if (SWIG_arg_fail(3)) SWIG_fail;
20811 }
20812 }
20813 if (obj3) {
20814 {
20815 arg4 = (int)(SWIG_As_int(obj3));
20816 if (SWIG_arg_fail(4)) SWIG_fail;
20817 }
20818 }
20819 {
20820 PyThreadState* __tstate = wxPyBeginAllowThreads();
20821 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20822
20823 wxPyEndAllowThreads(__tstate);
20824 if (PyErr_Occurred()) SWIG_fail;
20825 }
20826 {
20827 wxDateTime * resultptr;
20828 resultptr = new wxDateTime((wxDateTime &)(result));
20829 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20830 }
20831 return resultobj;
20832 fail:
20833 return NULL;
20834 }
20835
20836
20837 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20838 PyObject *resultobj;
20839 wxDateTime *arg1 = (wxDateTime *) 0 ;
20840 int arg2 ;
20841 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20842 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20843 bool result;
20844 PyObject * obj0 = 0 ;
20845 PyObject * obj1 = 0 ;
20846 PyObject * obj2 = 0 ;
20847 PyObject * obj3 = 0 ;
20848 char *kwnames[] = {
20849 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20850 };
20851
20852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20854 if (SWIG_arg_fail(1)) SWIG_fail;
20855 {
20856 arg2 = (int)(SWIG_As_int(obj1));
20857 if (SWIG_arg_fail(2)) SWIG_fail;
20858 }
20859 if (obj2) {
20860 {
20861 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20862 if (SWIG_arg_fail(3)) SWIG_fail;
20863 }
20864 }
20865 if (obj3) {
20866 {
20867 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20868 if (SWIG_arg_fail(4)) SWIG_fail;
20869 }
20870 }
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20874
20875 wxPyEndAllowThreads(__tstate);
20876 if (PyErr_Occurred()) SWIG_fail;
20877 }
20878 {
20879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20880 }
20881 return resultobj;
20882 fail:
20883 return NULL;
20884 }
20885
20886
20887 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20888 PyObject *resultobj;
20889 wxDateTime *arg1 = (wxDateTime *) 0 ;
20890 int arg2 ;
20891 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20892 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20893 wxDateTime result;
20894 PyObject * obj0 = 0 ;
20895 PyObject * obj1 = 0 ;
20896 PyObject * obj2 = 0 ;
20897 PyObject * obj3 = 0 ;
20898 char *kwnames[] = {
20899 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20900 };
20901
20902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20904 if (SWIG_arg_fail(1)) SWIG_fail;
20905 {
20906 arg2 = (int)(SWIG_As_int(obj1));
20907 if (SWIG_arg_fail(2)) SWIG_fail;
20908 }
20909 if (obj2) {
20910 {
20911 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20912 if (SWIG_arg_fail(3)) SWIG_fail;
20913 }
20914 }
20915 if (obj3) {
20916 {
20917 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20918 if (SWIG_arg_fail(4)) SWIG_fail;
20919 }
20920 }
20921 {
20922 PyThreadState* __tstate = wxPyBeginAllowThreads();
20923 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20924
20925 wxPyEndAllowThreads(__tstate);
20926 if (PyErr_Occurred()) SWIG_fail;
20927 }
20928 {
20929 wxDateTime * resultptr;
20930 resultptr = new wxDateTime((wxDateTime &)(result));
20931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20932 }
20933 return resultobj;
20934 fail:
20935 return NULL;
20936 }
20937
20938
20939 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20940 PyObject *resultobj;
20941 int arg1 ;
20942 int arg2 ;
20943 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20944 wxDateTime result;
20945 PyObject * obj0 = 0 ;
20946 PyObject * obj1 = 0 ;
20947 PyObject * obj2 = 0 ;
20948 char *kwnames[] = {
20949 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20950 };
20951
20952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20953 {
20954 arg1 = (int)(SWIG_As_int(obj0));
20955 if (SWIG_arg_fail(1)) SWIG_fail;
20956 }
20957 {
20958 arg2 = (int)(SWIG_As_int(obj1));
20959 if (SWIG_arg_fail(2)) SWIG_fail;
20960 }
20961 if (obj2) {
20962 {
20963 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20964 if (SWIG_arg_fail(3)) SWIG_fail;
20965 }
20966 }
20967 {
20968 PyThreadState* __tstate = wxPyBeginAllowThreads();
20969 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20970
20971 wxPyEndAllowThreads(__tstate);
20972 if (PyErr_Occurred()) SWIG_fail;
20973 }
20974 {
20975 wxDateTime * resultptr;
20976 resultptr = new wxDateTime((wxDateTime &)(result));
20977 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20978 }
20979 return resultobj;
20980 fail:
20981 return NULL;
20982 }
20983
20984
20985 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20986 PyObject *resultobj;
20987 wxDateTime *arg1 = (wxDateTime *) 0 ;
20988 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20989 int arg3 = (int) wxDateTime::Inv_Year ;
20990 wxDateTime *result;
20991 PyObject * obj0 = 0 ;
20992 PyObject * obj1 = 0 ;
20993 PyObject * obj2 = 0 ;
20994 char *kwnames[] = {
20995 (char *) "self",(char *) "month",(char *) "year", NULL
20996 };
20997
20998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21000 if (SWIG_arg_fail(1)) SWIG_fail;
21001 if (obj1) {
21002 {
21003 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21004 if (SWIG_arg_fail(2)) SWIG_fail;
21005 }
21006 }
21007 if (obj2) {
21008 {
21009 arg3 = (int)(SWIG_As_int(obj2));
21010 if (SWIG_arg_fail(3)) SWIG_fail;
21011 }
21012 }
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 {
21016 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
21017 result = (wxDateTime *) &_result_ref;
21018 }
21019
21020 wxPyEndAllowThreads(__tstate);
21021 if (PyErr_Occurred()) SWIG_fail;
21022 }
21023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21024 return resultobj;
21025 fail:
21026 return NULL;
21027 }
21028
21029
21030 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21031 PyObject *resultobj;
21032 wxDateTime *arg1 = (wxDateTime *) 0 ;
21033 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21034 int arg3 = (int) wxDateTime::Inv_Year ;
21035 wxDateTime result;
21036 PyObject * obj0 = 0 ;
21037 PyObject * obj1 = 0 ;
21038 PyObject * obj2 = 0 ;
21039 char *kwnames[] = {
21040 (char *) "self",(char *) "month",(char *) "year", NULL
21041 };
21042
21043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21045 if (SWIG_arg_fail(1)) SWIG_fail;
21046 if (obj1) {
21047 {
21048 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21049 if (SWIG_arg_fail(2)) SWIG_fail;
21050 }
21051 }
21052 if (obj2) {
21053 {
21054 arg3 = (int)(SWIG_As_int(obj2));
21055 if (SWIG_arg_fail(3)) SWIG_fail;
21056 }
21057 }
21058 {
21059 PyThreadState* __tstate = wxPyBeginAllowThreads();
21060 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21061
21062 wxPyEndAllowThreads(__tstate);
21063 if (PyErr_Occurred()) SWIG_fail;
21064 }
21065 {
21066 wxDateTime * resultptr;
21067 resultptr = new wxDateTime((wxDateTime &)(result));
21068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21069 }
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21077 PyObject *resultobj;
21078 wxDateTime *arg1 = (wxDateTime *) 0 ;
21079 int arg2 ;
21080 wxDateTime *result;
21081 PyObject * obj0 = 0 ;
21082 PyObject * obj1 = 0 ;
21083 char *kwnames[] = {
21084 (char *) "self",(char *) "yday", NULL
21085 };
21086
21087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21089 if (SWIG_arg_fail(1)) SWIG_fail;
21090 {
21091 arg2 = (int)(SWIG_As_int(obj1));
21092 if (SWIG_arg_fail(2)) SWIG_fail;
21093 }
21094 {
21095 PyThreadState* __tstate = wxPyBeginAllowThreads();
21096 {
21097 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21098 result = (wxDateTime *) &_result_ref;
21099 }
21100
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21112 PyObject *resultobj;
21113 wxDateTime *arg1 = (wxDateTime *) 0 ;
21114 int arg2 ;
21115 wxDateTime result;
21116 PyObject * obj0 = 0 ;
21117 PyObject * obj1 = 0 ;
21118 char *kwnames[] = {
21119 (char *) "self",(char *) "yday", NULL
21120 };
21121
21122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21124 if (SWIG_arg_fail(1)) SWIG_fail;
21125 {
21126 arg2 = (int)(SWIG_As_int(obj1));
21127 if (SWIG_arg_fail(2)) SWIG_fail;
21128 }
21129 {
21130 PyThreadState* __tstate = wxPyBeginAllowThreads();
21131 result = (arg1)->GetYearDay(arg2);
21132
21133 wxPyEndAllowThreads(__tstate);
21134 if (PyErr_Occurred()) SWIG_fail;
21135 }
21136 {
21137 wxDateTime * resultptr;
21138 resultptr = new wxDateTime((wxDateTime &)(result));
21139 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21140 }
21141 return resultobj;
21142 fail:
21143 return NULL;
21144 }
21145
21146
21147 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21148 PyObject *resultobj;
21149 wxDateTime *arg1 = (wxDateTime *) 0 ;
21150 double result;
21151 PyObject * obj0 = 0 ;
21152 char *kwnames[] = {
21153 (char *) "self", NULL
21154 };
21155
21156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21158 if (SWIG_arg_fail(1)) SWIG_fail;
21159 {
21160 PyThreadState* __tstate = wxPyBeginAllowThreads();
21161 result = (double)(arg1)->GetJulianDayNumber();
21162
21163 wxPyEndAllowThreads(__tstate);
21164 if (PyErr_Occurred()) SWIG_fail;
21165 }
21166 {
21167 resultobj = SWIG_From_double((double)(result));
21168 }
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21176 PyObject *resultobj;
21177 wxDateTime *arg1 = (wxDateTime *) 0 ;
21178 double result;
21179 PyObject * obj0 = 0 ;
21180 char *kwnames[] = {
21181 (char *) "self", NULL
21182 };
21183
21184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21186 if (SWIG_arg_fail(1)) SWIG_fail;
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 result = (double)(arg1)->GetJDN();
21190
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 {
21195 resultobj = SWIG_From_double((double)(result));
21196 }
21197 return resultobj;
21198 fail:
21199 return NULL;
21200 }
21201
21202
21203 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21204 PyObject *resultobj;
21205 wxDateTime *arg1 = (wxDateTime *) 0 ;
21206 double result;
21207 PyObject * obj0 = 0 ;
21208 char *kwnames[] = {
21209 (char *) "self", NULL
21210 };
21211
21212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21214 if (SWIG_arg_fail(1)) SWIG_fail;
21215 {
21216 PyThreadState* __tstate = wxPyBeginAllowThreads();
21217 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21218
21219 wxPyEndAllowThreads(__tstate);
21220 if (PyErr_Occurred()) SWIG_fail;
21221 }
21222 {
21223 resultobj = SWIG_From_double((double)(result));
21224 }
21225 return resultobj;
21226 fail:
21227 return NULL;
21228 }
21229
21230
21231 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21232 PyObject *resultobj;
21233 wxDateTime *arg1 = (wxDateTime *) 0 ;
21234 double result;
21235 PyObject * obj0 = 0 ;
21236 char *kwnames[] = {
21237 (char *) "self", NULL
21238 };
21239
21240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21242 if (SWIG_arg_fail(1)) SWIG_fail;
21243 {
21244 PyThreadState* __tstate = wxPyBeginAllowThreads();
21245 result = (double)(arg1)->GetMJD();
21246
21247 wxPyEndAllowThreads(__tstate);
21248 if (PyErr_Occurred()) SWIG_fail;
21249 }
21250 {
21251 resultobj = SWIG_From_double((double)(result));
21252 }
21253 return resultobj;
21254 fail:
21255 return NULL;
21256 }
21257
21258
21259 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21260 PyObject *resultobj;
21261 wxDateTime *arg1 = (wxDateTime *) 0 ;
21262 double result;
21263 PyObject * obj0 = 0 ;
21264 char *kwnames[] = {
21265 (char *) "self", NULL
21266 };
21267
21268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21270 if (SWIG_arg_fail(1)) SWIG_fail;
21271 {
21272 PyThreadState* __tstate = wxPyBeginAllowThreads();
21273 result = (double)(arg1)->GetRataDie();
21274
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 {
21279 resultobj = SWIG_From_double((double)(result));
21280 }
21281 return resultobj;
21282 fail:
21283 return NULL;
21284 }
21285
21286
21287 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21288 PyObject *resultobj;
21289 wxDateTime *arg1 = (wxDateTime *) 0 ;
21290 wxDateTime::TimeZone *arg2 = 0 ;
21291 bool arg3 = (bool) false ;
21292 wxDateTime result;
21293 bool temp2 = false ;
21294 PyObject * obj0 = 0 ;
21295 PyObject * obj1 = 0 ;
21296 PyObject * obj2 = 0 ;
21297 char *kwnames[] = {
21298 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21299 };
21300
21301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21303 if (SWIG_arg_fail(1)) SWIG_fail;
21304 {
21305 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21306 temp2 = true;
21307 }
21308 if (obj2) {
21309 {
21310 arg3 = (bool)(SWIG_As_bool(obj2));
21311 if (SWIG_arg_fail(3)) SWIG_fail;
21312 }
21313 }
21314 {
21315 PyThreadState* __tstate = wxPyBeginAllowThreads();
21316 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21317
21318 wxPyEndAllowThreads(__tstate);
21319 if (PyErr_Occurred()) SWIG_fail;
21320 }
21321 {
21322 wxDateTime * resultptr;
21323 resultptr = new wxDateTime((wxDateTime &)(result));
21324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21325 }
21326 {
21327 if (temp2) delete arg2;
21328 }
21329 return resultobj;
21330 fail:
21331 {
21332 if (temp2) delete arg2;
21333 }
21334 return NULL;
21335 }
21336
21337
21338 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21339 PyObject *resultobj;
21340 wxDateTime *arg1 = (wxDateTime *) 0 ;
21341 wxDateTime::TimeZone *arg2 = 0 ;
21342 bool arg3 = (bool) false ;
21343 wxDateTime *result;
21344 bool temp2 = false ;
21345 PyObject * obj0 = 0 ;
21346 PyObject * obj1 = 0 ;
21347 PyObject * obj2 = 0 ;
21348 char *kwnames[] = {
21349 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21350 };
21351
21352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21354 if (SWIG_arg_fail(1)) SWIG_fail;
21355 {
21356 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21357 temp2 = true;
21358 }
21359 if (obj2) {
21360 {
21361 arg3 = (bool)(SWIG_As_bool(obj2));
21362 if (SWIG_arg_fail(3)) SWIG_fail;
21363 }
21364 }
21365 {
21366 PyThreadState* __tstate = wxPyBeginAllowThreads();
21367 {
21368 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21369 result = (wxDateTime *) &_result_ref;
21370 }
21371
21372 wxPyEndAllowThreads(__tstate);
21373 if (PyErr_Occurred()) SWIG_fail;
21374 }
21375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21376 {
21377 if (temp2) delete arg2;
21378 }
21379 return resultobj;
21380 fail:
21381 {
21382 if (temp2) delete arg2;
21383 }
21384 return NULL;
21385 }
21386
21387
21388 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21389 PyObject *resultobj;
21390 wxDateTime *arg1 = (wxDateTime *) 0 ;
21391 bool arg2 = (bool) false ;
21392 wxDateTime result;
21393 PyObject * obj0 = 0 ;
21394 PyObject * obj1 = 0 ;
21395 char *kwnames[] = {
21396 (char *) "self",(char *) "noDST", NULL
21397 };
21398
21399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21401 if (SWIG_arg_fail(1)) SWIG_fail;
21402 if (obj1) {
21403 {
21404 arg2 = (bool)(SWIG_As_bool(obj1));
21405 if (SWIG_arg_fail(2)) SWIG_fail;
21406 }
21407 }
21408 {
21409 PyThreadState* __tstate = wxPyBeginAllowThreads();
21410 result = (arg1)->ToGMT(arg2);
21411
21412 wxPyEndAllowThreads(__tstate);
21413 if (PyErr_Occurred()) SWIG_fail;
21414 }
21415 {
21416 wxDateTime * resultptr;
21417 resultptr = new wxDateTime((wxDateTime &)(result));
21418 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21419 }
21420 return resultobj;
21421 fail:
21422 return NULL;
21423 }
21424
21425
21426 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21427 PyObject *resultobj;
21428 wxDateTime *arg1 = (wxDateTime *) 0 ;
21429 bool arg2 = (bool) false ;
21430 wxDateTime *result;
21431 PyObject * obj0 = 0 ;
21432 PyObject * obj1 = 0 ;
21433 char *kwnames[] = {
21434 (char *) "self",(char *) "noDST", NULL
21435 };
21436
21437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21439 if (SWIG_arg_fail(1)) SWIG_fail;
21440 if (obj1) {
21441 {
21442 arg2 = (bool)(SWIG_As_bool(obj1));
21443 if (SWIG_arg_fail(2)) SWIG_fail;
21444 }
21445 }
21446 {
21447 PyThreadState* __tstate = wxPyBeginAllowThreads();
21448 {
21449 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21450 result = (wxDateTime *) &_result_ref;
21451 }
21452
21453 wxPyEndAllowThreads(__tstate);
21454 if (PyErr_Occurred()) SWIG_fail;
21455 }
21456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21457 return resultobj;
21458 fail:
21459 return NULL;
21460 }
21461
21462
21463 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21464 PyObject *resultobj;
21465 wxDateTime *arg1 = (wxDateTime *) 0 ;
21466 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21467 int result;
21468 PyObject * obj0 = 0 ;
21469 PyObject * obj1 = 0 ;
21470 char *kwnames[] = {
21471 (char *) "self",(char *) "country", NULL
21472 };
21473
21474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",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 = (wxDateTime::Country)(SWIG_As_int(obj1));
21480 if (SWIG_arg_fail(2)) SWIG_fail;
21481 }
21482 }
21483 {
21484 PyThreadState* __tstate = wxPyBeginAllowThreads();
21485 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21486
21487 wxPyEndAllowThreads(__tstate);
21488 if (PyErr_Occurred()) SWIG_fail;
21489 }
21490 {
21491 resultobj = SWIG_From_int((int)(result));
21492 }
21493 return resultobj;
21494 fail:
21495 return NULL;
21496 }
21497
21498
21499 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21500 PyObject *resultobj;
21501 wxDateTime *arg1 = (wxDateTime *) 0 ;
21502 bool result;
21503 PyObject * obj0 = 0 ;
21504 char *kwnames[] = {
21505 (char *) "self", NULL
21506 };
21507
21508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21510 if (SWIG_arg_fail(1)) SWIG_fail;
21511 {
21512 PyThreadState* __tstate = wxPyBeginAllowThreads();
21513 result = (bool)((wxDateTime const *)arg1)->IsValid();
21514
21515 wxPyEndAllowThreads(__tstate);
21516 if (PyErr_Occurred()) SWIG_fail;
21517 }
21518 {
21519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21520 }
21521 return resultobj;
21522 fail:
21523 return NULL;
21524 }
21525
21526
21527 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21528 PyObject *resultobj;
21529 wxDateTime *arg1 = (wxDateTime *) 0 ;
21530 time_t result;
21531 PyObject * obj0 = 0 ;
21532 char *kwnames[] = {
21533 (char *) "self", NULL
21534 };
21535
21536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21538 if (SWIG_arg_fail(1)) SWIG_fail;
21539 {
21540 PyThreadState* __tstate = wxPyBeginAllowThreads();
21541 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21542
21543 wxPyEndAllowThreads(__tstate);
21544 if (PyErr_Occurred()) SWIG_fail;
21545 }
21546 {
21547 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21548 }
21549 return resultobj;
21550 fail:
21551 return NULL;
21552 }
21553
21554
21555 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21556 PyObject *resultobj;
21557 wxDateTime *arg1 = (wxDateTime *) 0 ;
21558 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21559 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21560 int result;
21561 bool temp2 = false ;
21562 PyObject * obj0 = 0 ;
21563 PyObject * obj1 = 0 ;
21564 char *kwnames[] = {
21565 (char *) "self",(char *) "tz", NULL
21566 };
21567
21568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21570 if (SWIG_arg_fail(1)) SWIG_fail;
21571 if (obj1) {
21572 {
21573 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21574 temp2 = true;
21575 }
21576 }
21577 {
21578 PyThreadState* __tstate = wxPyBeginAllowThreads();
21579 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21580
21581 wxPyEndAllowThreads(__tstate);
21582 if (PyErr_Occurred()) SWIG_fail;
21583 }
21584 {
21585 resultobj = SWIG_From_int((int)(result));
21586 }
21587 {
21588 if (temp2) delete arg2;
21589 }
21590 return resultobj;
21591 fail:
21592 {
21593 if (temp2) delete arg2;
21594 }
21595 return NULL;
21596 }
21597
21598
21599 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21600 PyObject *resultobj;
21601 wxDateTime *arg1 = (wxDateTime *) 0 ;
21602 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21603 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21604 wxDateTime::Month result;
21605 bool temp2 = false ;
21606 PyObject * obj0 = 0 ;
21607 PyObject * obj1 = 0 ;
21608 char *kwnames[] = {
21609 (char *) "self",(char *) "tz", NULL
21610 };
21611
21612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21614 if (SWIG_arg_fail(1)) SWIG_fail;
21615 if (obj1) {
21616 {
21617 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21618 temp2 = true;
21619 }
21620 }
21621 {
21622 PyThreadState* __tstate = wxPyBeginAllowThreads();
21623 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21624
21625 wxPyEndAllowThreads(__tstate);
21626 if (PyErr_Occurred()) SWIG_fail;
21627 }
21628 resultobj = SWIG_From_int((result));
21629 {
21630 if (temp2) delete arg2;
21631 }
21632 return resultobj;
21633 fail:
21634 {
21635 if (temp2) delete arg2;
21636 }
21637 return NULL;
21638 }
21639
21640
21641 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21642 PyObject *resultobj;
21643 wxDateTime *arg1 = (wxDateTime *) 0 ;
21644 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21645 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21646 int result;
21647 bool temp2 = false ;
21648 PyObject * obj0 = 0 ;
21649 PyObject * obj1 = 0 ;
21650 char *kwnames[] = {
21651 (char *) "self",(char *) "tz", NULL
21652 };
21653
21654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21656 if (SWIG_arg_fail(1)) SWIG_fail;
21657 if (obj1) {
21658 {
21659 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21660 temp2 = true;
21661 }
21662 }
21663 {
21664 PyThreadState* __tstate = wxPyBeginAllowThreads();
21665 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21666
21667 wxPyEndAllowThreads(__tstate);
21668 if (PyErr_Occurred()) SWIG_fail;
21669 }
21670 {
21671 resultobj = SWIG_From_int((int)(result));
21672 }
21673 {
21674 if (temp2) delete arg2;
21675 }
21676 return resultobj;
21677 fail:
21678 {
21679 if (temp2) delete arg2;
21680 }
21681 return NULL;
21682 }
21683
21684
21685 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21686 PyObject *resultobj;
21687 wxDateTime *arg1 = (wxDateTime *) 0 ;
21688 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21689 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21690 wxDateTime::WeekDay result;
21691 bool temp2 = false ;
21692 PyObject * obj0 = 0 ;
21693 PyObject * obj1 = 0 ;
21694 char *kwnames[] = {
21695 (char *) "self",(char *) "tz", NULL
21696 };
21697
21698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21700 if (SWIG_arg_fail(1)) SWIG_fail;
21701 if (obj1) {
21702 {
21703 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21704 temp2 = true;
21705 }
21706 }
21707 {
21708 PyThreadState* __tstate = wxPyBeginAllowThreads();
21709 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21710
21711 wxPyEndAllowThreads(__tstate);
21712 if (PyErr_Occurred()) SWIG_fail;
21713 }
21714 resultobj = SWIG_From_int((result));
21715 {
21716 if (temp2) delete arg2;
21717 }
21718 return resultobj;
21719 fail:
21720 {
21721 if (temp2) delete arg2;
21722 }
21723 return NULL;
21724 }
21725
21726
21727 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21728 PyObject *resultobj;
21729 wxDateTime *arg1 = (wxDateTime *) 0 ;
21730 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21731 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21732 int result;
21733 bool temp2 = false ;
21734 PyObject * obj0 = 0 ;
21735 PyObject * obj1 = 0 ;
21736 char *kwnames[] = {
21737 (char *) "self",(char *) "tz", NULL
21738 };
21739
21740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21742 if (SWIG_arg_fail(1)) SWIG_fail;
21743 if (obj1) {
21744 {
21745 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21746 temp2 = true;
21747 }
21748 }
21749 {
21750 PyThreadState* __tstate = wxPyBeginAllowThreads();
21751 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21752
21753 wxPyEndAllowThreads(__tstate);
21754 if (PyErr_Occurred()) SWIG_fail;
21755 }
21756 {
21757 resultobj = SWIG_From_int((int)(result));
21758 }
21759 {
21760 if (temp2) delete arg2;
21761 }
21762 return resultobj;
21763 fail:
21764 {
21765 if (temp2) delete arg2;
21766 }
21767 return NULL;
21768 }
21769
21770
21771 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21772 PyObject *resultobj;
21773 wxDateTime *arg1 = (wxDateTime *) 0 ;
21774 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21775 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21776 int result;
21777 bool temp2 = false ;
21778 PyObject * obj0 = 0 ;
21779 PyObject * obj1 = 0 ;
21780 char *kwnames[] = {
21781 (char *) "self",(char *) "tz", NULL
21782 };
21783
21784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21786 if (SWIG_arg_fail(1)) SWIG_fail;
21787 if (obj1) {
21788 {
21789 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21790 temp2 = true;
21791 }
21792 }
21793 {
21794 PyThreadState* __tstate = wxPyBeginAllowThreads();
21795 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21796
21797 wxPyEndAllowThreads(__tstate);
21798 if (PyErr_Occurred()) SWIG_fail;
21799 }
21800 {
21801 resultobj = SWIG_From_int((int)(result));
21802 }
21803 {
21804 if (temp2) delete arg2;
21805 }
21806 return resultobj;
21807 fail:
21808 {
21809 if (temp2) delete arg2;
21810 }
21811 return NULL;
21812 }
21813
21814
21815 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21816 PyObject *resultobj;
21817 wxDateTime *arg1 = (wxDateTime *) 0 ;
21818 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21819 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21820 int result;
21821 bool temp2 = false ;
21822 PyObject * obj0 = 0 ;
21823 PyObject * obj1 = 0 ;
21824 char *kwnames[] = {
21825 (char *) "self",(char *) "tz", NULL
21826 };
21827
21828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21830 if (SWIG_arg_fail(1)) SWIG_fail;
21831 if (obj1) {
21832 {
21833 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21834 temp2 = true;
21835 }
21836 }
21837 {
21838 PyThreadState* __tstate = wxPyBeginAllowThreads();
21839 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21840
21841 wxPyEndAllowThreads(__tstate);
21842 if (PyErr_Occurred()) SWIG_fail;
21843 }
21844 {
21845 resultobj = SWIG_From_int((int)(result));
21846 }
21847 {
21848 if (temp2) delete arg2;
21849 }
21850 return resultobj;
21851 fail:
21852 {
21853 if (temp2) delete arg2;
21854 }
21855 return NULL;
21856 }
21857
21858
21859 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21860 PyObject *resultobj;
21861 wxDateTime *arg1 = (wxDateTime *) 0 ;
21862 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21863 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21864 int result;
21865 bool temp2 = false ;
21866 PyObject * obj0 = 0 ;
21867 PyObject * obj1 = 0 ;
21868 char *kwnames[] = {
21869 (char *) "self",(char *) "tz", NULL
21870 };
21871
21872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21874 if (SWIG_arg_fail(1)) SWIG_fail;
21875 if (obj1) {
21876 {
21877 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21878 temp2 = true;
21879 }
21880 }
21881 {
21882 PyThreadState* __tstate = wxPyBeginAllowThreads();
21883 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21884
21885 wxPyEndAllowThreads(__tstate);
21886 if (PyErr_Occurred()) SWIG_fail;
21887 }
21888 {
21889 resultobj = SWIG_From_int((int)(result));
21890 }
21891 {
21892 if (temp2) delete arg2;
21893 }
21894 return resultobj;
21895 fail:
21896 {
21897 if (temp2) delete arg2;
21898 }
21899 return NULL;
21900 }
21901
21902
21903 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21904 PyObject *resultobj;
21905 wxDateTime *arg1 = (wxDateTime *) 0 ;
21906 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21907 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21908 int result;
21909 bool temp2 = false ;
21910 PyObject * obj0 = 0 ;
21911 PyObject * obj1 = 0 ;
21912 char *kwnames[] = {
21913 (char *) "self",(char *) "tz", NULL
21914 };
21915
21916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21918 if (SWIG_arg_fail(1)) SWIG_fail;
21919 if (obj1) {
21920 {
21921 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21922 temp2 = true;
21923 }
21924 }
21925 {
21926 PyThreadState* __tstate = wxPyBeginAllowThreads();
21927 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21928
21929 wxPyEndAllowThreads(__tstate);
21930 if (PyErr_Occurred()) SWIG_fail;
21931 }
21932 {
21933 resultobj = SWIG_From_int((int)(result));
21934 }
21935 {
21936 if (temp2) delete arg2;
21937 }
21938 return resultobj;
21939 fail:
21940 {
21941 if (temp2) delete arg2;
21942 }
21943 return NULL;
21944 }
21945
21946
21947 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21948 PyObject *resultobj;
21949 wxDateTime *arg1 = (wxDateTime *) 0 ;
21950 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21951 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21952 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21953 int result;
21954 bool temp3 = false ;
21955 PyObject * obj0 = 0 ;
21956 PyObject * obj1 = 0 ;
21957 PyObject * obj2 = 0 ;
21958 char *kwnames[] = {
21959 (char *) "self",(char *) "flags",(char *) "tz", NULL
21960 };
21961
21962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21964 if (SWIG_arg_fail(1)) SWIG_fail;
21965 if (obj1) {
21966 {
21967 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21968 if (SWIG_arg_fail(2)) SWIG_fail;
21969 }
21970 }
21971 if (obj2) {
21972 {
21973 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21974 temp3 = true;
21975 }
21976 }
21977 {
21978 PyThreadState* __tstate = wxPyBeginAllowThreads();
21979 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21980
21981 wxPyEndAllowThreads(__tstate);
21982 if (PyErr_Occurred()) SWIG_fail;
21983 }
21984 {
21985 resultobj = SWIG_From_int((int)(result));
21986 }
21987 {
21988 if (temp3) delete arg3;
21989 }
21990 return resultobj;
21991 fail:
21992 {
21993 if (temp3) delete arg3;
21994 }
21995 return NULL;
21996 }
21997
21998
21999 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22000 PyObject *resultobj;
22001 wxDateTime *arg1 = (wxDateTime *) 0 ;
22002 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22003 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22004 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22005 int result;
22006 bool temp3 = false ;
22007 PyObject * obj0 = 0 ;
22008 PyObject * obj1 = 0 ;
22009 PyObject * obj2 = 0 ;
22010 char *kwnames[] = {
22011 (char *) "self",(char *) "flags",(char *) "tz", NULL
22012 };
22013
22014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22016 if (SWIG_arg_fail(1)) SWIG_fail;
22017 if (obj1) {
22018 {
22019 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22020 if (SWIG_arg_fail(2)) SWIG_fail;
22021 }
22022 }
22023 if (obj2) {
22024 {
22025 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22026 temp3 = true;
22027 }
22028 }
22029 {
22030 PyThreadState* __tstate = wxPyBeginAllowThreads();
22031 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22032
22033 wxPyEndAllowThreads(__tstate);
22034 if (PyErr_Occurred()) SWIG_fail;
22035 }
22036 {
22037 resultobj = SWIG_From_int((int)(result));
22038 }
22039 {
22040 if (temp3) delete arg3;
22041 }
22042 return resultobj;
22043 fail:
22044 {
22045 if (temp3) delete arg3;
22046 }
22047 return NULL;
22048 }
22049
22050
22051 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22052 PyObject *resultobj;
22053 wxDateTime *arg1 = (wxDateTime *) 0 ;
22054 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22055 bool result;
22056 PyObject * obj0 = 0 ;
22057 PyObject * obj1 = 0 ;
22058 char *kwnames[] = {
22059 (char *) "self",(char *) "country", NULL
22060 };
22061
22062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22064 if (SWIG_arg_fail(1)) SWIG_fail;
22065 if (obj1) {
22066 {
22067 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22068 if (SWIG_arg_fail(2)) SWIG_fail;
22069 }
22070 }
22071 {
22072 PyThreadState* __tstate = wxPyBeginAllowThreads();
22073 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22074
22075 wxPyEndAllowThreads(__tstate);
22076 if (PyErr_Occurred()) SWIG_fail;
22077 }
22078 {
22079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22080 }
22081 return resultobj;
22082 fail:
22083 return NULL;
22084 }
22085
22086
22087 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22088 PyObject *resultobj;
22089 wxDateTime *arg1 = (wxDateTime *) 0 ;
22090 wxDateTime *arg2 = 0 ;
22091 bool result;
22092 PyObject * obj0 = 0 ;
22093 PyObject * obj1 = 0 ;
22094 char *kwnames[] = {
22095 (char *) "self",(char *) "datetime", NULL
22096 };
22097
22098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22100 if (SWIG_arg_fail(1)) SWIG_fail;
22101 {
22102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22103 if (SWIG_arg_fail(2)) SWIG_fail;
22104 if (arg2 == NULL) {
22105 SWIG_null_ref("wxDateTime");
22106 }
22107 if (SWIG_arg_fail(2)) SWIG_fail;
22108 }
22109 {
22110 PyThreadState* __tstate = wxPyBeginAllowThreads();
22111 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22112
22113 wxPyEndAllowThreads(__tstate);
22114 if (PyErr_Occurred()) SWIG_fail;
22115 }
22116 {
22117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22118 }
22119 return resultobj;
22120 fail:
22121 return NULL;
22122 }
22123
22124
22125 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22126 PyObject *resultobj;
22127 wxDateTime *arg1 = (wxDateTime *) 0 ;
22128 wxDateTime *arg2 = 0 ;
22129 bool result;
22130 PyObject * obj0 = 0 ;
22131 PyObject * obj1 = 0 ;
22132 char *kwnames[] = {
22133 (char *) "self",(char *) "datetime", NULL
22134 };
22135
22136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22138 if (SWIG_arg_fail(1)) SWIG_fail;
22139 {
22140 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22141 if (SWIG_arg_fail(2)) SWIG_fail;
22142 if (arg2 == NULL) {
22143 SWIG_null_ref("wxDateTime");
22144 }
22145 if (SWIG_arg_fail(2)) SWIG_fail;
22146 }
22147 {
22148 PyThreadState* __tstate = wxPyBeginAllowThreads();
22149 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22150
22151 wxPyEndAllowThreads(__tstate);
22152 if (PyErr_Occurred()) SWIG_fail;
22153 }
22154 {
22155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22156 }
22157 return resultobj;
22158 fail:
22159 return NULL;
22160 }
22161
22162
22163 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj;
22165 wxDateTime *arg1 = (wxDateTime *) 0 ;
22166 wxDateTime *arg2 = 0 ;
22167 bool result;
22168 PyObject * obj0 = 0 ;
22169 PyObject * obj1 = 0 ;
22170 char *kwnames[] = {
22171 (char *) "self",(char *) "datetime", NULL
22172 };
22173
22174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22176 if (SWIG_arg_fail(1)) SWIG_fail;
22177 {
22178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22179 if (SWIG_arg_fail(2)) SWIG_fail;
22180 if (arg2 == NULL) {
22181 SWIG_null_ref("wxDateTime");
22182 }
22183 if (SWIG_arg_fail(2)) SWIG_fail;
22184 }
22185 {
22186 PyThreadState* __tstate = wxPyBeginAllowThreads();
22187 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22188
22189 wxPyEndAllowThreads(__tstate);
22190 if (PyErr_Occurred()) SWIG_fail;
22191 }
22192 {
22193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22194 }
22195 return resultobj;
22196 fail:
22197 return NULL;
22198 }
22199
22200
22201 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22202 PyObject *resultobj;
22203 wxDateTime *arg1 = (wxDateTime *) 0 ;
22204 wxDateTime *arg2 = 0 ;
22205 wxDateTime *arg3 = 0 ;
22206 bool result;
22207 PyObject * obj0 = 0 ;
22208 PyObject * obj1 = 0 ;
22209 PyObject * obj2 = 0 ;
22210 char *kwnames[] = {
22211 (char *) "self",(char *) "t1",(char *) "t2", NULL
22212 };
22213
22214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22216 if (SWIG_arg_fail(1)) SWIG_fail;
22217 {
22218 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22219 if (SWIG_arg_fail(2)) SWIG_fail;
22220 if (arg2 == NULL) {
22221 SWIG_null_ref("wxDateTime");
22222 }
22223 if (SWIG_arg_fail(2)) SWIG_fail;
22224 }
22225 {
22226 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22227 if (SWIG_arg_fail(3)) SWIG_fail;
22228 if (arg3 == NULL) {
22229 SWIG_null_ref("wxDateTime");
22230 }
22231 if (SWIG_arg_fail(3)) SWIG_fail;
22232 }
22233 {
22234 PyThreadState* __tstate = wxPyBeginAllowThreads();
22235 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22236
22237 wxPyEndAllowThreads(__tstate);
22238 if (PyErr_Occurred()) SWIG_fail;
22239 }
22240 {
22241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22242 }
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22250 PyObject *resultobj;
22251 wxDateTime *arg1 = (wxDateTime *) 0 ;
22252 wxDateTime *arg2 = 0 ;
22253 wxDateTime *arg3 = 0 ;
22254 bool result;
22255 PyObject * obj0 = 0 ;
22256 PyObject * obj1 = 0 ;
22257 PyObject * obj2 = 0 ;
22258 char *kwnames[] = {
22259 (char *) "self",(char *) "t1",(char *) "t2", NULL
22260 };
22261
22262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22264 if (SWIG_arg_fail(1)) SWIG_fail;
22265 {
22266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22267 if (SWIG_arg_fail(2)) SWIG_fail;
22268 if (arg2 == NULL) {
22269 SWIG_null_ref("wxDateTime");
22270 }
22271 if (SWIG_arg_fail(2)) SWIG_fail;
22272 }
22273 {
22274 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22275 if (SWIG_arg_fail(3)) SWIG_fail;
22276 if (arg3 == NULL) {
22277 SWIG_null_ref("wxDateTime");
22278 }
22279 if (SWIG_arg_fail(3)) SWIG_fail;
22280 }
22281 {
22282 PyThreadState* __tstate = wxPyBeginAllowThreads();
22283 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22284
22285 wxPyEndAllowThreads(__tstate);
22286 if (PyErr_Occurred()) SWIG_fail;
22287 }
22288 {
22289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22290 }
22291 return resultobj;
22292 fail:
22293 return NULL;
22294 }
22295
22296
22297 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22298 PyObject *resultobj;
22299 wxDateTime *arg1 = (wxDateTime *) 0 ;
22300 wxDateTime *arg2 = 0 ;
22301 bool result;
22302 PyObject * obj0 = 0 ;
22303 PyObject * obj1 = 0 ;
22304 char *kwnames[] = {
22305 (char *) "self",(char *) "dt", NULL
22306 };
22307
22308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22310 if (SWIG_arg_fail(1)) SWIG_fail;
22311 {
22312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22313 if (SWIG_arg_fail(2)) SWIG_fail;
22314 if (arg2 == NULL) {
22315 SWIG_null_ref("wxDateTime");
22316 }
22317 if (SWIG_arg_fail(2)) SWIG_fail;
22318 }
22319 {
22320 PyThreadState* __tstate = wxPyBeginAllowThreads();
22321 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22322
22323 wxPyEndAllowThreads(__tstate);
22324 if (PyErr_Occurred()) SWIG_fail;
22325 }
22326 {
22327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22328 }
22329 return resultobj;
22330 fail:
22331 return NULL;
22332 }
22333
22334
22335 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22336 PyObject *resultobj;
22337 wxDateTime *arg1 = (wxDateTime *) 0 ;
22338 wxDateTime *arg2 = 0 ;
22339 bool result;
22340 PyObject * obj0 = 0 ;
22341 PyObject * obj1 = 0 ;
22342 char *kwnames[] = {
22343 (char *) "self",(char *) "dt", NULL
22344 };
22345
22346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22348 if (SWIG_arg_fail(1)) SWIG_fail;
22349 {
22350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22351 if (SWIG_arg_fail(2)) SWIG_fail;
22352 if (arg2 == NULL) {
22353 SWIG_null_ref("wxDateTime");
22354 }
22355 if (SWIG_arg_fail(2)) SWIG_fail;
22356 }
22357 {
22358 PyThreadState* __tstate = wxPyBeginAllowThreads();
22359 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22360
22361 wxPyEndAllowThreads(__tstate);
22362 if (PyErr_Occurred()) SWIG_fail;
22363 }
22364 {
22365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22366 }
22367 return resultobj;
22368 fail:
22369 return NULL;
22370 }
22371
22372
22373 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22374 PyObject *resultobj;
22375 wxDateTime *arg1 = (wxDateTime *) 0 ;
22376 wxDateTime *arg2 = 0 ;
22377 wxTimeSpan *arg3 = 0 ;
22378 bool result;
22379 PyObject * obj0 = 0 ;
22380 PyObject * obj1 = 0 ;
22381 PyObject * obj2 = 0 ;
22382 char *kwnames[] = {
22383 (char *) "self",(char *) "dt",(char *) "ts", NULL
22384 };
22385
22386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22388 if (SWIG_arg_fail(1)) SWIG_fail;
22389 {
22390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22391 if (SWIG_arg_fail(2)) SWIG_fail;
22392 if (arg2 == NULL) {
22393 SWIG_null_ref("wxDateTime");
22394 }
22395 if (SWIG_arg_fail(2)) SWIG_fail;
22396 }
22397 {
22398 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22399 if (SWIG_arg_fail(3)) SWIG_fail;
22400 if (arg3 == NULL) {
22401 SWIG_null_ref("wxTimeSpan");
22402 }
22403 if (SWIG_arg_fail(3)) SWIG_fail;
22404 }
22405 {
22406 PyThreadState* __tstate = wxPyBeginAllowThreads();
22407 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22408
22409 wxPyEndAllowThreads(__tstate);
22410 if (PyErr_Occurred()) SWIG_fail;
22411 }
22412 {
22413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22414 }
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22422 PyObject *resultobj;
22423 wxDateTime *arg1 = (wxDateTime *) 0 ;
22424 wxTimeSpan *arg2 = 0 ;
22425 wxDateTime *result;
22426 PyObject * obj0 = 0 ;
22427 PyObject * obj1 = 0 ;
22428 char *kwnames[] = {
22429 (char *) "self",(char *) "diff", NULL
22430 };
22431
22432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22434 if (SWIG_arg_fail(1)) SWIG_fail;
22435 {
22436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22437 if (SWIG_arg_fail(2)) SWIG_fail;
22438 if (arg2 == NULL) {
22439 SWIG_null_ref("wxTimeSpan");
22440 }
22441 if (SWIG_arg_fail(2)) SWIG_fail;
22442 }
22443 {
22444 PyThreadState* __tstate = wxPyBeginAllowThreads();
22445 {
22446 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22447 result = (wxDateTime *) &_result_ref;
22448 }
22449
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22461 PyObject *resultobj;
22462 wxDateTime *arg1 = (wxDateTime *) 0 ;
22463 wxDateSpan *arg2 = 0 ;
22464 wxDateTime *result;
22465 PyObject * obj0 = 0 ;
22466 PyObject * obj1 = 0 ;
22467 char *kwnames[] = {
22468 (char *) "self",(char *) "diff", NULL
22469 };
22470
22471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22473 if (SWIG_arg_fail(1)) SWIG_fail;
22474 {
22475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(2)) SWIG_fail;
22477 if (arg2 == NULL) {
22478 SWIG_null_ref("wxDateSpan");
22479 }
22480 if (SWIG_arg_fail(2)) SWIG_fail;
22481 }
22482 {
22483 PyThreadState* __tstate = wxPyBeginAllowThreads();
22484 {
22485 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22486 result = (wxDateTime *) &_result_ref;
22487 }
22488
22489 wxPyEndAllowThreads(__tstate);
22490 if (PyErr_Occurred()) SWIG_fail;
22491 }
22492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22493 return resultobj;
22494 fail:
22495 return NULL;
22496 }
22497
22498
22499 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22500 PyObject *resultobj;
22501 wxDateTime *arg1 = (wxDateTime *) 0 ;
22502 wxTimeSpan *arg2 = 0 ;
22503 wxDateTime *result;
22504 PyObject * obj0 = 0 ;
22505 PyObject * obj1 = 0 ;
22506 char *kwnames[] = {
22507 (char *) "self",(char *) "diff", NULL
22508 };
22509
22510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22512 if (SWIG_arg_fail(1)) SWIG_fail;
22513 {
22514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22515 if (SWIG_arg_fail(2)) SWIG_fail;
22516 if (arg2 == NULL) {
22517 SWIG_null_ref("wxTimeSpan");
22518 }
22519 if (SWIG_arg_fail(2)) SWIG_fail;
22520 }
22521 {
22522 PyThreadState* __tstate = wxPyBeginAllowThreads();
22523 {
22524 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22525 result = (wxDateTime *) &_result_ref;
22526 }
22527
22528 wxPyEndAllowThreads(__tstate);
22529 if (PyErr_Occurred()) SWIG_fail;
22530 }
22531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22532 return resultobj;
22533 fail:
22534 return NULL;
22535 }
22536
22537
22538 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22539 PyObject *resultobj;
22540 wxDateTime *arg1 = (wxDateTime *) 0 ;
22541 wxDateSpan *arg2 = 0 ;
22542 wxDateTime *result;
22543 PyObject * obj0 = 0 ;
22544 PyObject * obj1 = 0 ;
22545 char *kwnames[] = {
22546 (char *) "self",(char *) "diff", NULL
22547 };
22548
22549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22551 if (SWIG_arg_fail(1)) SWIG_fail;
22552 {
22553 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22554 if (SWIG_arg_fail(2)) SWIG_fail;
22555 if (arg2 == NULL) {
22556 SWIG_null_ref("wxDateSpan");
22557 }
22558 if (SWIG_arg_fail(2)) SWIG_fail;
22559 }
22560 {
22561 PyThreadState* __tstate = wxPyBeginAllowThreads();
22562 {
22563 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22564 result = (wxDateTime *) &_result_ref;
22565 }
22566
22567 wxPyEndAllowThreads(__tstate);
22568 if (PyErr_Occurred()) SWIG_fail;
22569 }
22570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22571 return resultobj;
22572 fail:
22573 return NULL;
22574 }
22575
22576
22577 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22578 PyObject *resultobj;
22579 wxDateTime *arg1 = (wxDateTime *) 0 ;
22580 wxDateTime *arg2 = 0 ;
22581 wxTimeSpan result;
22582 PyObject * obj0 = 0 ;
22583 PyObject * obj1 = 0 ;
22584 char *kwnames[] = {
22585 (char *) "self",(char *) "dt", NULL
22586 };
22587
22588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22590 if (SWIG_arg_fail(1)) SWIG_fail;
22591 {
22592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22593 if (SWIG_arg_fail(2)) SWIG_fail;
22594 if (arg2 == NULL) {
22595 SWIG_null_ref("wxDateTime");
22596 }
22597 if (SWIG_arg_fail(2)) SWIG_fail;
22598 }
22599 {
22600 PyThreadState* __tstate = wxPyBeginAllowThreads();
22601 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22602
22603 wxPyEndAllowThreads(__tstate);
22604 if (PyErr_Occurred()) SWIG_fail;
22605 }
22606 {
22607 wxTimeSpan * resultptr;
22608 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22610 }
22611 return resultobj;
22612 fail:
22613 return NULL;
22614 }
22615
22616
22617 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22618 PyObject *resultobj;
22619 wxDateTime *arg1 = (wxDateTime *) 0 ;
22620 wxTimeSpan *arg2 = 0 ;
22621 wxDateTime *result;
22622 PyObject * obj0 = 0 ;
22623 PyObject * obj1 = 0 ;
22624
22625 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22627 if (SWIG_arg_fail(1)) SWIG_fail;
22628 {
22629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22630 if (SWIG_arg_fail(2)) SWIG_fail;
22631 if (arg2 == NULL) {
22632 SWIG_null_ref("wxTimeSpan");
22633 }
22634 if (SWIG_arg_fail(2)) SWIG_fail;
22635 }
22636 {
22637 PyThreadState* __tstate = wxPyBeginAllowThreads();
22638 {
22639 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22640 result = (wxDateTime *) &_result_ref;
22641 }
22642
22643 wxPyEndAllowThreads(__tstate);
22644 if (PyErr_Occurred()) SWIG_fail;
22645 }
22646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22647 return resultobj;
22648 fail:
22649 return NULL;
22650 }
22651
22652
22653 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22654 PyObject *resultobj;
22655 wxDateTime *arg1 = (wxDateTime *) 0 ;
22656 wxDateSpan *arg2 = 0 ;
22657 wxDateTime *result;
22658 PyObject * obj0 = 0 ;
22659 PyObject * obj1 = 0 ;
22660
22661 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22663 if (SWIG_arg_fail(1)) SWIG_fail;
22664 {
22665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22666 if (SWIG_arg_fail(2)) SWIG_fail;
22667 if (arg2 == NULL) {
22668 SWIG_null_ref("wxDateSpan");
22669 }
22670 if (SWIG_arg_fail(2)) SWIG_fail;
22671 }
22672 {
22673 PyThreadState* __tstate = wxPyBeginAllowThreads();
22674 {
22675 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22676 result = (wxDateTime *) &_result_ref;
22677 }
22678
22679 wxPyEndAllowThreads(__tstate);
22680 if (PyErr_Occurred()) SWIG_fail;
22681 }
22682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22683 return resultobj;
22684 fail:
22685 return NULL;
22686 }
22687
22688
22689 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22690 int argc;
22691 PyObject *argv[3];
22692 int ii;
22693
22694 argc = PyObject_Length(args);
22695 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22696 argv[ii] = PyTuple_GetItem(args,ii);
22697 }
22698 if (argc == 2) {
22699 int _v;
22700 {
22701 void *ptr;
22702 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22703 _v = 0;
22704 PyErr_Clear();
22705 } else {
22706 _v = 1;
22707 }
22708 }
22709 if (_v) {
22710 {
22711 void *ptr = 0;
22712 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22713 _v = 0;
22714 PyErr_Clear();
22715 } else {
22716 _v = (ptr != 0);
22717 }
22718 }
22719 if (_v) {
22720 return _wrap_DateTime___iadd____SWIG_0(self,args);
22721 }
22722 }
22723 }
22724 if (argc == 2) {
22725 int _v;
22726 {
22727 void *ptr;
22728 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22729 _v = 0;
22730 PyErr_Clear();
22731 } else {
22732 _v = 1;
22733 }
22734 }
22735 if (_v) {
22736 {
22737 void *ptr = 0;
22738 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22739 _v = 0;
22740 PyErr_Clear();
22741 } else {
22742 _v = (ptr != 0);
22743 }
22744 }
22745 if (_v) {
22746 return _wrap_DateTime___iadd____SWIG_1(self,args);
22747 }
22748 }
22749 }
22750
22751 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22752 return NULL;
22753 }
22754
22755
22756 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22757 PyObject *resultobj;
22758 wxDateTime *arg1 = (wxDateTime *) 0 ;
22759 wxTimeSpan *arg2 = 0 ;
22760 wxDateTime *result;
22761 PyObject * obj0 = 0 ;
22762 PyObject * obj1 = 0 ;
22763
22764 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22766 if (SWIG_arg_fail(1)) SWIG_fail;
22767 {
22768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22769 if (SWIG_arg_fail(2)) SWIG_fail;
22770 if (arg2 == NULL) {
22771 SWIG_null_ref("wxTimeSpan");
22772 }
22773 if (SWIG_arg_fail(2)) SWIG_fail;
22774 }
22775 {
22776 PyThreadState* __tstate = wxPyBeginAllowThreads();
22777 {
22778 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22779 result = (wxDateTime *) &_result_ref;
22780 }
22781
22782 wxPyEndAllowThreads(__tstate);
22783 if (PyErr_Occurred()) SWIG_fail;
22784 }
22785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22786 return resultobj;
22787 fail:
22788 return NULL;
22789 }
22790
22791
22792 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22793 PyObject *resultobj;
22794 wxDateTime *arg1 = (wxDateTime *) 0 ;
22795 wxDateSpan *arg2 = 0 ;
22796 wxDateTime *result;
22797 PyObject * obj0 = 0 ;
22798 PyObject * obj1 = 0 ;
22799
22800 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22802 if (SWIG_arg_fail(1)) SWIG_fail;
22803 {
22804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22805 if (SWIG_arg_fail(2)) SWIG_fail;
22806 if (arg2 == NULL) {
22807 SWIG_null_ref("wxDateSpan");
22808 }
22809 if (SWIG_arg_fail(2)) SWIG_fail;
22810 }
22811 {
22812 PyThreadState* __tstate = wxPyBeginAllowThreads();
22813 {
22814 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22815 result = (wxDateTime *) &_result_ref;
22816 }
22817
22818 wxPyEndAllowThreads(__tstate);
22819 if (PyErr_Occurred()) SWIG_fail;
22820 }
22821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22822 return resultobj;
22823 fail:
22824 return NULL;
22825 }
22826
22827
22828 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22829 int argc;
22830 PyObject *argv[3];
22831 int ii;
22832
22833 argc = PyObject_Length(args);
22834 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22835 argv[ii] = PyTuple_GetItem(args,ii);
22836 }
22837 if (argc == 2) {
22838 int _v;
22839 {
22840 void *ptr;
22841 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22842 _v = 0;
22843 PyErr_Clear();
22844 } else {
22845 _v = 1;
22846 }
22847 }
22848 if (_v) {
22849 {
22850 void *ptr = 0;
22851 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22852 _v = 0;
22853 PyErr_Clear();
22854 } else {
22855 _v = (ptr != 0);
22856 }
22857 }
22858 if (_v) {
22859 return _wrap_DateTime___isub____SWIG_0(self,args);
22860 }
22861 }
22862 }
22863 if (argc == 2) {
22864 int _v;
22865 {
22866 void *ptr;
22867 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22868 _v = 0;
22869 PyErr_Clear();
22870 } else {
22871 _v = 1;
22872 }
22873 }
22874 if (_v) {
22875 {
22876 void *ptr = 0;
22877 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22878 _v = 0;
22879 PyErr_Clear();
22880 } else {
22881 _v = (ptr != 0);
22882 }
22883 }
22884 if (_v) {
22885 return _wrap_DateTime___isub____SWIG_1(self,args);
22886 }
22887 }
22888 }
22889
22890 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22891 return NULL;
22892 }
22893
22894
22895 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22896 PyObject *resultobj;
22897 wxDateTime *arg1 = (wxDateTime *) 0 ;
22898 wxTimeSpan *arg2 = 0 ;
22899 wxDateTime result;
22900 PyObject * obj0 = 0 ;
22901 PyObject * obj1 = 0 ;
22902
22903 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22905 if (SWIG_arg_fail(1)) SWIG_fail;
22906 {
22907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22908 if (SWIG_arg_fail(2)) SWIG_fail;
22909 if (arg2 == NULL) {
22910 SWIG_null_ref("wxTimeSpan");
22911 }
22912 if (SWIG_arg_fail(2)) SWIG_fail;
22913 }
22914 {
22915 PyThreadState* __tstate = wxPyBeginAllowThreads();
22916 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22917
22918 wxPyEndAllowThreads(__tstate);
22919 if (PyErr_Occurred()) SWIG_fail;
22920 }
22921 {
22922 wxDateTime * resultptr;
22923 resultptr = new wxDateTime((wxDateTime &)(result));
22924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22925 }
22926 return resultobj;
22927 fail:
22928 return NULL;
22929 }
22930
22931
22932 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22933 PyObject *resultobj;
22934 wxDateTime *arg1 = (wxDateTime *) 0 ;
22935 wxDateSpan *arg2 = 0 ;
22936 wxDateTime result;
22937 PyObject * obj0 = 0 ;
22938 PyObject * obj1 = 0 ;
22939
22940 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22942 if (SWIG_arg_fail(1)) SWIG_fail;
22943 {
22944 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22945 if (SWIG_arg_fail(2)) SWIG_fail;
22946 if (arg2 == NULL) {
22947 SWIG_null_ref("wxDateSpan");
22948 }
22949 if (SWIG_arg_fail(2)) SWIG_fail;
22950 }
22951 {
22952 PyThreadState* __tstate = wxPyBeginAllowThreads();
22953 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22954
22955 wxPyEndAllowThreads(__tstate);
22956 if (PyErr_Occurred()) SWIG_fail;
22957 }
22958 {
22959 wxDateTime * resultptr;
22960 resultptr = new wxDateTime((wxDateTime &)(result));
22961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22962 }
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22970 int argc;
22971 PyObject *argv[3];
22972 int ii;
22973
22974 argc = PyObject_Length(args);
22975 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22976 argv[ii] = PyTuple_GetItem(args,ii);
22977 }
22978 if (argc == 2) {
22979 int _v;
22980 {
22981 void *ptr;
22982 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22983 _v = 0;
22984 PyErr_Clear();
22985 } else {
22986 _v = 1;
22987 }
22988 }
22989 if (_v) {
22990 {
22991 void *ptr = 0;
22992 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22993 _v = 0;
22994 PyErr_Clear();
22995 } else {
22996 _v = (ptr != 0);
22997 }
22998 }
22999 if (_v) {
23000 return _wrap_DateTime___add____SWIG_0(self,args);
23001 }
23002 }
23003 }
23004 if (argc == 2) {
23005 int _v;
23006 {
23007 void *ptr;
23008 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23009 _v = 0;
23010 PyErr_Clear();
23011 } else {
23012 _v = 1;
23013 }
23014 }
23015 if (_v) {
23016 {
23017 void *ptr = 0;
23018 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23019 _v = 0;
23020 PyErr_Clear();
23021 } else {
23022 _v = (ptr != 0);
23023 }
23024 }
23025 if (_v) {
23026 return _wrap_DateTime___add____SWIG_1(self,args);
23027 }
23028 }
23029 }
23030
23031 Py_INCREF(Py_NotImplemented);
23032 return Py_NotImplemented;
23033 }
23034
23035
23036 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23037 PyObject *resultobj;
23038 wxDateTime *arg1 = (wxDateTime *) 0 ;
23039 wxDateTime *arg2 = 0 ;
23040 wxTimeSpan result;
23041 PyObject * obj0 = 0 ;
23042 PyObject * obj1 = 0 ;
23043
23044 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23046 if (SWIG_arg_fail(1)) SWIG_fail;
23047 {
23048 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23049 if (SWIG_arg_fail(2)) SWIG_fail;
23050 if (arg2 == NULL) {
23051 SWIG_null_ref("wxDateTime");
23052 }
23053 if (SWIG_arg_fail(2)) SWIG_fail;
23054 }
23055 {
23056 PyThreadState* __tstate = wxPyBeginAllowThreads();
23057 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23058
23059 wxPyEndAllowThreads(__tstate);
23060 if (PyErr_Occurred()) SWIG_fail;
23061 }
23062 {
23063 wxTimeSpan * resultptr;
23064 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23065 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23066 }
23067 return resultobj;
23068 fail:
23069 return NULL;
23070 }
23071
23072
23073 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23074 PyObject *resultobj;
23075 wxDateTime *arg1 = (wxDateTime *) 0 ;
23076 wxTimeSpan *arg2 = 0 ;
23077 wxDateTime result;
23078 PyObject * obj0 = 0 ;
23079 PyObject * obj1 = 0 ;
23080
23081 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23083 if (SWIG_arg_fail(1)) SWIG_fail;
23084 {
23085 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23086 if (SWIG_arg_fail(2)) SWIG_fail;
23087 if (arg2 == NULL) {
23088 SWIG_null_ref("wxTimeSpan");
23089 }
23090 if (SWIG_arg_fail(2)) SWIG_fail;
23091 }
23092 {
23093 PyThreadState* __tstate = wxPyBeginAllowThreads();
23094 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23095
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 {
23100 wxDateTime * resultptr;
23101 resultptr = new wxDateTime((wxDateTime &)(result));
23102 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23103 }
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23111 PyObject *resultobj;
23112 wxDateTime *arg1 = (wxDateTime *) 0 ;
23113 wxDateSpan *arg2 = 0 ;
23114 wxDateTime result;
23115 PyObject * obj0 = 0 ;
23116 PyObject * obj1 = 0 ;
23117
23118 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23120 if (SWIG_arg_fail(1)) SWIG_fail;
23121 {
23122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23123 if (SWIG_arg_fail(2)) SWIG_fail;
23124 if (arg2 == NULL) {
23125 SWIG_null_ref("wxDateSpan");
23126 }
23127 if (SWIG_arg_fail(2)) SWIG_fail;
23128 }
23129 {
23130 PyThreadState* __tstate = wxPyBeginAllowThreads();
23131 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23132
23133 wxPyEndAllowThreads(__tstate);
23134 if (PyErr_Occurred()) SWIG_fail;
23135 }
23136 {
23137 wxDateTime * resultptr;
23138 resultptr = new wxDateTime((wxDateTime &)(result));
23139 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23140 }
23141 return resultobj;
23142 fail:
23143 return NULL;
23144 }
23145
23146
23147 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23148 int argc;
23149 PyObject *argv[3];
23150 int ii;
23151
23152 argc = PyObject_Length(args);
23153 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23154 argv[ii] = PyTuple_GetItem(args,ii);
23155 }
23156 if (argc == 2) {
23157 int _v;
23158 {
23159 void *ptr;
23160 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23161 _v = 0;
23162 PyErr_Clear();
23163 } else {
23164 _v = 1;
23165 }
23166 }
23167 if (_v) {
23168 {
23169 void *ptr = 0;
23170 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23171 _v = 0;
23172 PyErr_Clear();
23173 } else {
23174 _v = (ptr != 0);
23175 }
23176 }
23177 if (_v) {
23178 return _wrap_DateTime___sub____SWIG_0(self,args);
23179 }
23180 }
23181 }
23182 if (argc == 2) {
23183 int _v;
23184 {
23185 void *ptr;
23186 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23187 _v = 0;
23188 PyErr_Clear();
23189 } else {
23190 _v = 1;
23191 }
23192 }
23193 if (_v) {
23194 {
23195 void *ptr = 0;
23196 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23197 _v = 0;
23198 PyErr_Clear();
23199 } else {
23200 _v = (ptr != 0);
23201 }
23202 }
23203 if (_v) {
23204 return _wrap_DateTime___sub____SWIG_1(self,args);
23205 }
23206 }
23207 }
23208 if (argc == 2) {
23209 int _v;
23210 {
23211 void *ptr;
23212 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23213 _v = 0;
23214 PyErr_Clear();
23215 } else {
23216 _v = 1;
23217 }
23218 }
23219 if (_v) {
23220 {
23221 void *ptr = 0;
23222 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23223 _v = 0;
23224 PyErr_Clear();
23225 } else {
23226 _v = (ptr != 0);
23227 }
23228 }
23229 if (_v) {
23230 return _wrap_DateTime___sub____SWIG_2(self,args);
23231 }
23232 }
23233 }
23234
23235 Py_INCREF(Py_NotImplemented);
23236 return Py_NotImplemented;
23237 }
23238
23239
23240 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23241 PyObject *resultobj;
23242 wxDateTime *arg1 = (wxDateTime *) 0 ;
23243 wxDateTime *arg2 = (wxDateTime *) 0 ;
23244 bool result;
23245 PyObject * obj0 = 0 ;
23246 PyObject * obj1 = 0 ;
23247 char *kwnames[] = {
23248 (char *) "self",(char *) "other", NULL
23249 };
23250
23251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23253 if (SWIG_arg_fail(1)) SWIG_fail;
23254 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23255 if (SWIG_arg_fail(2)) SWIG_fail;
23256 {
23257 PyThreadState* __tstate = wxPyBeginAllowThreads();
23258 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23259
23260 wxPyEndAllowThreads(__tstate);
23261 if (PyErr_Occurred()) SWIG_fail;
23262 }
23263 {
23264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23265 }
23266 return resultobj;
23267 fail:
23268 return NULL;
23269 }
23270
23271
23272 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23273 PyObject *resultobj;
23274 wxDateTime *arg1 = (wxDateTime *) 0 ;
23275 wxDateTime *arg2 = (wxDateTime *) 0 ;
23276 bool result;
23277 PyObject * obj0 = 0 ;
23278 PyObject * obj1 = 0 ;
23279 char *kwnames[] = {
23280 (char *) "self",(char *) "other", NULL
23281 };
23282
23283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23285 if (SWIG_arg_fail(1)) SWIG_fail;
23286 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23287 if (SWIG_arg_fail(2)) SWIG_fail;
23288 {
23289 PyThreadState* __tstate = wxPyBeginAllowThreads();
23290 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23291
23292 wxPyEndAllowThreads(__tstate);
23293 if (PyErr_Occurred()) SWIG_fail;
23294 }
23295 {
23296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23297 }
23298 return resultobj;
23299 fail:
23300 return NULL;
23301 }
23302
23303
23304 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23305 PyObject *resultobj;
23306 wxDateTime *arg1 = (wxDateTime *) 0 ;
23307 wxDateTime *arg2 = (wxDateTime *) 0 ;
23308 bool result;
23309 PyObject * obj0 = 0 ;
23310 PyObject * obj1 = 0 ;
23311 char *kwnames[] = {
23312 (char *) "self",(char *) "other", NULL
23313 };
23314
23315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23317 if (SWIG_arg_fail(1)) SWIG_fail;
23318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23319 if (SWIG_arg_fail(2)) SWIG_fail;
23320 {
23321 PyThreadState* __tstate = wxPyBeginAllowThreads();
23322 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23323
23324 wxPyEndAllowThreads(__tstate);
23325 if (PyErr_Occurred()) SWIG_fail;
23326 }
23327 {
23328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23329 }
23330 return resultobj;
23331 fail:
23332 return NULL;
23333 }
23334
23335
23336 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23337 PyObject *resultobj;
23338 wxDateTime *arg1 = (wxDateTime *) 0 ;
23339 wxDateTime *arg2 = (wxDateTime *) 0 ;
23340 bool result;
23341 PyObject * obj0 = 0 ;
23342 PyObject * obj1 = 0 ;
23343 char *kwnames[] = {
23344 (char *) "self",(char *) "other", NULL
23345 };
23346
23347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23349 if (SWIG_arg_fail(1)) SWIG_fail;
23350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23351 if (SWIG_arg_fail(2)) SWIG_fail;
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23355
23356 wxPyEndAllowThreads(__tstate);
23357 if (PyErr_Occurred()) SWIG_fail;
23358 }
23359 {
23360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23361 }
23362 return resultobj;
23363 fail:
23364 return NULL;
23365 }
23366
23367
23368 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23369 PyObject *resultobj;
23370 wxDateTime *arg1 = (wxDateTime *) 0 ;
23371 wxDateTime *arg2 = (wxDateTime *) 0 ;
23372 bool result;
23373 PyObject * obj0 = 0 ;
23374 PyObject * obj1 = 0 ;
23375 char *kwnames[] = {
23376 (char *) "self",(char *) "other", NULL
23377 };
23378
23379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23381 if (SWIG_arg_fail(1)) SWIG_fail;
23382 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23383 if (SWIG_arg_fail(2)) SWIG_fail;
23384 {
23385 PyThreadState* __tstate = wxPyBeginAllowThreads();
23386 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23387
23388 wxPyEndAllowThreads(__tstate);
23389 if (PyErr_Occurred()) SWIG_fail;
23390 }
23391 {
23392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23393 }
23394 return resultobj;
23395 fail:
23396 return NULL;
23397 }
23398
23399
23400 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23401 PyObject *resultobj;
23402 wxDateTime *arg1 = (wxDateTime *) 0 ;
23403 wxDateTime *arg2 = (wxDateTime *) 0 ;
23404 bool result;
23405 PyObject * obj0 = 0 ;
23406 PyObject * obj1 = 0 ;
23407 char *kwnames[] = {
23408 (char *) "self",(char *) "other", NULL
23409 };
23410
23411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23413 if (SWIG_arg_fail(1)) SWIG_fail;
23414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23415 if (SWIG_arg_fail(2)) SWIG_fail;
23416 {
23417 PyThreadState* __tstate = wxPyBeginAllowThreads();
23418 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23419
23420 wxPyEndAllowThreads(__tstate);
23421 if (PyErr_Occurred()) SWIG_fail;
23422 }
23423 {
23424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23425 }
23426 return resultobj;
23427 fail:
23428 return NULL;
23429 }
23430
23431
23432 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23433 PyObject *resultobj;
23434 wxDateTime *arg1 = (wxDateTime *) 0 ;
23435 wxString *arg2 = 0 ;
23436 int result;
23437 bool temp2 = false ;
23438 PyObject * obj0 = 0 ;
23439 PyObject * obj1 = 0 ;
23440 char *kwnames[] = {
23441 (char *) "self",(char *) "date", NULL
23442 };
23443
23444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23446 if (SWIG_arg_fail(1)) SWIG_fail;
23447 {
23448 arg2 = wxString_in_helper(obj1);
23449 if (arg2 == NULL) SWIG_fail;
23450 temp2 = true;
23451 }
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23455
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 {
23460 resultobj = SWIG_From_int((int)(result));
23461 }
23462 {
23463 if (temp2)
23464 delete arg2;
23465 }
23466 return resultobj;
23467 fail:
23468 {
23469 if (temp2)
23470 delete arg2;
23471 }
23472 return NULL;
23473 }
23474
23475
23476 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23477 PyObject *resultobj;
23478 wxDateTime *arg1 = (wxDateTime *) 0 ;
23479 wxString *arg2 = 0 ;
23480 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23481 wxString *arg3 = (wxString *) &arg3_defvalue ;
23482 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23483 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23484 int result;
23485 bool temp2 = false ;
23486 bool temp3 = false ;
23487 PyObject * obj0 = 0 ;
23488 PyObject * obj1 = 0 ;
23489 PyObject * obj2 = 0 ;
23490 PyObject * obj3 = 0 ;
23491 char *kwnames[] = {
23492 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23493 };
23494
23495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23497 if (SWIG_arg_fail(1)) SWIG_fail;
23498 {
23499 arg2 = wxString_in_helper(obj1);
23500 if (arg2 == NULL) SWIG_fail;
23501 temp2 = true;
23502 }
23503 if (obj2) {
23504 {
23505 arg3 = wxString_in_helper(obj2);
23506 if (arg3 == NULL) SWIG_fail;
23507 temp3 = true;
23508 }
23509 }
23510 if (obj3) {
23511 {
23512 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23513 if (SWIG_arg_fail(4)) SWIG_fail;
23514 if (arg4 == NULL) {
23515 SWIG_null_ref("wxDateTime");
23516 }
23517 if (SWIG_arg_fail(4)) SWIG_fail;
23518 }
23519 }
23520 {
23521 PyThreadState* __tstate = wxPyBeginAllowThreads();
23522 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23523
23524 wxPyEndAllowThreads(__tstate);
23525 if (PyErr_Occurred()) SWIG_fail;
23526 }
23527 {
23528 resultobj = SWIG_From_int((int)(result));
23529 }
23530 {
23531 if (temp2)
23532 delete arg2;
23533 }
23534 {
23535 if (temp3)
23536 delete arg3;
23537 }
23538 return resultobj;
23539 fail:
23540 {
23541 if (temp2)
23542 delete arg2;
23543 }
23544 {
23545 if (temp3)
23546 delete arg3;
23547 }
23548 return NULL;
23549 }
23550
23551
23552 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23553 PyObject *resultobj;
23554 wxDateTime *arg1 = (wxDateTime *) 0 ;
23555 wxString *arg2 = 0 ;
23556 int result;
23557 bool temp2 = false ;
23558 PyObject * obj0 = 0 ;
23559 PyObject * obj1 = 0 ;
23560 char *kwnames[] = {
23561 (char *) "self",(char *) "datetime", NULL
23562 };
23563
23564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23566 if (SWIG_arg_fail(1)) SWIG_fail;
23567 {
23568 arg2 = wxString_in_helper(obj1);
23569 if (arg2 == NULL) SWIG_fail;
23570 temp2 = true;
23571 }
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23575
23576 wxPyEndAllowThreads(__tstate);
23577 if (PyErr_Occurred()) SWIG_fail;
23578 }
23579 {
23580 resultobj = SWIG_From_int((int)(result));
23581 }
23582 {
23583 if (temp2)
23584 delete arg2;
23585 }
23586 return resultobj;
23587 fail:
23588 {
23589 if (temp2)
23590 delete arg2;
23591 }
23592 return NULL;
23593 }
23594
23595
23596 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23597 PyObject *resultobj;
23598 wxDateTime *arg1 = (wxDateTime *) 0 ;
23599 wxString *arg2 = 0 ;
23600 int result;
23601 bool temp2 = false ;
23602 PyObject * obj0 = 0 ;
23603 PyObject * obj1 = 0 ;
23604 char *kwnames[] = {
23605 (char *) "self",(char *) "date", NULL
23606 };
23607
23608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23610 if (SWIG_arg_fail(1)) SWIG_fail;
23611 {
23612 arg2 = wxString_in_helper(obj1);
23613 if (arg2 == NULL) SWIG_fail;
23614 temp2 = true;
23615 }
23616 {
23617 PyThreadState* __tstate = wxPyBeginAllowThreads();
23618 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23619
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 {
23624 resultobj = SWIG_From_int((int)(result));
23625 }
23626 {
23627 if (temp2)
23628 delete arg2;
23629 }
23630 return resultobj;
23631 fail:
23632 {
23633 if (temp2)
23634 delete arg2;
23635 }
23636 return NULL;
23637 }
23638
23639
23640 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23641 PyObject *resultobj;
23642 wxDateTime *arg1 = (wxDateTime *) 0 ;
23643 wxString *arg2 = 0 ;
23644 int result;
23645 bool temp2 = false ;
23646 PyObject * obj0 = 0 ;
23647 PyObject * obj1 = 0 ;
23648 char *kwnames[] = {
23649 (char *) "self",(char *) "time", NULL
23650 };
23651
23652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23654 if (SWIG_arg_fail(1)) SWIG_fail;
23655 {
23656 arg2 = wxString_in_helper(obj1);
23657 if (arg2 == NULL) SWIG_fail;
23658 temp2 = true;
23659 }
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23663
23664 wxPyEndAllowThreads(__tstate);
23665 if (PyErr_Occurred()) SWIG_fail;
23666 }
23667 {
23668 resultobj = SWIG_From_int((int)(result));
23669 }
23670 {
23671 if (temp2)
23672 delete arg2;
23673 }
23674 return resultobj;
23675 fail:
23676 {
23677 if (temp2)
23678 delete arg2;
23679 }
23680 return NULL;
23681 }
23682
23683
23684 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23685 PyObject *resultobj;
23686 wxDateTime *arg1 = (wxDateTime *) 0 ;
23687 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23688 wxString *arg2 = (wxString *) &arg2_defvalue ;
23689 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23690 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23691 wxString result;
23692 bool temp2 = false ;
23693 bool temp3 = false ;
23694 PyObject * obj0 = 0 ;
23695 PyObject * obj1 = 0 ;
23696 PyObject * obj2 = 0 ;
23697 char *kwnames[] = {
23698 (char *) "self",(char *) "format",(char *) "tz", NULL
23699 };
23700
23701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23703 if (SWIG_arg_fail(1)) SWIG_fail;
23704 if (obj1) {
23705 {
23706 arg2 = wxString_in_helper(obj1);
23707 if (arg2 == NULL) SWIG_fail;
23708 temp2 = true;
23709 }
23710 }
23711 if (obj2) {
23712 {
23713 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23714 temp3 = true;
23715 }
23716 }
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23720
23721 wxPyEndAllowThreads(__tstate);
23722 if (PyErr_Occurred()) SWIG_fail;
23723 }
23724 {
23725 #if wxUSE_UNICODE
23726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23727 #else
23728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23729 #endif
23730 }
23731 {
23732 if (temp2)
23733 delete arg2;
23734 }
23735 {
23736 if (temp3) delete arg3;
23737 }
23738 return resultobj;
23739 fail:
23740 {
23741 if (temp2)
23742 delete arg2;
23743 }
23744 {
23745 if (temp3) delete arg3;
23746 }
23747 return NULL;
23748 }
23749
23750
23751 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23752 PyObject *resultobj;
23753 wxDateTime *arg1 = (wxDateTime *) 0 ;
23754 wxString result;
23755 PyObject * obj0 = 0 ;
23756 char *kwnames[] = {
23757 (char *) "self", NULL
23758 };
23759
23760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23762 if (SWIG_arg_fail(1)) SWIG_fail;
23763 {
23764 PyThreadState* __tstate = wxPyBeginAllowThreads();
23765 result = ((wxDateTime const *)arg1)->FormatDate();
23766
23767 wxPyEndAllowThreads(__tstate);
23768 if (PyErr_Occurred()) SWIG_fail;
23769 }
23770 {
23771 #if wxUSE_UNICODE
23772 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23773 #else
23774 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23775 #endif
23776 }
23777 return resultobj;
23778 fail:
23779 return NULL;
23780 }
23781
23782
23783 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23784 PyObject *resultobj;
23785 wxDateTime *arg1 = (wxDateTime *) 0 ;
23786 wxString result;
23787 PyObject * obj0 = 0 ;
23788 char *kwnames[] = {
23789 (char *) "self", NULL
23790 };
23791
23792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23794 if (SWIG_arg_fail(1)) SWIG_fail;
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 result = ((wxDateTime const *)arg1)->FormatTime();
23798
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 {
23803 #if wxUSE_UNICODE
23804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23805 #else
23806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23807 #endif
23808 }
23809 return resultobj;
23810 fail:
23811 return NULL;
23812 }
23813
23814
23815 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23816 PyObject *resultobj;
23817 wxDateTime *arg1 = (wxDateTime *) 0 ;
23818 wxString result;
23819 PyObject * obj0 = 0 ;
23820 char *kwnames[] = {
23821 (char *) "self", NULL
23822 };
23823
23824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23826 if (SWIG_arg_fail(1)) SWIG_fail;
23827 {
23828 PyThreadState* __tstate = wxPyBeginAllowThreads();
23829 result = ((wxDateTime const *)arg1)->FormatISODate();
23830
23831 wxPyEndAllowThreads(__tstate);
23832 if (PyErr_Occurred()) SWIG_fail;
23833 }
23834 {
23835 #if wxUSE_UNICODE
23836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23837 #else
23838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23839 #endif
23840 }
23841 return resultobj;
23842 fail:
23843 return NULL;
23844 }
23845
23846
23847 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23848 PyObject *resultobj;
23849 wxDateTime *arg1 = (wxDateTime *) 0 ;
23850 wxString result;
23851 PyObject * obj0 = 0 ;
23852 char *kwnames[] = {
23853 (char *) "self", NULL
23854 };
23855
23856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23858 if (SWIG_arg_fail(1)) SWIG_fail;
23859 {
23860 PyThreadState* __tstate = wxPyBeginAllowThreads();
23861 result = ((wxDateTime const *)arg1)->FormatISOTime();
23862
23863 wxPyEndAllowThreads(__tstate);
23864 if (PyErr_Occurred()) SWIG_fail;
23865 }
23866 {
23867 #if wxUSE_UNICODE
23868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23869 #else
23870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23871 #endif
23872 }
23873 return resultobj;
23874 fail:
23875 return NULL;
23876 }
23877
23878
23879 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23880 PyObject *obj;
23881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23882 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23883 Py_INCREF(obj);
23884 return Py_BuildValue((char *)"");
23885 }
23886 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23887 PyObject *resultobj;
23888 long arg1 ;
23889 wxTimeSpan result;
23890 PyObject * obj0 = 0 ;
23891 char *kwnames[] = {
23892 (char *) "sec", NULL
23893 };
23894
23895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23896 {
23897 arg1 = (long)(SWIG_As_long(obj0));
23898 if (SWIG_arg_fail(1)) SWIG_fail;
23899 }
23900 {
23901 PyThreadState* __tstate = wxPyBeginAllowThreads();
23902 result = wxTimeSpan::Seconds(arg1);
23903
23904 wxPyEndAllowThreads(__tstate);
23905 if (PyErr_Occurred()) SWIG_fail;
23906 }
23907 {
23908 wxTimeSpan * resultptr;
23909 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23910 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23911 }
23912 return resultobj;
23913 fail:
23914 return NULL;
23915 }
23916
23917
23918 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23919 PyObject *resultobj;
23920 wxTimeSpan result;
23921 char *kwnames[] = {
23922 NULL
23923 };
23924
23925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23926 {
23927 PyThreadState* __tstate = wxPyBeginAllowThreads();
23928 result = wxTimeSpan::Second();
23929
23930 wxPyEndAllowThreads(__tstate);
23931 if (PyErr_Occurred()) SWIG_fail;
23932 }
23933 {
23934 wxTimeSpan * resultptr;
23935 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23937 }
23938 return resultobj;
23939 fail:
23940 return NULL;
23941 }
23942
23943
23944 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23945 PyObject *resultobj;
23946 long arg1 ;
23947 wxTimeSpan result;
23948 PyObject * obj0 = 0 ;
23949 char *kwnames[] = {
23950 (char *) "min", NULL
23951 };
23952
23953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23954 {
23955 arg1 = (long)(SWIG_As_long(obj0));
23956 if (SWIG_arg_fail(1)) SWIG_fail;
23957 }
23958 {
23959 PyThreadState* __tstate = wxPyBeginAllowThreads();
23960 result = wxTimeSpan::Minutes(arg1);
23961
23962 wxPyEndAllowThreads(__tstate);
23963 if (PyErr_Occurred()) SWIG_fail;
23964 }
23965 {
23966 wxTimeSpan * resultptr;
23967 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23968 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23969 }
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23977 PyObject *resultobj;
23978 wxTimeSpan result;
23979 char *kwnames[] = {
23980 NULL
23981 };
23982
23983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 result = wxTimeSpan::Minute();
23987
23988 wxPyEndAllowThreads(__tstate);
23989 if (PyErr_Occurred()) SWIG_fail;
23990 }
23991 {
23992 wxTimeSpan * resultptr;
23993 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23994 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23995 }
23996 return resultobj;
23997 fail:
23998 return NULL;
23999 }
24000
24001
24002 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24003 PyObject *resultobj;
24004 long arg1 ;
24005 wxTimeSpan result;
24006 PyObject * obj0 = 0 ;
24007 char *kwnames[] = {
24008 (char *) "hours", NULL
24009 };
24010
24011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24012 {
24013 arg1 = (long)(SWIG_As_long(obj0));
24014 if (SWIG_arg_fail(1)) SWIG_fail;
24015 }
24016 {
24017 PyThreadState* __tstate = wxPyBeginAllowThreads();
24018 result = wxTimeSpan::Hours(arg1);
24019
24020 wxPyEndAllowThreads(__tstate);
24021 if (PyErr_Occurred()) SWIG_fail;
24022 }
24023 {
24024 wxTimeSpan * resultptr;
24025 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24027 }
24028 return resultobj;
24029 fail:
24030 return NULL;
24031 }
24032
24033
24034 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24035 PyObject *resultobj;
24036 wxTimeSpan result;
24037 char *kwnames[] = {
24038 NULL
24039 };
24040
24041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24042 {
24043 PyThreadState* __tstate = wxPyBeginAllowThreads();
24044 result = wxTimeSpan::Hour();
24045
24046 wxPyEndAllowThreads(__tstate);
24047 if (PyErr_Occurred()) SWIG_fail;
24048 }
24049 {
24050 wxTimeSpan * resultptr;
24051 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24053 }
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj;
24062 long arg1 ;
24063 wxTimeSpan result;
24064 PyObject * obj0 = 0 ;
24065 char *kwnames[] = {
24066 (char *) "days", NULL
24067 };
24068
24069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24070 {
24071 arg1 = (long)(SWIG_As_long(obj0));
24072 if (SWIG_arg_fail(1)) SWIG_fail;
24073 }
24074 {
24075 PyThreadState* __tstate = wxPyBeginAllowThreads();
24076 result = wxTimeSpan::Days(arg1);
24077
24078 wxPyEndAllowThreads(__tstate);
24079 if (PyErr_Occurred()) SWIG_fail;
24080 }
24081 {
24082 wxTimeSpan * resultptr;
24083 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24084 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24085 }
24086 return resultobj;
24087 fail:
24088 return NULL;
24089 }
24090
24091
24092 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24093 PyObject *resultobj;
24094 wxTimeSpan result;
24095 char *kwnames[] = {
24096 NULL
24097 };
24098
24099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 result = wxTimeSpan::Day();
24103
24104 wxPyEndAllowThreads(__tstate);
24105 if (PyErr_Occurred()) SWIG_fail;
24106 }
24107 {
24108 wxTimeSpan * resultptr;
24109 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24111 }
24112 return resultobj;
24113 fail:
24114 return NULL;
24115 }
24116
24117
24118 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24119 PyObject *resultobj;
24120 long arg1 ;
24121 wxTimeSpan result;
24122 PyObject * obj0 = 0 ;
24123 char *kwnames[] = {
24124 (char *) "days", NULL
24125 };
24126
24127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24128 {
24129 arg1 = (long)(SWIG_As_long(obj0));
24130 if (SWIG_arg_fail(1)) SWIG_fail;
24131 }
24132 {
24133 PyThreadState* __tstate = wxPyBeginAllowThreads();
24134 result = wxTimeSpan::Weeks(arg1);
24135
24136 wxPyEndAllowThreads(__tstate);
24137 if (PyErr_Occurred()) SWIG_fail;
24138 }
24139 {
24140 wxTimeSpan * resultptr;
24141 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24143 }
24144 return resultobj;
24145 fail:
24146 return NULL;
24147 }
24148
24149
24150 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24151 PyObject *resultobj;
24152 wxTimeSpan result;
24153 char *kwnames[] = {
24154 NULL
24155 };
24156
24157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 result = wxTimeSpan::Week();
24161
24162 wxPyEndAllowThreads(__tstate);
24163 if (PyErr_Occurred()) SWIG_fail;
24164 }
24165 {
24166 wxTimeSpan * resultptr;
24167 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24169 }
24170 return resultobj;
24171 fail:
24172 return NULL;
24173 }
24174
24175
24176 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24177 PyObject *resultobj;
24178 long arg1 = (long) 0 ;
24179 long arg2 = (long) 0 ;
24180 long arg3 = (long) 0 ;
24181 long arg4 = (long) 0 ;
24182 wxTimeSpan *result;
24183 PyObject * obj0 = 0 ;
24184 PyObject * obj1 = 0 ;
24185 PyObject * obj2 = 0 ;
24186 PyObject * obj3 = 0 ;
24187 char *kwnames[] = {
24188 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24189 };
24190
24191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24192 if (obj0) {
24193 {
24194 arg1 = (long)(SWIG_As_long(obj0));
24195 if (SWIG_arg_fail(1)) SWIG_fail;
24196 }
24197 }
24198 if (obj1) {
24199 {
24200 arg2 = (long)(SWIG_As_long(obj1));
24201 if (SWIG_arg_fail(2)) SWIG_fail;
24202 }
24203 }
24204 if (obj2) {
24205 {
24206 arg3 = (long)(SWIG_As_long(obj2));
24207 if (SWIG_arg_fail(3)) SWIG_fail;
24208 }
24209 }
24210 if (obj3) {
24211 {
24212 arg4 = (long)(SWIG_As_long(obj3));
24213 if (SWIG_arg_fail(4)) SWIG_fail;
24214 }
24215 }
24216 {
24217 PyThreadState* __tstate = wxPyBeginAllowThreads();
24218 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24219
24220 wxPyEndAllowThreads(__tstate);
24221 if (PyErr_Occurred()) SWIG_fail;
24222 }
24223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24224 return resultobj;
24225 fail:
24226 return NULL;
24227 }
24228
24229
24230 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24231 PyObject *resultobj;
24232 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24233 PyObject * obj0 = 0 ;
24234 char *kwnames[] = {
24235 (char *) "self", NULL
24236 };
24237
24238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24240 if (SWIG_arg_fail(1)) SWIG_fail;
24241 {
24242 PyThreadState* __tstate = wxPyBeginAllowThreads();
24243 delete arg1;
24244
24245 wxPyEndAllowThreads(__tstate);
24246 if (PyErr_Occurred()) SWIG_fail;
24247 }
24248 Py_INCREF(Py_None); resultobj = Py_None;
24249 return resultobj;
24250 fail:
24251 return NULL;
24252 }
24253
24254
24255 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24256 PyObject *resultobj;
24257 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24258 wxTimeSpan *arg2 = 0 ;
24259 wxTimeSpan *result;
24260 PyObject * obj0 = 0 ;
24261 PyObject * obj1 = 0 ;
24262 char *kwnames[] = {
24263 (char *) "self",(char *) "diff", NULL
24264 };
24265
24266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24268 if (SWIG_arg_fail(1)) SWIG_fail;
24269 {
24270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24271 if (SWIG_arg_fail(2)) SWIG_fail;
24272 if (arg2 == NULL) {
24273 SWIG_null_ref("wxTimeSpan");
24274 }
24275 if (SWIG_arg_fail(2)) SWIG_fail;
24276 }
24277 {
24278 PyThreadState* __tstate = wxPyBeginAllowThreads();
24279 {
24280 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24281 result = (wxTimeSpan *) &_result_ref;
24282 }
24283
24284 wxPyEndAllowThreads(__tstate);
24285 if (PyErr_Occurred()) SWIG_fail;
24286 }
24287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24295 PyObject *resultobj;
24296 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24297 wxTimeSpan *arg2 = 0 ;
24298 wxTimeSpan *result;
24299 PyObject * obj0 = 0 ;
24300 PyObject * obj1 = 0 ;
24301 char *kwnames[] = {
24302 (char *) "self",(char *) "diff", NULL
24303 };
24304
24305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24307 if (SWIG_arg_fail(1)) SWIG_fail;
24308 {
24309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24310 if (SWIG_arg_fail(2)) SWIG_fail;
24311 if (arg2 == NULL) {
24312 SWIG_null_ref("wxTimeSpan");
24313 }
24314 if (SWIG_arg_fail(2)) SWIG_fail;
24315 }
24316 {
24317 PyThreadState* __tstate = wxPyBeginAllowThreads();
24318 {
24319 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24320 result = (wxTimeSpan *) &_result_ref;
24321 }
24322
24323 wxPyEndAllowThreads(__tstate);
24324 if (PyErr_Occurred()) SWIG_fail;
24325 }
24326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24327 return resultobj;
24328 fail:
24329 return NULL;
24330 }
24331
24332
24333 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24334 PyObject *resultobj;
24335 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24336 int arg2 ;
24337 wxTimeSpan *result;
24338 PyObject * obj0 = 0 ;
24339 PyObject * obj1 = 0 ;
24340 char *kwnames[] = {
24341 (char *) "self",(char *) "n", NULL
24342 };
24343
24344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24346 if (SWIG_arg_fail(1)) SWIG_fail;
24347 {
24348 arg2 = (int)(SWIG_As_int(obj1));
24349 if (SWIG_arg_fail(2)) SWIG_fail;
24350 }
24351 {
24352 PyThreadState* __tstate = wxPyBeginAllowThreads();
24353 {
24354 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24355 result = (wxTimeSpan *) &_result_ref;
24356 }
24357
24358 wxPyEndAllowThreads(__tstate);
24359 if (PyErr_Occurred()) SWIG_fail;
24360 }
24361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24362 return resultobj;
24363 fail:
24364 return NULL;
24365 }
24366
24367
24368 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24369 PyObject *resultobj;
24370 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24371 wxTimeSpan *result;
24372 PyObject * obj0 = 0 ;
24373 char *kwnames[] = {
24374 (char *) "self", NULL
24375 };
24376
24377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24379 if (SWIG_arg_fail(1)) SWIG_fail;
24380 {
24381 PyThreadState* __tstate = wxPyBeginAllowThreads();
24382 {
24383 wxTimeSpan &_result_ref = (arg1)->Neg();
24384 result = (wxTimeSpan *) &_result_ref;
24385 }
24386
24387 wxPyEndAllowThreads(__tstate);
24388 if (PyErr_Occurred()) SWIG_fail;
24389 }
24390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24391 return resultobj;
24392 fail:
24393 return NULL;
24394 }
24395
24396
24397 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24398 PyObject *resultobj;
24399 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24400 wxTimeSpan result;
24401 PyObject * obj0 = 0 ;
24402 char *kwnames[] = {
24403 (char *) "self", NULL
24404 };
24405
24406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24408 if (SWIG_arg_fail(1)) SWIG_fail;
24409 {
24410 PyThreadState* __tstate = wxPyBeginAllowThreads();
24411 result = ((wxTimeSpan const *)arg1)->Abs();
24412
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 {
24417 wxTimeSpan * resultptr;
24418 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24420 }
24421 return resultobj;
24422 fail:
24423 return NULL;
24424 }
24425
24426
24427 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24428 PyObject *resultobj;
24429 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24430 wxTimeSpan *arg2 = 0 ;
24431 wxTimeSpan *result;
24432 PyObject * obj0 = 0 ;
24433 PyObject * obj1 = 0 ;
24434 char *kwnames[] = {
24435 (char *) "self",(char *) "diff", NULL
24436 };
24437
24438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24440 if (SWIG_arg_fail(1)) SWIG_fail;
24441 {
24442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24443 if (SWIG_arg_fail(2)) SWIG_fail;
24444 if (arg2 == NULL) {
24445 SWIG_null_ref("wxTimeSpan");
24446 }
24447 if (SWIG_arg_fail(2)) SWIG_fail;
24448 }
24449 {
24450 PyThreadState* __tstate = wxPyBeginAllowThreads();
24451 {
24452 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24453 result = (wxTimeSpan *) &_result_ref;
24454 }
24455
24456 wxPyEndAllowThreads(__tstate);
24457 if (PyErr_Occurred()) SWIG_fail;
24458 }
24459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24460 return resultobj;
24461 fail:
24462 return NULL;
24463 }
24464
24465
24466 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24467 PyObject *resultobj;
24468 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24469 wxTimeSpan *arg2 = 0 ;
24470 wxTimeSpan *result;
24471 PyObject * obj0 = 0 ;
24472 PyObject * obj1 = 0 ;
24473 char *kwnames[] = {
24474 (char *) "self",(char *) "diff", NULL
24475 };
24476
24477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24479 if (SWIG_arg_fail(1)) SWIG_fail;
24480 {
24481 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24482 if (SWIG_arg_fail(2)) SWIG_fail;
24483 if (arg2 == NULL) {
24484 SWIG_null_ref("wxTimeSpan");
24485 }
24486 if (SWIG_arg_fail(2)) SWIG_fail;
24487 }
24488 {
24489 PyThreadState* __tstate = wxPyBeginAllowThreads();
24490 {
24491 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24492 result = (wxTimeSpan *) &_result_ref;
24493 }
24494
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24506 PyObject *resultobj;
24507 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24508 int arg2 ;
24509 wxTimeSpan *result;
24510 PyObject * obj0 = 0 ;
24511 PyObject * obj1 = 0 ;
24512 char *kwnames[] = {
24513 (char *) "self",(char *) "n", NULL
24514 };
24515
24516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24518 if (SWIG_arg_fail(1)) SWIG_fail;
24519 {
24520 arg2 = (int)(SWIG_As_int(obj1));
24521 if (SWIG_arg_fail(2)) SWIG_fail;
24522 }
24523 {
24524 PyThreadState* __tstate = wxPyBeginAllowThreads();
24525 {
24526 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24527 result = (wxTimeSpan *) &_result_ref;
24528 }
24529
24530 wxPyEndAllowThreads(__tstate);
24531 if (PyErr_Occurred()) SWIG_fail;
24532 }
24533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24534 return resultobj;
24535 fail:
24536 return NULL;
24537 }
24538
24539
24540 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24541 PyObject *resultobj;
24542 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24543 wxTimeSpan *result;
24544 PyObject * obj0 = 0 ;
24545 char *kwnames[] = {
24546 (char *) "self", NULL
24547 };
24548
24549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24551 if (SWIG_arg_fail(1)) SWIG_fail;
24552 {
24553 PyThreadState* __tstate = wxPyBeginAllowThreads();
24554 {
24555 wxTimeSpan &_result_ref = (arg1)->operator -();
24556 result = (wxTimeSpan *) &_result_ref;
24557 }
24558
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24563 return resultobj;
24564 fail:
24565 return NULL;
24566 }
24567
24568
24569 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24570 PyObject *resultobj;
24571 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24572 wxTimeSpan *arg2 = 0 ;
24573 wxTimeSpan result;
24574 PyObject * obj0 = 0 ;
24575 PyObject * obj1 = 0 ;
24576 char *kwnames[] = {
24577 (char *) "self",(char *) "other", NULL
24578 };
24579
24580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24582 if (SWIG_arg_fail(1)) SWIG_fail;
24583 {
24584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24585 if (SWIG_arg_fail(2)) SWIG_fail;
24586 if (arg2 == NULL) {
24587 SWIG_null_ref("wxTimeSpan");
24588 }
24589 if (SWIG_arg_fail(2)) SWIG_fail;
24590 }
24591 {
24592 PyThreadState* __tstate = wxPyBeginAllowThreads();
24593 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24594
24595 wxPyEndAllowThreads(__tstate);
24596 if (PyErr_Occurred()) SWIG_fail;
24597 }
24598 {
24599 wxTimeSpan * resultptr;
24600 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24602 }
24603 return resultobj;
24604 fail:
24605 return NULL;
24606 }
24607
24608
24609 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24610 PyObject *resultobj;
24611 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24612 wxTimeSpan *arg2 = 0 ;
24613 wxTimeSpan result;
24614 PyObject * obj0 = 0 ;
24615 PyObject * obj1 = 0 ;
24616 char *kwnames[] = {
24617 (char *) "self",(char *) "other", NULL
24618 };
24619
24620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24622 if (SWIG_arg_fail(1)) SWIG_fail;
24623 {
24624 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24625 if (SWIG_arg_fail(2)) SWIG_fail;
24626 if (arg2 == NULL) {
24627 SWIG_null_ref("wxTimeSpan");
24628 }
24629 if (SWIG_arg_fail(2)) SWIG_fail;
24630 }
24631 {
24632 PyThreadState* __tstate = wxPyBeginAllowThreads();
24633 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24634
24635 wxPyEndAllowThreads(__tstate);
24636 if (PyErr_Occurred()) SWIG_fail;
24637 }
24638 {
24639 wxTimeSpan * resultptr;
24640 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24641 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24642 }
24643 return resultobj;
24644 fail:
24645 return NULL;
24646 }
24647
24648
24649 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24650 PyObject *resultobj;
24651 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24652 int arg2 ;
24653 wxTimeSpan result;
24654 PyObject * obj0 = 0 ;
24655 PyObject * obj1 = 0 ;
24656 char *kwnames[] = {
24657 (char *) "self",(char *) "n", NULL
24658 };
24659
24660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24662 if (SWIG_arg_fail(1)) SWIG_fail;
24663 {
24664 arg2 = (int)(SWIG_As_int(obj1));
24665 if (SWIG_arg_fail(2)) SWIG_fail;
24666 }
24667 {
24668 PyThreadState* __tstate = wxPyBeginAllowThreads();
24669 result = wxTimeSpan___mul__(arg1,arg2);
24670
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 {
24675 wxTimeSpan * resultptr;
24676 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24677 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24678 }
24679 return resultobj;
24680 fail:
24681 return NULL;
24682 }
24683
24684
24685 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24686 PyObject *resultobj;
24687 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24688 int arg2 ;
24689 wxTimeSpan result;
24690 PyObject * obj0 = 0 ;
24691 PyObject * obj1 = 0 ;
24692 char *kwnames[] = {
24693 (char *) "self",(char *) "n", NULL
24694 };
24695
24696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24698 if (SWIG_arg_fail(1)) SWIG_fail;
24699 {
24700 arg2 = (int)(SWIG_As_int(obj1));
24701 if (SWIG_arg_fail(2)) SWIG_fail;
24702 }
24703 {
24704 PyThreadState* __tstate = wxPyBeginAllowThreads();
24705 result = wxTimeSpan___rmul__(arg1,arg2);
24706
24707 wxPyEndAllowThreads(__tstate);
24708 if (PyErr_Occurred()) SWIG_fail;
24709 }
24710 {
24711 wxTimeSpan * resultptr;
24712 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24714 }
24715 return resultobj;
24716 fail:
24717 return NULL;
24718 }
24719
24720
24721 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24722 PyObject *resultobj;
24723 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24724 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24725 bool result;
24726 PyObject * obj0 = 0 ;
24727 PyObject * obj1 = 0 ;
24728 char *kwnames[] = {
24729 (char *) "self",(char *) "other", NULL
24730 };
24731
24732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24734 if (SWIG_arg_fail(1)) SWIG_fail;
24735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24736 if (SWIG_arg_fail(2)) SWIG_fail;
24737 {
24738 PyThreadState* __tstate = wxPyBeginAllowThreads();
24739 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24740
24741 wxPyEndAllowThreads(__tstate);
24742 if (PyErr_Occurred()) SWIG_fail;
24743 }
24744 {
24745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24746 }
24747 return resultobj;
24748 fail:
24749 return NULL;
24750 }
24751
24752
24753 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24754 PyObject *resultobj;
24755 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24756 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24757 bool result;
24758 PyObject * obj0 = 0 ;
24759 PyObject * obj1 = 0 ;
24760 char *kwnames[] = {
24761 (char *) "self",(char *) "other", NULL
24762 };
24763
24764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24766 if (SWIG_arg_fail(1)) SWIG_fail;
24767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24768 if (SWIG_arg_fail(2)) SWIG_fail;
24769 {
24770 PyThreadState* __tstate = wxPyBeginAllowThreads();
24771 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24772
24773 wxPyEndAllowThreads(__tstate);
24774 if (PyErr_Occurred()) SWIG_fail;
24775 }
24776 {
24777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24778 }
24779 return resultobj;
24780 fail:
24781 return NULL;
24782 }
24783
24784
24785 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24786 PyObject *resultobj;
24787 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24788 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24789 bool result;
24790 PyObject * obj0 = 0 ;
24791 PyObject * obj1 = 0 ;
24792 char *kwnames[] = {
24793 (char *) "self",(char *) "other", NULL
24794 };
24795
24796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24798 if (SWIG_arg_fail(1)) SWIG_fail;
24799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24800 if (SWIG_arg_fail(2)) SWIG_fail;
24801 {
24802 PyThreadState* __tstate = wxPyBeginAllowThreads();
24803 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24804
24805 wxPyEndAllowThreads(__tstate);
24806 if (PyErr_Occurred()) SWIG_fail;
24807 }
24808 {
24809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24810 }
24811 return resultobj;
24812 fail:
24813 return NULL;
24814 }
24815
24816
24817 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24818 PyObject *resultobj;
24819 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24820 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24821 bool result;
24822 PyObject * obj0 = 0 ;
24823 PyObject * obj1 = 0 ;
24824 char *kwnames[] = {
24825 (char *) "self",(char *) "other", NULL
24826 };
24827
24828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24830 if (SWIG_arg_fail(1)) SWIG_fail;
24831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24832 if (SWIG_arg_fail(2)) SWIG_fail;
24833 {
24834 PyThreadState* __tstate = wxPyBeginAllowThreads();
24835 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24836
24837 wxPyEndAllowThreads(__tstate);
24838 if (PyErr_Occurred()) SWIG_fail;
24839 }
24840 {
24841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24842 }
24843 return resultobj;
24844 fail:
24845 return NULL;
24846 }
24847
24848
24849 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24850 PyObject *resultobj;
24851 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24852 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24853 bool result;
24854 PyObject * obj0 = 0 ;
24855 PyObject * obj1 = 0 ;
24856 char *kwnames[] = {
24857 (char *) "self",(char *) "other", NULL
24858 };
24859
24860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24862 if (SWIG_arg_fail(1)) SWIG_fail;
24863 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24864 if (SWIG_arg_fail(2)) SWIG_fail;
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24868
24869 wxPyEndAllowThreads(__tstate);
24870 if (PyErr_Occurred()) SWIG_fail;
24871 }
24872 {
24873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24874 }
24875 return resultobj;
24876 fail:
24877 return NULL;
24878 }
24879
24880
24881 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24882 PyObject *resultobj;
24883 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24884 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24885 bool result;
24886 PyObject * obj0 = 0 ;
24887 PyObject * obj1 = 0 ;
24888 char *kwnames[] = {
24889 (char *) "self",(char *) "other", NULL
24890 };
24891
24892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24894 if (SWIG_arg_fail(1)) SWIG_fail;
24895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24896 if (SWIG_arg_fail(2)) SWIG_fail;
24897 {
24898 PyThreadState* __tstate = wxPyBeginAllowThreads();
24899 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24900
24901 wxPyEndAllowThreads(__tstate);
24902 if (PyErr_Occurred()) SWIG_fail;
24903 }
24904 {
24905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24906 }
24907 return resultobj;
24908 fail:
24909 return NULL;
24910 }
24911
24912
24913 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24914 PyObject *resultobj;
24915 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24916 bool result;
24917 PyObject * obj0 = 0 ;
24918 char *kwnames[] = {
24919 (char *) "self", NULL
24920 };
24921
24922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24924 if (SWIG_arg_fail(1)) SWIG_fail;
24925 {
24926 PyThreadState* __tstate = wxPyBeginAllowThreads();
24927 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24928
24929 wxPyEndAllowThreads(__tstate);
24930 if (PyErr_Occurred()) SWIG_fail;
24931 }
24932 {
24933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24934 }
24935 return resultobj;
24936 fail:
24937 return NULL;
24938 }
24939
24940
24941 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24942 PyObject *resultobj;
24943 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24944 bool result;
24945 PyObject * obj0 = 0 ;
24946 char *kwnames[] = {
24947 (char *) "self", NULL
24948 };
24949
24950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24952 if (SWIG_arg_fail(1)) SWIG_fail;
24953 {
24954 PyThreadState* __tstate = wxPyBeginAllowThreads();
24955 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24956
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 {
24961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24962 }
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24970 PyObject *resultobj;
24971 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24972 bool result;
24973 PyObject * obj0 = 0 ;
24974 char *kwnames[] = {
24975 (char *) "self", NULL
24976 };
24977
24978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24980 if (SWIG_arg_fail(1)) SWIG_fail;
24981 {
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24984
24985 wxPyEndAllowThreads(__tstate);
24986 if (PyErr_Occurred()) SWIG_fail;
24987 }
24988 {
24989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24990 }
24991 return resultobj;
24992 fail:
24993 return NULL;
24994 }
24995
24996
24997 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24998 PyObject *resultobj;
24999 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25000 wxTimeSpan *arg2 = 0 ;
25001 bool result;
25002 PyObject * obj0 = 0 ;
25003 PyObject * obj1 = 0 ;
25004 char *kwnames[] = {
25005 (char *) "self",(char *) "ts", NULL
25006 };
25007
25008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25010 if (SWIG_arg_fail(1)) SWIG_fail;
25011 {
25012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25013 if (SWIG_arg_fail(2)) SWIG_fail;
25014 if (arg2 == NULL) {
25015 SWIG_null_ref("wxTimeSpan");
25016 }
25017 if (SWIG_arg_fail(2)) SWIG_fail;
25018 }
25019 {
25020 PyThreadState* __tstate = wxPyBeginAllowThreads();
25021 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25022
25023 wxPyEndAllowThreads(__tstate);
25024 if (PyErr_Occurred()) SWIG_fail;
25025 }
25026 {
25027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25028 }
25029 return resultobj;
25030 fail:
25031 return NULL;
25032 }
25033
25034
25035 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25036 PyObject *resultobj;
25037 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25038 wxTimeSpan *arg2 = 0 ;
25039 bool result;
25040 PyObject * obj0 = 0 ;
25041 PyObject * obj1 = 0 ;
25042 char *kwnames[] = {
25043 (char *) "self",(char *) "ts", NULL
25044 };
25045
25046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25048 if (SWIG_arg_fail(1)) SWIG_fail;
25049 {
25050 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25051 if (SWIG_arg_fail(2)) SWIG_fail;
25052 if (arg2 == NULL) {
25053 SWIG_null_ref("wxTimeSpan");
25054 }
25055 if (SWIG_arg_fail(2)) SWIG_fail;
25056 }
25057 {
25058 PyThreadState* __tstate = wxPyBeginAllowThreads();
25059 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25060
25061 wxPyEndAllowThreads(__tstate);
25062 if (PyErr_Occurred()) SWIG_fail;
25063 }
25064 {
25065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25066 }
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25074 PyObject *resultobj;
25075 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25076 wxTimeSpan *arg2 = 0 ;
25077 bool result;
25078 PyObject * obj0 = 0 ;
25079 PyObject * obj1 = 0 ;
25080 char *kwnames[] = {
25081 (char *) "self",(char *) "t", NULL
25082 };
25083
25084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25086 if (SWIG_arg_fail(1)) SWIG_fail;
25087 {
25088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25089 if (SWIG_arg_fail(2)) SWIG_fail;
25090 if (arg2 == NULL) {
25091 SWIG_null_ref("wxTimeSpan");
25092 }
25093 if (SWIG_arg_fail(2)) SWIG_fail;
25094 }
25095 {
25096 PyThreadState* __tstate = wxPyBeginAllowThreads();
25097 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25098
25099 wxPyEndAllowThreads(__tstate);
25100 if (PyErr_Occurred()) SWIG_fail;
25101 }
25102 {
25103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25104 }
25105 return resultobj;
25106 fail:
25107 return NULL;
25108 }
25109
25110
25111 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25112 PyObject *resultobj;
25113 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25114 int result;
25115 PyObject * obj0 = 0 ;
25116 char *kwnames[] = {
25117 (char *) "self", NULL
25118 };
25119
25120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25122 if (SWIG_arg_fail(1)) SWIG_fail;
25123 {
25124 PyThreadState* __tstate = wxPyBeginAllowThreads();
25125 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25126
25127 wxPyEndAllowThreads(__tstate);
25128 if (PyErr_Occurred()) SWIG_fail;
25129 }
25130 {
25131 resultobj = SWIG_From_int((int)(result));
25132 }
25133 return resultobj;
25134 fail:
25135 return NULL;
25136 }
25137
25138
25139 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25140 PyObject *resultobj;
25141 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25142 int result;
25143 PyObject * obj0 = 0 ;
25144 char *kwnames[] = {
25145 (char *) "self", NULL
25146 };
25147
25148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25150 if (SWIG_arg_fail(1)) SWIG_fail;
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25154
25155 wxPyEndAllowThreads(__tstate);
25156 if (PyErr_Occurred()) SWIG_fail;
25157 }
25158 {
25159 resultobj = SWIG_From_int((int)(result));
25160 }
25161 return resultobj;
25162 fail:
25163 return NULL;
25164 }
25165
25166
25167 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25168 PyObject *resultobj;
25169 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25170 int result;
25171 PyObject * obj0 = 0 ;
25172 char *kwnames[] = {
25173 (char *) "self", NULL
25174 };
25175
25176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25178 if (SWIG_arg_fail(1)) SWIG_fail;
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25182
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 {
25187 resultobj = SWIG_From_int((int)(result));
25188 }
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25196 PyObject *resultobj;
25197 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25198 int result;
25199 PyObject * obj0 = 0 ;
25200 char *kwnames[] = {
25201 (char *) "self", NULL
25202 };
25203
25204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25206 if (SWIG_arg_fail(1)) SWIG_fail;
25207 {
25208 PyThreadState* __tstate = wxPyBeginAllowThreads();
25209 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25210
25211 wxPyEndAllowThreads(__tstate);
25212 if (PyErr_Occurred()) SWIG_fail;
25213 }
25214 {
25215 resultobj = SWIG_From_int((int)(result));
25216 }
25217 return resultobj;
25218 fail:
25219 return NULL;
25220 }
25221
25222
25223 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25224 PyObject *resultobj;
25225 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25226 wxLongLong result;
25227 PyObject * obj0 = 0 ;
25228 char *kwnames[] = {
25229 (char *) "self", NULL
25230 };
25231
25232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25234 if (SWIG_arg_fail(1)) SWIG_fail;
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25238
25239 wxPyEndAllowThreads(__tstate);
25240 if (PyErr_Occurred()) SWIG_fail;
25241 }
25242 {
25243 PyObject *hi, *lo, *shifter, *shifted;
25244 hi = PyLong_FromLong( (&result)->GetHi() );
25245 lo = PyLong_FromLong( (&result)->GetLo() );
25246 shifter = PyLong_FromLong(32);
25247 shifted = PyNumber_Lshift(hi, shifter);
25248 resultobj = PyNumber_Or(shifted, lo);
25249 Py_DECREF(hi);
25250 Py_DECREF(lo);
25251 Py_DECREF(shifter);
25252 Py_DECREF(shifted);
25253 }
25254 return resultobj;
25255 fail:
25256 return NULL;
25257 }
25258
25259
25260 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25261 PyObject *resultobj;
25262 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25263 wxLongLong result;
25264 PyObject * obj0 = 0 ;
25265 char *kwnames[] = {
25266 (char *) "self", NULL
25267 };
25268
25269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25271 if (SWIG_arg_fail(1)) SWIG_fail;
25272 {
25273 PyThreadState* __tstate = wxPyBeginAllowThreads();
25274 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25275
25276 wxPyEndAllowThreads(__tstate);
25277 if (PyErr_Occurred()) SWIG_fail;
25278 }
25279 {
25280 PyObject *hi, *lo, *shifter, *shifted;
25281 hi = PyLong_FromLong( (&result)->GetHi() );
25282 lo = PyLong_FromLong( (&result)->GetLo() );
25283 shifter = PyLong_FromLong(32);
25284 shifted = PyNumber_Lshift(hi, shifter);
25285 resultobj = PyNumber_Or(shifted, lo);
25286 Py_DECREF(hi);
25287 Py_DECREF(lo);
25288 Py_DECREF(shifter);
25289 Py_DECREF(shifted);
25290 }
25291 return resultobj;
25292 fail:
25293 return NULL;
25294 }
25295
25296
25297 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25298 PyObject *resultobj;
25299 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25300 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25301 wxString *arg2 = (wxString *) &arg2_defvalue ;
25302 wxString result;
25303 bool temp2 = false ;
25304 PyObject * obj0 = 0 ;
25305 PyObject * obj1 = 0 ;
25306 char *kwnames[] = {
25307 (char *) "self",(char *) "format", NULL
25308 };
25309
25310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25312 if (SWIG_arg_fail(1)) SWIG_fail;
25313 if (obj1) {
25314 {
25315 arg2 = wxString_in_helper(obj1);
25316 if (arg2 == NULL) SWIG_fail;
25317 temp2 = true;
25318 }
25319 }
25320 {
25321 PyThreadState* __tstate = wxPyBeginAllowThreads();
25322 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25323
25324 wxPyEndAllowThreads(__tstate);
25325 if (PyErr_Occurred()) SWIG_fail;
25326 }
25327 {
25328 #if wxUSE_UNICODE
25329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25330 #else
25331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25332 #endif
25333 }
25334 {
25335 if (temp2)
25336 delete arg2;
25337 }
25338 return resultobj;
25339 fail:
25340 {
25341 if (temp2)
25342 delete arg2;
25343 }
25344 return NULL;
25345 }
25346
25347
25348 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25349 PyObject *obj;
25350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25351 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25352 Py_INCREF(obj);
25353 return Py_BuildValue((char *)"");
25354 }
25355 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25356 PyObject *resultobj;
25357 int arg1 = (int) 0 ;
25358 int arg2 = (int) 0 ;
25359 int arg3 = (int) 0 ;
25360 int arg4 = (int) 0 ;
25361 wxDateSpan *result;
25362 PyObject * obj0 = 0 ;
25363 PyObject * obj1 = 0 ;
25364 PyObject * obj2 = 0 ;
25365 PyObject * obj3 = 0 ;
25366 char *kwnames[] = {
25367 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25368 };
25369
25370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25371 if (obj0) {
25372 {
25373 arg1 = (int)(SWIG_As_int(obj0));
25374 if (SWIG_arg_fail(1)) SWIG_fail;
25375 }
25376 }
25377 if (obj1) {
25378 {
25379 arg2 = (int)(SWIG_As_int(obj1));
25380 if (SWIG_arg_fail(2)) SWIG_fail;
25381 }
25382 }
25383 if (obj2) {
25384 {
25385 arg3 = (int)(SWIG_As_int(obj2));
25386 if (SWIG_arg_fail(3)) SWIG_fail;
25387 }
25388 }
25389 if (obj3) {
25390 {
25391 arg4 = (int)(SWIG_As_int(obj3));
25392 if (SWIG_arg_fail(4)) SWIG_fail;
25393 }
25394 }
25395 {
25396 PyThreadState* __tstate = wxPyBeginAllowThreads();
25397 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25398
25399 wxPyEndAllowThreads(__tstate);
25400 if (PyErr_Occurred()) SWIG_fail;
25401 }
25402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25403 return resultobj;
25404 fail:
25405 return NULL;
25406 }
25407
25408
25409 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25410 PyObject *resultobj;
25411 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25412 PyObject * obj0 = 0 ;
25413 char *kwnames[] = {
25414 (char *) "self", NULL
25415 };
25416
25417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25419 if (SWIG_arg_fail(1)) SWIG_fail;
25420 {
25421 PyThreadState* __tstate = wxPyBeginAllowThreads();
25422 delete arg1;
25423
25424 wxPyEndAllowThreads(__tstate);
25425 if (PyErr_Occurred()) SWIG_fail;
25426 }
25427 Py_INCREF(Py_None); resultobj = Py_None;
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25435 PyObject *resultobj;
25436 int arg1 ;
25437 wxDateSpan result;
25438 PyObject * obj0 = 0 ;
25439 char *kwnames[] = {
25440 (char *) "days", NULL
25441 };
25442
25443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25444 {
25445 arg1 = (int)(SWIG_As_int(obj0));
25446 if (SWIG_arg_fail(1)) SWIG_fail;
25447 }
25448 {
25449 PyThreadState* __tstate = wxPyBeginAllowThreads();
25450 result = wxDateSpan::Days(arg1);
25451
25452 wxPyEndAllowThreads(__tstate);
25453 if (PyErr_Occurred()) SWIG_fail;
25454 }
25455 {
25456 wxDateSpan * resultptr;
25457 resultptr = new wxDateSpan((wxDateSpan &)(result));
25458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25459 }
25460 return resultobj;
25461 fail:
25462 return NULL;
25463 }
25464
25465
25466 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25467 PyObject *resultobj;
25468 wxDateSpan result;
25469 char *kwnames[] = {
25470 NULL
25471 };
25472
25473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25474 {
25475 PyThreadState* __tstate = wxPyBeginAllowThreads();
25476 result = wxDateSpan::Day();
25477
25478 wxPyEndAllowThreads(__tstate);
25479 if (PyErr_Occurred()) SWIG_fail;
25480 }
25481 {
25482 wxDateSpan * resultptr;
25483 resultptr = new wxDateSpan((wxDateSpan &)(result));
25484 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25485 }
25486 return resultobj;
25487 fail:
25488 return NULL;
25489 }
25490
25491
25492 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25493 PyObject *resultobj;
25494 int arg1 ;
25495 wxDateSpan result;
25496 PyObject * obj0 = 0 ;
25497 char *kwnames[] = {
25498 (char *) "weeks", NULL
25499 };
25500
25501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25502 {
25503 arg1 = (int)(SWIG_As_int(obj0));
25504 if (SWIG_arg_fail(1)) SWIG_fail;
25505 }
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 result = wxDateSpan::Weeks(arg1);
25509
25510 wxPyEndAllowThreads(__tstate);
25511 if (PyErr_Occurred()) SWIG_fail;
25512 }
25513 {
25514 wxDateSpan * resultptr;
25515 resultptr = new wxDateSpan((wxDateSpan &)(result));
25516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25517 }
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25525 PyObject *resultobj;
25526 wxDateSpan result;
25527 char *kwnames[] = {
25528 NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25532 {
25533 PyThreadState* __tstate = wxPyBeginAllowThreads();
25534 result = wxDateSpan::Week();
25535
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 {
25540 wxDateSpan * resultptr;
25541 resultptr = new wxDateSpan((wxDateSpan &)(result));
25542 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25543 }
25544 return resultobj;
25545 fail:
25546 return NULL;
25547 }
25548
25549
25550 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25551 PyObject *resultobj;
25552 int arg1 ;
25553 wxDateSpan result;
25554 PyObject * obj0 = 0 ;
25555 char *kwnames[] = {
25556 (char *) "mon", NULL
25557 };
25558
25559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25560 {
25561 arg1 = (int)(SWIG_As_int(obj0));
25562 if (SWIG_arg_fail(1)) SWIG_fail;
25563 }
25564 {
25565 PyThreadState* __tstate = wxPyBeginAllowThreads();
25566 result = wxDateSpan::Months(arg1);
25567
25568 wxPyEndAllowThreads(__tstate);
25569 if (PyErr_Occurred()) SWIG_fail;
25570 }
25571 {
25572 wxDateSpan * resultptr;
25573 resultptr = new wxDateSpan((wxDateSpan &)(result));
25574 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25575 }
25576 return resultobj;
25577 fail:
25578 return NULL;
25579 }
25580
25581
25582 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25583 PyObject *resultobj;
25584 wxDateSpan result;
25585 char *kwnames[] = {
25586 NULL
25587 };
25588
25589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25590 {
25591 PyThreadState* __tstate = wxPyBeginAllowThreads();
25592 result = wxDateSpan::Month();
25593
25594 wxPyEndAllowThreads(__tstate);
25595 if (PyErr_Occurred()) SWIG_fail;
25596 }
25597 {
25598 wxDateSpan * resultptr;
25599 resultptr = new wxDateSpan((wxDateSpan &)(result));
25600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25601 }
25602 return resultobj;
25603 fail:
25604 return NULL;
25605 }
25606
25607
25608 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25609 PyObject *resultobj;
25610 int arg1 ;
25611 wxDateSpan result;
25612 PyObject * obj0 = 0 ;
25613 char *kwnames[] = {
25614 (char *) "years", NULL
25615 };
25616
25617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25618 {
25619 arg1 = (int)(SWIG_As_int(obj0));
25620 if (SWIG_arg_fail(1)) SWIG_fail;
25621 }
25622 {
25623 PyThreadState* __tstate = wxPyBeginAllowThreads();
25624 result = wxDateSpan::Years(arg1);
25625
25626 wxPyEndAllowThreads(__tstate);
25627 if (PyErr_Occurred()) SWIG_fail;
25628 }
25629 {
25630 wxDateSpan * resultptr;
25631 resultptr = new wxDateSpan((wxDateSpan &)(result));
25632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25633 }
25634 return resultobj;
25635 fail:
25636 return NULL;
25637 }
25638
25639
25640 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25641 PyObject *resultobj;
25642 wxDateSpan result;
25643 char *kwnames[] = {
25644 NULL
25645 };
25646
25647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25648 {
25649 PyThreadState* __tstate = wxPyBeginAllowThreads();
25650 result = wxDateSpan::Year();
25651
25652 wxPyEndAllowThreads(__tstate);
25653 if (PyErr_Occurred()) SWIG_fail;
25654 }
25655 {
25656 wxDateSpan * resultptr;
25657 resultptr = new wxDateSpan((wxDateSpan &)(result));
25658 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25659 }
25660 return resultobj;
25661 fail:
25662 return NULL;
25663 }
25664
25665
25666 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25667 PyObject *resultobj;
25668 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25669 int arg2 ;
25670 wxDateSpan *result;
25671 PyObject * obj0 = 0 ;
25672 PyObject * obj1 = 0 ;
25673 char *kwnames[] = {
25674 (char *) "self",(char *) "n", NULL
25675 };
25676
25677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
25682 if (SWIG_arg_fail(2)) SWIG_fail;
25683 }
25684 {
25685 PyThreadState* __tstate = wxPyBeginAllowThreads();
25686 {
25687 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25688 result = (wxDateSpan *) &_result_ref;
25689 }
25690
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj;
25703 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25704 int arg2 ;
25705 wxDateSpan *result;
25706 PyObject * obj0 = 0 ;
25707 PyObject * obj1 = 0 ;
25708 char *kwnames[] = {
25709 (char *) "self",(char *) "n", NULL
25710 };
25711
25712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25714 if (SWIG_arg_fail(1)) SWIG_fail;
25715 {
25716 arg2 = (int)(SWIG_As_int(obj1));
25717 if (SWIG_arg_fail(2)) SWIG_fail;
25718 }
25719 {
25720 PyThreadState* __tstate = wxPyBeginAllowThreads();
25721 {
25722 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25723 result = (wxDateSpan *) &_result_ref;
25724 }
25725
25726 wxPyEndAllowThreads(__tstate);
25727 if (PyErr_Occurred()) SWIG_fail;
25728 }
25729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25730 return resultobj;
25731 fail:
25732 return NULL;
25733 }
25734
25735
25736 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25737 PyObject *resultobj;
25738 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25739 int arg2 ;
25740 wxDateSpan *result;
25741 PyObject * obj0 = 0 ;
25742 PyObject * obj1 = 0 ;
25743 char *kwnames[] = {
25744 (char *) "self",(char *) "n", NULL
25745 };
25746
25747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25749 if (SWIG_arg_fail(1)) SWIG_fail;
25750 {
25751 arg2 = (int)(SWIG_As_int(obj1));
25752 if (SWIG_arg_fail(2)) SWIG_fail;
25753 }
25754 {
25755 PyThreadState* __tstate = wxPyBeginAllowThreads();
25756 {
25757 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25758 result = (wxDateSpan *) &_result_ref;
25759 }
25760
25761 wxPyEndAllowThreads(__tstate);
25762 if (PyErr_Occurred()) SWIG_fail;
25763 }
25764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25765 return resultobj;
25766 fail:
25767 return NULL;
25768 }
25769
25770
25771 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25772 PyObject *resultobj;
25773 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25774 int arg2 ;
25775 wxDateSpan *result;
25776 PyObject * obj0 = 0 ;
25777 PyObject * obj1 = 0 ;
25778 char *kwnames[] = {
25779 (char *) "self",(char *) "n", NULL
25780 };
25781
25782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25784 if (SWIG_arg_fail(1)) SWIG_fail;
25785 {
25786 arg2 = (int)(SWIG_As_int(obj1));
25787 if (SWIG_arg_fail(2)) SWIG_fail;
25788 }
25789 {
25790 PyThreadState* __tstate = wxPyBeginAllowThreads();
25791 {
25792 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25793 result = (wxDateSpan *) &_result_ref;
25794 }
25795
25796 wxPyEndAllowThreads(__tstate);
25797 if (PyErr_Occurred()) SWIG_fail;
25798 }
25799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25800 return resultobj;
25801 fail:
25802 return NULL;
25803 }
25804
25805
25806 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25807 PyObject *resultobj;
25808 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25809 int result;
25810 PyObject * obj0 = 0 ;
25811 char *kwnames[] = {
25812 (char *) "self", NULL
25813 };
25814
25815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25817 if (SWIG_arg_fail(1)) SWIG_fail;
25818 {
25819 PyThreadState* __tstate = wxPyBeginAllowThreads();
25820 result = (int)((wxDateSpan const *)arg1)->GetYears();
25821
25822 wxPyEndAllowThreads(__tstate);
25823 if (PyErr_Occurred()) SWIG_fail;
25824 }
25825 {
25826 resultobj = SWIG_From_int((int)(result));
25827 }
25828 return resultobj;
25829 fail:
25830 return NULL;
25831 }
25832
25833
25834 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25835 PyObject *resultobj;
25836 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25837 int result;
25838 PyObject * obj0 = 0 ;
25839 char *kwnames[] = {
25840 (char *) "self", NULL
25841 };
25842
25843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25845 if (SWIG_arg_fail(1)) SWIG_fail;
25846 {
25847 PyThreadState* __tstate = wxPyBeginAllowThreads();
25848 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25849
25850 wxPyEndAllowThreads(__tstate);
25851 if (PyErr_Occurred()) SWIG_fail;
25852 }
25853 {
25854 resultobj = SWIG_From_int((int)(result));
25855 }
25856 return resultobj;
25857 fail:
25858 return NULL;
25859 }
25860
25861
25862 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25863 PyObject *resultobj;
25864 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25865 int result;
25866 PyObject * obj0 = 0 ;
25867 char *kwnames[] = {
25868 (char *) "self", NULL
25869 };
25870
25871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25873 if (SWIG_arg_fail(1)) SWIG_fail;
25874 {
25875 PyThreadState* __tstate = wxPyBeginAllowThreads();
25876 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25877
25878 wxPyEndAllowThreads(__tstate);
25879 if (PyErr_Occurred()) SWIG_fail;
25880 }
25881 {
25882 resultobj = SWIG_From_int((int)(result));
25883 }
25884 return resultobj;
25885 fail:
25886 return NULL;
25887 }
25888
25889
25890 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25891 PyObject *resultobj;
25892 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25893 int result;
25894 PyObject * obj0 = 0 ;
25895 char *kwnames[] = {
25896 (char *) "self", NULL
25897 };
25898
25899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25901 if (SWIG_arg_fail(1)) SWIG_fail;
25902 {
25903 PyThreadState* __tstate = wxPyBeginAllowThreads();
25904 result = (int)((wxDateSpan const *)arg1)->GetDays();
25905
25906 wxPyEndAllowThreads(__tstate);
25907 if (PyErr_Occurred()) SWIG_fail;
25908 }
25909 {
25910 resultobj = SWIG_From_int((int)(result));
25911 }
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25919 PyObject *resultobj;
25920 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25921 int result;
25922 PyObject * obj0 = 0 ;
25923 char *kwnames[] = {
25924 (char *) "self", NULL
25925 };
25926
25927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25929 if (SWIG_arg_fail(1)) SWIG_fail;
25930 {
25931 PyThreadState* __tstate = wxPyBeginAllowThreads();
25932 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25933
25934 wxPyEndAllowThreads(__tstate);
25935 if (PyErr_Occurred()) SWIG_fail;
25936 }
25937 {
25938 resultobj = SWIG_From_int((int)(result));
25939 }
25940 return resultobj;
25941 fail:
25942 return NULL;
25943 }
25944
25945
25946 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25947 PyObject *resultobj;
25948 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25949 wxDateSpan *arg2 = 0 ;
25950 wxDateSpan *result;
25951 PyObject * obj0 = 0 ;
25952 PyObject * obj1 = 0 ;
25953 char *kwnames[] = {
25954 (char *) "self",(char *) "other", NULL
25955 };
25956
25957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25959 if (SWIG_arg_fail(1)) SWIG_fail;
25960 {
25961 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25962 if (SWIG_arg_fail(2)) SWIG_fail;
25963 if (arg2 == NULL) {
25964 SWIG_null_ref("wxDateSpan");
25965 }
25966 if (SWIG_arg_fail(2)) SWIG_fail;
25967 }
25968 {
25969 PyThreadState* __tstate = wxPyBeginAllowThreads();
25970 {
25971 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25972 result = (wxDateSpan *) &_result_ref;
25973 }
25974
25975 wxPyEndAllowThreads(__tstate);
25976 if (PyErr_Occurred()) SWIG_fail;
25977 }
25978 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25979 return resultobj;
25980 fail:
25981 return NULL;
25982 }
25983
25984
25985 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25986 PyObject *resultobj;
25987 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25988 wxDateSpan *arg2 = 0 ;
25989 wxDateSpan *result;
25990 PyObject * obj0 = 0 ;
25991 PyObject * obj1 = 0 ;
25992 char *kwnames[] = {
25993 (char *) "self",(char *) "other", NULL
25994 };
25995
25996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25998 if (SWIG_arg_fail(1)) SWIG_fail;
25999 {
26000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26001 if (SWIG_arg_fail(2)) SWIG_fail;
26002 if (arg2 == NULL) {
26003 SWIG_null_ref("wxDateSpan");
26004 }
26005 if (SWIG_arg_fail(2)) SWIG_fail;
26006 }
26007 {
26008 PyThreadState* __tstate = wxPyBeginAllowThreads();
26009 {
26010 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26011 result = (wxDateSpan *) &_result_ref;
26012 }
26013
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj;
26026 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26027 wxDateSpan *result;
26028 PyObject * obj0 = 0 ;
26029 char *kwnames[] = {
26030 (char *) "self", NULL
26031 };
26032
26033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26035 if (SWIG_arg_fail(1)) SWIG_fail;
26036 {
26037 PyThreadState* __tstate = wxPyBeginAllowThreads();
26038 {
26039 wxDateSpan &_result_ref = (arg1)->Neg();
26040 result = (wxDateSpan *) &_result_ref;
26041 }
26042
26043 wxPyEndAllowThreads(__tstate);
26044 if (PyErr_Occurred()) SWIG_fail;
26045 }
26046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26047 return resultobj;
26048 fail:
26049 return NULL;
26050 }
26051
26052
26053 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26054 PyObject *resultobj;
26055 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26056 int arg2 ;
26057 wxDateSpan *result;
26058 PyObject * obj0 = 0 ;
26059 PyObject * obj1 = 0 ;
26060 char *kwnames[] = {
26061 (char *) "self",(char *) "factor", NULL
26062 };
26063
26064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26066 if (SWIG_arg_fail(1)) SWIG_fail;
26067 {
26068 arg2 = (int)(SWIG_As_int(obj1));
26069 if (SWIG_arg_fail(2)) SWIG_fail;
26070 }
26071 {
26072 PyThreadState* __tstate = wxPyBeginAllowThreads();
26073 {
26074 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26075 result = (wxDateSpan *) &_result_ref;
26076 }
26077
26078 wxPyEndAllowThreads(__tstate);
26079 if (PyErr_Occurred()) SWIG_fail;
26080 }
26081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26082 return resultobj;
26083 fail:
26084 return NULL;
26085 }
26086
26087
26088 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26089 PyObject *resultobj;
26090 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26091 wxDateSpan *arg2 = 0 ;
26092 wxDateSpan *result;
26093 PyObject * obj0 = 0 ;
26094 PyObject * obj1 = 0 ;
26095 char *kwnames[] = {
26096 (char *) "self",(char *) "other", NULL
26097 };
26098
26099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26101 if (SWIG_arg_fail(1)) SWIG_fail;
26102 {
26103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26104 if (SWIG_arg_fail(2)) SWIG_fail;
26105 if (arg2 == NULL) {
26106 SWIG_null_ref("wxDateSpan");
26107 }
26108 if (SWIG_arg_fail(2)) SWIG_fail;
26109 }
26110 {
26111 PyThreadState* __tstate = wxPyBeginAllowThreads();
26112 {
26113 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26114 result = (wxDateSpan *) &_result_ref;
26115 }
26116
26117 wxPyEndAllowThreads(__tstate);
26118 if (PyErr_Occurred()) SWIG_fail;
26119 }
26120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26121 return resultobj;
26122 fail:
26123 return NULL;
26124 }
26125
26126
26127 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26128 PyObject *resultobj;
26129 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26130 wxDateSpan *arg2 = 0 ;
26131 wxDateSpan *result;
26132 PyObject * obj0 = 0 ;
26133 PyObject * obj1 = 0 ;
26134 char *kwnames[] = {
26135 (char *) "self",(char *) "other", NULL
26136 };
26137
26138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26140 if (SWIG_arg_fail(1)) SWIG_fail;
26141 {
26142 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26143 if (SWIG_arg_fail(2)) SWIG_fail;
26144 if (arg2 == NULL) {
26145 SWIG_null_ref("wxDateSpan");
26146 }
26147 if (SWIG_arg_fail(2)) SWIG_fail;
26148 }
26149 {
26150 PyThreadState* __tstate = wxPyBeginAllowThreads();
26151 {
26152 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26153 result = (wxDateSpan *) &_result_ref;
26154 }
26155
26156 wxPyEndAllowThreads(__tstate);
26157 if (PyErr_Occurred()) SWIG_fail;
26158 }
26159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26160 return resultobj;
26161 fail:
26162 return NULL;
26163 }
26164
26165
26166 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26167 PyObject *resultobj;
26168 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26169 wxDateSpan *result;
26170 PyObject * obj0 = 0 ;
26171 char *kwnames[] = {
26172 (char *) "self", NULL
26173 };
26174
26175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26177 if (SWIG_arg_fail(1)) SWIG_fail;
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 {
26181 wxDateSpan &_result_ref = (arg1)->operator -();
26182 result = (wxDateSpan *) &_result_ref;
26183 }
26184
26185 wxPyEndAllowThreads(__tstate);
26186 if (PyErr_Occurred()) SWIG_fail;
26187 }
26188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26189 return resultobj;
26190 fail:
26191 return NULL;
26192 }
26193
26194
26195 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26196 PyObject *resultobj;
26197 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26198 int arg2 ;
26199 wxDateSpan *result;
26200 PyObject * obj0 = 0 ;
26201 PyObject * obj1 = 0 ;
26202 char *kwnames[] = {
26203 (char *) "self",(char *) "factor", NULL
26204 };
26205
26206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26208 if (SWIG_arg_fail(1)) SWIG_fail;
26209 {
26210 arg2 = (int)(SWIG_As_int(obj1));
26211 if (SWIG_arg_fail(2)) SWIG_fail;
26212 }
26213 {
26214 PyThreadState* __tstate = wxPyBeginAllowThreads();
26215 {
26216 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26217 result = (wxDateSpan *) &_result_ref;
26218 }
26219
26220 wxPyEndAllowThreads(__tstate);
26221 if (PyErr_Occurred()) SWIG_fail;
26222 }
26223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26224 return resultobj;
26225 fail:
26226 return NULL;
26227 }
26228
26229
26230 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26231 PyObject *resultobj;
26232 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26233 wxDateSpan *arg2 = 0 ;
26234 wxDateSpan result;
26235 PyObject * obj0 = 0 ;
26236 PyObject * obj1 = 0 ;
26237 char *kwnames[] = {
26238 (char *) "self",(char *) "other", NULL
26239 };
26240
26241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26243 if (SWIG_arg_fail(1)) SWIG_fail;
26244 {
26245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26246 if (SWIG_arg_fail(2)) SWIG_fail;
26247 if (arg2 == NULL) {
26248 SWIG_null_ref("wxDateSpan");
26249 }
26250 if (SWIG_arg_fail(2)) SWIG_fail;
26251 }
26252 {
26253 PyThreadState* __tstate = wxPyBeginAllowThreads();
26254 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26255
26256 wxPyEndAllowThreads(__tstate);
26257 if (PyErr_Occurred()) SWIG_fail;
26258 }
26259 {
26260 wxDateSpan * resultptr;
26261 resultptr = new wxDateSpan((wxDateSpan &)(result));
26262 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26263 }
26264 return resultobj;
26265 fail:
26266 return NULL;
26267 }
26268
26269
26270 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26271 PyObject *resultobj;
26272 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26273 wxDateSpan *arg2 = 0 ;
26274 wxDateSpan result;
26275 PyObject * obj0 = 0 ;
26276 PyObject * obj1 = 0 ;
26277 char *kwnames[] = {
26278 (char *) "self",(char *) "other", NULL
26279 };
26280
26281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26283 if (SWIG_arg_fail(1)) SWIG_fail;
26284 {
26285 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26286 if (SWIG_arg_fail(2)) SWIG_fail;
26287 if (arg2 == NULL) {
26288 SWIG_null_ref("wxDateSpan");
26289 }
26290 if (SWIG_arg_fail(2)) SWIG_fail;
26291 }
26292 {
26293 PyThreadState* __tstate = wxPyBeginAllowThreads();
26294 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26295
26296 wxPyEndAllowThreads(__tstate);
26297 if (PyErr_Occurred()) SWIG_fail;
26298 }
26299 {
26300 wxDateSpan * resultptr;
26301 resultptr = new wxDateSpan((wxDateSpan &)(result));
26302 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26303 }
26304 return resultobj;
26305 fail:
26306 return NULL;
26307 }
26308
26309
26310 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26311 PyObject *resultobj;
26312 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26313 int arg2 ;
26314 wxDateSpan result;
26315 PyObject * obj0 = 0 ;
26316 PyObject * obj1 = 0 ;
26317 char *kwnames[] = {
26318 (char *) "self",(char *) "n", NULL
26319 };
26320
26321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26323 if (SWIG_arg_fail(1)) SWIG_fail;
26324 {
26325 arg2 = (int)(SWIG_As_int(obj1));
26326 if (SWIG_arg_fail(2)) SWIG_fail;
26327 }
26328 {
26329 PyThreadState* __tstate = wxPyBeginAllowThreads();
26330 result = wxDateSpan___mul__(arg1,arg2);
26331
26332 wxPyEndAllowThreads(__tstate);
26333 if (PyErr_Occurred()) SWIG_fail;
26334 }
26335 {
26336 wxDateSpan * resultptr;
26337 resultptr = new wxDateSpan((wxDateSpan &)(result));
26338 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26339 }
26340 return resultobj;
26341 fail:
26342 return NULL;
26343 }
26344
26345
26346 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26347 PyObject *resultobj;
26348 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26349 int arg2 ;
26350 wxDateSpan result;
26351 PyObject * obj0 = 0 ;
26352 PyObject * obj1 = 0 ;
26353 char *kwnames[] = {
26354 (char *) "self",(char *) "n", NULL
26355 };
26356
26357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26359 if (SWIG_arg_fail(1)) SWIG_fail;
26360 {
26361 arg2 = (int)(SWIG_As_int(obj1));
26362 if (SWIG_arg_fail(2)) SWIG_fail;
26363 }
26364 {
26365 PyThreadState* __tstate = wxPyBeginAllowThreads();
26366 result = wxDateSpan___rmul__(arg1,arg2);
26367
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 {
26372 wxDateSpan * resultptr;
26373 resultptr = new wxDateSpan((wxDateSpan &)(result));
26374 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26375 }
26376 return resultobj;
26377 fail:
26378 return NULL;
26379 }
26380
26381
26382 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26383 PyObject *resultobj;
26384 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26385 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26386 bool result;
26387 PyObject * obj0 = 0 ;
26388 PyObject * obj1 = 0 ;
26389 char *kwnames[] = {
26390 (char *) "self",(char *) "other", NULL
26391 };
26392
26393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26395 if (SWIG_arg_fail(1)) SWIG_fail;
26396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26397 if (SWIG_arg_fail(2)) SWIG_fail;
26398 {
26399 PyThreadState* __tstate = wxPyBeginAllowThreads();
26400 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26401
26402 wxPyEndAllowThreads(__tstate);
26403 if (PyErr_Occurred()) SWIG_fail;
26404 }
26405 {
26406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26407 }
26408 return resultobj;
26409 fail:
26410 return NULL;
26411 }
26412
26413
26414 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26415 PyObject *resultobj;
26416 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26417 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26418 bool result;
26419 PyObject * obj0 = 0 ;
26420 PyObject * obj1 = 0 ;
26421 char *kwnames[] = {
26422 (char *) "self",(char *) "other", NULL
26423 };
26424
26425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26427 if (SWIG_arg_fail(1)) SWIG_fail;
26428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26429 if (SWIG_arg_fail(2)) SWIG_fail;
26430 {
26431 PyThreadState* __tstate = wxPyBeginAllowThreads();
26432 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26433
26434 wxPyEndAllowThreads(__tstate);
26435 if (PyErr_Occurred()) SWIG_fail;
26436 }
26437 {
26438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26439 }
26440 return resultobj;
26441 fail:
26442 return NULL;
26443 }
26444
26445
26446 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26447 PyObject *obj;
26448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26449 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26450 Py_INCREF(obj);
26451 return Py_BuildValue((char *)"");
26452 }
26453 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26454 PyObject *resultobj;
26455 long result;
26456 char *kwnames[] = {
26457 NULL
26458 };
26459
26460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26461 {
26462 PyThreadState* __tstate = wxPyBeginAllowThreads();
26463 result = (long)wxGetLocalTime();
26464
26465 wxPyEndAllowThreads(__tstate);
26466 if (PyErr_Occurred()) SWIG_fail;
26467 }
26468 {
26469 resultobj = SWIG_From_long((long)(result));
26470 }
26471 return resultobj;
26472 fail:
26473 return NULL;
26474 }
26475
26476
26477 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26478 PyObject *resultobj;
26479 long result;
26480 char *kwnames[] = {
26481 NULL
26482 };
26483
26484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 result = (long)wxGetUTCTime();
26488
26489 wxPyEndAllowThreads(__tstate);
26490 if (PyErr_Occurred()) SWIG_fail;
26491 }
26492 {
26493 resultobj = SWIG_From_long((long)(result));
26494 }
26495 return resultobj;
26496 fail:
26497 return NULL;
26498 }
26499
26500
26501 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26502 PyObject *resultobj;
26503 long result;
26504 char *kwnames[] = {
26505 NULL
26506 };
26507
26508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26509 {
26510 PyThreadState* __tstate = wxPyBeginAllowThreads();
26511 result = (long)wxGetCurrentTime();
26512
26513 wxPyEndAllowThreads(__tstate);
26514 if (PyErr_Occurred()) SWIG_fail;
26515 }
26516 {
26517 resultobj = SWIG_From_long((long)(result));
26518 }
26519 return resultobj;
26520 fail:
26521 return NULL;
26522 }
26523
26524
26525 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26526 PyObject *resultobj;
26527 wxLongLong result;
26528 char *kwnames[] = {
26529 NULL
26530 };
26531
26532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 result = wxGetLocalTimeMillis();
26536
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 {
26541 PyObject *hi, *lo, *shifter, *shifted;
26542 hi = PyLong_FromLong( (&result)->GetHi() );
26543 lo = PyLong_FromLong( (&result)->GetLo() );
26544 shifter = PyLong_FromLong(32);
26545 shifted = PyNumber_Lshift(hi, shifter);
26546 resultobj = PyNumber_Or(shifted, lo);
26547 Py_DECREF(hi);
26548 Py_DECREF(lo);
26549 Py_DECREF(shifter);
26550 Py_DECREF(shifted);
26551 }
26552 return resultobj;
26553 fail:
26554 return NULL;
26555 }
26556
26557
26558 static int _wrap_DefaultDateTime_set(PyObject *) {
26559 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26560 return 1;
26561 }
26562
26563
26564 static PyObject *_wrap_DefaultDateTime_get(void) {
26565 PyObject *pyobj;
26566
26567 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26568 return pyobj;
26569 }
26570
26571
26572 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26573 PyObject *resultobj;
26574 wxDataFormatId arg1 ;
26575 wxDataFormat *result;
26576 PyObject * obj0 = 0 ;
26577 char *kwnames[] = {
26578 (char *) "type", NULL
26579 };
26580
26581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26582 {
26583 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26584 if (SWIG_arg_fail(1)) SWIG_fail;
26585 }
26586 {
26587 PyThreadState* __tstate = wxPyBeginAllowThreads();
26588 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26589
26590 wxPyEndAllowThreads(__tstate);
26591 if (PyErr_Occurred()) SWIG_fail;
26592 }
26593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26594 return resultobj;
26595 fail:
26596 return NULL;
26597 }
26598
26599
26600 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26601 PyObject *resultobj;
26602 wxString *arg1 = 0 ;
26603 wxDataFormat *result;
26604 bool temp1 = false ;
26605 PyObject * obj0 = 0 ;
26606 char *kwnames[] = {
26607 (char *) "format", NULL
26608 };
26609
26610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26611 {
26612 arg1 = wxString_in_helper(obj0);
26613 if (arg1 == NULL) SWIG_fail;
26614 temp1 = true;
26615 }
26616 {
26617 PyThreadState* __tstate = wxPyBeginAllowThreads();
26618 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26619
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26624 {
26625 if (temp1)
26626 delete arg1;
26627 }
26628 return resultobj;
26629 fail:
26630 {
26631 if (temp1)
26632 delete arg1;
26633 }
26634 return NULL;
26635 }
26636
26637
26638 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26639 PyObject *resultobj;
26640 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26641 PyObject * obj0 = 0 ;
26642 char *kwnames[] = {
26643 (char *) "self", NULL
26644 };
26645
26646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26648 if (SWIG_arg_fail(1)) SWIG_fail;
26649 {
26650 PyThreadState* __tstate = wxPyBeginAllowThreads();
26651 delete arg1;
26652
26653 wxPyEndAllowThreads(__tstate);
26654 if (PyErr_Occurred()) SWIG_fail;
26655 }
26656 Py_INCREF(Py_None); resultobj = Py_None;
26657 return resultobj;
26658 fail:
26659 return NULL;
26660 }
26661
26662
26663 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26664 PyObject *resultobj;
26665 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26666 wxDataFormatId arg2 ;
26667 bool result;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670
26671 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26673 if (SWIG_arg_fail(1)) SWIG_fail;
26674 {
26675 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26676 if (SWIG_arg_fail(2)) SWIG_fail;
26677 }
26678 {
26679 PyThreadState* __tstate = wxPyBeginAllowThreads();
26680 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26681
26682 wxPyEndAllowThreads(__tstate);
26683 if (PyErr_Occurred()) SWIG_fail;
26684 }
26685 {
26686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26687 }
26688 return resultobj;
26689 fail:
26690 return NULL;
26691 }
26692
26693
26694 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26695 PyObject *resultobj;
26696 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26697 wxDataFormatId arg2 ;
26698 bool result;
26699 PyObject * obj0 = 0 ;
26700 PyObject * obj1 = 0 ;
26701
26702 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26704 if (SWIG_arg_fail(1)) SWIG_fail;
26705 {
26706 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26707 if (SWIG_arg_fail(2)) SWIG_fail;
26708 }
26709 {
26710 PyThreadState* __tstate = wxPyBeginAllowThreads();
26711 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26712
26713 wxPyEndAllowThreads(__tstate);
26714 if (PyErr_Occurred()) SWIG_fail;
26715 }
26716 {
26717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26718 }
26719 return resultobj;
26720 fail:
26721 return NULL;
26722 }
26723
26724
26725 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26726 PyObject *resultobj;
26727 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26728 wxDataFormat *arg2 = 0 ;
26729 bool result;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732
26733 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26735 if (SWIG_arg_fail(1)) SWIG_fail;
26736 {
26737 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26738 if (SWIG_arg_fail(2)) SWIG_fail;
26739 if (arg2 == NULL) {
26740 SWIG_null_ref("wxDataFormat");
26741 }
26742 if (SWIG_arg_fail(2)) SWIG_fail;
26743 }
26744 {
26745 PyThreadState* __tstate = wxPyBeginAllowThreads();
26746 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26747
26748 wxPyEndAllowThreads(__tstate);
26749 if (PyErr_Occurred()) SWIG_fail;
26750 }
26751 {
26752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26753 }
26754 return resultobj;
26755 fail:
26756 return NULL;
26757 }
26758
26759
26760 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26761 int argc;
26762 PyObject *argv[3];
26763 int ii;
26764
26765 argc = PyObject_Length(args);
26766 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26767 argv[ii] = PyTuple_GetItem(args,ii);
26768 }
26769 if (argc == 2) {
26770 int _v;
26771 {
26772 void *ptr;
26773 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26774 _v = 0;
26775 PyErr_Clear();
26776 } else {
26777 _v = 1;
26778 }
26779 }
26780 if (_v) {
26781 {
26782 void *ptr = 0;
26783 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26784 _v = 0;
26785 PyErr_Clear();
26786 } else {
26787 _v = (ptr != 0);
26788 }
26789 }
26790 if (_v) {
26791 return _wrap_DataFormat___eq____SWIG_1(self,args);
26792 }
26793 }
26794 }
26795 if (argc == 2) {
26796 int _v;
26797 {
26798 void *ptr;
26799 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26800 _v = 0;
26801 PyErr_Clear();
26802 } else {
26803 _v = 1;
26804 }
26805 }
26806 if (_v) {
26807 _v = SWIG_Check_int(argv[1]);
26808 if (_v) {
26809 return _wrap_DataFormat___eq____SWIG_0(self,args);
26810 }
26811 }
26812 }
26813
26814 Py_INCREF(Py_NotImplemented);
26815 return Py_NotImplemented;
26816 }
26817
26818
26819 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26820 PyObject *resultobj;
26821 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26822 wxDataFormat *arg2 = 0 ;
26823 bool result;
26824 PyObject * obj0 = 0 ;
26825 PyObject * obj1 = 0 ;
26826
26827 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26829 if (SWIG_arg_fail(1)) SWIG_fail;
26830 {
26831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26832 if (SWIG_arg_fail(2)) SWIG_fail;
26833 if (arg2 == NULL) {
26834 SWIG_null_ref("wxDataFormat");
26835 }
26836 if (SWIG_arg_fail(2)) SWIG_fail;
26837 }
26838 {
26839 PyThreadState* __tstate = wxPyBeginAllowThreads();
26840 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26841
26842 wxPyEndAllowThreads(__tstate);
26843 if (PyErr_Occurred()) SWIG_fail;
26844 }
26845 {
26846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26847 }
26848 return resultobj;
26849 fail:
26850 return NULL;
26851 }
26852
26853
26854 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26855 int argc;
26856 PyObject *argv[3];
26857 int ii;
26858
26859 argc = PyObject_Length(args);
26860 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26861 argv[ii] = PyTuple_GetItem(args,ii);
26862 }
26863 if (argc == 2) {
26864 int _v;
26865 {
26866 void *ptr;
26867 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26868 _v = 0;
26869 PyErr_Clear();
26870 } else {
26871 _v = 1;
26872 }
26873 }
26874 if (_v) {
26875 {
26876 void *ptr = 0;
26877 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26878 _v = 0;
26879 PyErr_Clear();
26880 } else {
26881 _v = (ptr != 0);
26882 }
26883 }
26884 if (_v) {
26885 return _wrap_DataFormat___ne____SWIG_1(self,args);
26886 }
26887 }
26888 }
26889 if (argc == 2) {
26890 int _v;
26891 {
26892 void *ptr;
26893 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26894 _v = 0;
26895 PyErr_Clear();
26896 } else {
26897 _v = 1;
26898 }
26899 }
26900 if (_v) {
26901 _v = SWIG_Check_int(argv[1]);
26902 if (_v) {
26903 return _wrap_DataFormat___ne____SWIG_0(self,args);
26904 }
26905 }
26906 }
26907
26908 Py_INCREF(Py_NotImplemented);
26909 return Py_NotImplemented;
26910 }
26911
26912
26913 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26914 PyObject *resultobj;
26915 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26916 wxDataFormatId arg2 ;
26917 PyObject * obj0 = 0 ;
26918 PyObject * obj1 = 0 ;
26919 char *kwnames[] = {
26920 (char *) "self",(char *) "format", NULL
26921 };
26922
26923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26925 if (SWIG_arg_fail(1)) SWIG_fail;
26926 {
26927 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26928 if (SWIG_arg_fail(2)) SWIG_fail;
26929 }
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 (arg1)->SetType((wxDataFormatId )arg2);
26933
26934 wxPyEndAllowThreads(__tstate);
26935 if (PyErr_Occurred()) SWIG_fail;
26936 }
26937 Py_INCREF(Py_None); resultobj = Py_None;
26938 return resultobj;
26939 fail:
26940 return NULL;
26941 }
26942
26943
26944 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26945 PyObject *resultobj;
26946 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26947 wxDataFormatId result;
26948 PyObject * obj0 = 0 ;
26949 char *kwnames[] = {
26950 (char *) "self", NULL
26951 };
26952
26953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26955 if (SWIG_arg_fail(1)) SWIG_fail;
26956 {
26957 PyThreadState* __tstate = wxPyBeginAllowThreads();
26958 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26959
26960 wxPyEndAllowThreads(__tstate);
26961 if (PyErr_Occurred()) SWIG_fail;
26962 }
26963 resultobj = SWIG_From_int((result));
26964 return resultobj;
26965 fail:
26966 return NULL;
26967 }
26968
26969
26970 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26971 PyObject *resultobj;
26972 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26973 wxString result;
26974 PyObject * obj0 = 0 ;
26975 char *kwnames[] = {
26976 (char *) "self", NULL
26977 };
26978
26979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26981 if (SWIG_arg_fail(1)) SWIG_fail;
26982 {
26983 PyThreadState* __tstate = wxPyBeginAllowThreads();
26984 result = ((wxDataFormat const *)arg1)->GetId();
26985
26986 wxPyEndAllowThreads(__tstate);
26987 if (PyErr_Occurred()) SWIG_fail;
26988 }
26989 {
26990 #if wxUSE_UNICODE
26991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26992 #else
26993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26994 #endif
26995 }
26996 return resultobj;
26997 fail:
26998 return NULL;
26999 }
27000
27001
27002 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27003 PyObject *resultobj;
27004 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27005 wxString *arg2 = 0 ;
27006 bool temp2 = false ;
27007 PyObject * obj0 = 0 ;
27008 PyObject * obj1 = 0 ;
27009 char *kwnames[] = {
27010 (char *) "self",(char *) "format", NULL
27011 };
27012
27013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27015 if (SWIG_arg_fail(1)) SWIG_fail;
27016 {
27017 arg2 = wxString_in_helper(obj1);
27018 if (arg2 == NULL) SWIG_fail;
27019 temp2 = true;
27020 }
27021 {
27022 PyThreadState* __tstate = wxPyBeginAllowThreads();
27023 (arg1)->SetId((wxString const &)*arg2);
27024
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 Py_INCREF(Py_None); resultobj = Py_None;
27029 {
27030 if (temp2)
27031 delete arg2;
27032 }
27033 return resultobj;
27034 fail:
27035 {
27036 if (temp2)
27037 delete arg2;
27038 }
27039 return NULL;
27040 }
27041
27042
27043 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27044 PyObject *obj;
27045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27046 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27047 Py_INCREF(obj);
27048 return Py_BuildValue((char *)"");
27049 }
27050 static int _wrap_FormatInvalid_set(PyObject *) {
27051 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27052 return 1;
27053 }
27054
27055
27056 static PyObject *_wrap_FormatInvalid_get(void) {
27057 PyObject *pyobj;
27058
27059 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27060 return pyobj;
27061 }
27062
27063
27064 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27065 PyObject *resultobj;
27066 wxDataObject *arg1 = (wxDataObject *) 0 ;
27067 PyObject * obj0 = 0 ;
27068 char *kwnames[] = {
27069 (char *) "self", NULL
27070 };
27071
27072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27074 if (SWIG_arg_fail(1)) SWIG_fail;
27075 {
27076 PyThreadState* __tstate = wxPyBeginAllowThreads();
27077 delete arg1;
27078
27079 wxPyEndAllowThreads(__tstate);
27080 if (PyErr_Occurred()) SWIG_fail;
27081 }
27082 Py_INCREF(Py_None); resultobj = Py_None;
27083 return resultobj;
27084 fail:
27085 return NULL;
27086 }
27087
27088
27089 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27090 PyObject *resultobj;
27091 wxDataObject *arg1 = (wxDataObject *) 0 ;
27092 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27093 SwigValueWrapper<wxDataFormat > result;
27094 PyObject * obj0 = 0 ;
27095 PyObject * obj1 = 0 ;
27096 char *kwnames[] = {
27097 (char *) "self",(char *) "dir", NULL
27098 };
27099
27100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27102 if (SWIG_arg_fail(1)) SWIG_fail;
27103 if (obj1) {
27104 {
27105 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27106 if (SWIG_arg_fail(2)) SWIG_fail;
27107 }
27108 }
27109 {
27110 PyThreadState* __tstate = wxPyBeginAllowThreads();
27111 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27112
27113 wxPyEndAllowThreads(__tstate);
27114 if (PyErr_Occurred()) SWIG_fail;
27115 }
27116 {
27117 wxDataFormat * resultptr;
27118 resultptr = new wxDataFormat((wxDataFormat &)(result));
27119 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27120 }
27121 return resultobj;
27122 fail:
27123 return NULL;
27124 }
27125
27126
27127 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27128 PyObject *resultobj;
27129 wxDataObject *arg1 = (wxDataObject *) 0 ;
27130 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27131 size_t result;
27132 PyObject * obj0 = 0 ;
27133 PyObject * obj1 = 0 ;
27134 char *kwnames[] = {
27135 (char *) "self",(char *) "dir", NULL
27136 };
27137
27138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27140 if (SWIG_arg_fail(1)) SWIG_fail;
27141 if (obj1) {
27142 {
27143 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27144 if (SWIG_arg_fail(2)) SWIG_fail;
27145 }
27146 }
27147 {
27148 PyThreadState* __tstate = wxPyBeginAllowThreads();
27149 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27150
27151 wxPyEndAllowThreads(__tstate);
27152 if (PyErr_Occurred()) SWIG_fail;
27153 }
27154 {
27155 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27156 }
27157 return resultobj;
27158 fail:
27159 return NULL;
27160 }
27161
27162
27163 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27164 PyObject *resultobj;
27165 wxDataObject *arg1 = (wxDataObject *) 0 ;
27166 wxDataFormat *arg2 = 0 ;
27167 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27168 bool result;
27169 PyObject * obj0 = 0 ;
27170 PyObject * obj1 = 0 ;
27171 PyObject * obj2 = 0 ;
27172 char *kwnames[] = {
27173 (char *) "self",(char *) "format",(char *) "dir", NULL
27174 };
27175
27176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27178 if (SWIG_arg_fail(1)) SWIG_fail;
27179 {
27180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27181 if (SWIG_arg_fail(2)) SWIG_fail;
27182 if (arg2 == NULL) {
27183 SWIG_null_ref("wxDataFormat");
27184 }
27185 if (SWIG_arg_fail(2)) SWIG_fail;
27186 }
27187 if (obj2) {
27188 {
27189 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27190 if (SWIG_arg_fail(3)) SWIG_fail;
27191 }
27192 }
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27196
27197 wxPyEndAllowThreads(__tstate);
27198 if (PyErr_Occurred()) SWIG_fail;
27199 }
27200 {
27201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27202 }
27203 return resultobj;
27204 fail:
27205 return NULL;
27206 }
27207
27208
27209 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27210 PyObject *resultobj;
27211 wxDataObject *arg1 = (wxDataObject *) 0 ;
27212 wxDataFormat *arg2 = 0 ;
27213 size_t result;
27214 PyObject * obj0 = 0 ;
27215 PyObject * obj1 = 0 ;
27216 char *kwnames[] = {
27217 (char *) "self",(char *) "format", NULL
27218 };
27219
27220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27222 if (SWIG_arg_fail(1)) SWIG_fail;
27223 {
27224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27225 if (SWIG_arg_fail(2)) SWIG_fail;
27226 if (arg2 == NULL) {
27227 SWIG_null_ref("wxDataFormat");
27228 }
27229 if (SWIG_arg_fail(2)) SWIG_fail;
27230 }
27231 {
27232 PyThreadState* __tstate = wxPyBeginAllowThreads();
27233 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27234
27235 wxPyEndAllowThreads(__tstate);
27236 if (PyErr_Occurred()) SWIG_fail;
27237 }
27238 {
27239 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27240 }
27241 return resultobj;
27242 fail:
27243 return NULL;
27244 }
27245
27246
27247 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27248 PyObject *resultobj;
27249 wxDataObject *arg1 = (wxDataObject *) 0 ;
27250 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27251 PyObject *result;
27252 PyObject * obj0 = 0 ;
27253 PyObject * obj1 = 0 ;
27254 char *kwnames[] = {
27255 (char *) "self",(char *) "dir", NULL
27256 };
27257
27258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27260 if (SWIG_arg_fail(1)) SWIG_fail;
27261 if (obj1) {
27262 {
27263 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27264 if (SWIG_arg_fail(2)) SWIG_fail;
27265 }
27266 }
27267 {
27268 PyThreadState* __tstate = wxPyBeginAllowThreads();
27269 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27270
27271 wxPyEndAllowThreads(__tstate);
27272 if (PyErr_Occurred()) SWIG_fail;
27273 }
27274 resultobj = result;
27275 return resultobj;
27276 fail:
27277 return NULL;
27278 }
27279
27280
27281 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27282 PyObject *resultobj;
27283 wxDataObject *arg1 = (wxDataObject *) 0 ;
27284 wxDataFormat *arg2 = 0 ;
27285 PyObject *result;
27286 PyObject * obj0 = 0 ;
27287 PyObject * obj1 = 0 ;
27288 char *kwnames[] = {
27289 (char *) "self",(char *) "format", NULL
27290 };
27291
27292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27294 if (SWIG_arg_fail(1)) SWIG_fail;
27295 {
27296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27297 if (SWIG_arg_fail(2)) SWIG_fail;
27298 if (arg2 == NULL) {
27299 SWIG_null_ref("wxDataFormat");
27300 }
27301 if (SWIG_arg_fail(2)) SWIG_fail;
27302 }
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27306
27307 wxPyEndAllowThreads(__tstate);
27308 if (PyErr_Occurred()) SWIG_fail;
27309 }
27310 resultobj = result;
27311 return resultobj;
27312 fail:
27313 return NULL;
27314 }
27315
27316
27317 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27318 PyObject *resultobj;
27319 wxDataObject *arg1 = (wxDataObject *) 0 ;
27320 wxDataFormat *arg2 = 0 ;
27321 PyObject *arg3 = (PyObject *) 0 ;
27322 bool result;
27323 PyObject * obj0 = 0 ;
27324 PyObject * obj1 = 0 ;
27325 PyObject * obj2 = 0 ;
27326 char *kwnames[] = {
27327 (char *) "self",(char *) "format",(char *) "data", NULL
27328 };
27329
27330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27332 if (SWIG_arg_fail(1)) SWIG_fail;
27333 {
27334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27335 if (SWIG_arg_fail(2)) SWIG_fail;
27336 if (arg2 == NULL) {
27337 SWIG_null_ref("wxDataFormat");
27338 }
27339 if (SWIG_arg_fail(2)) SWIG_fail;
27340 }
27341 arg3 = obj2;
27342 {
27343 PyThreadState* __tstate = wxPyBeginAllowThreads();
27344 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27345
27346 wxPyEndAllowThreads(__tstate);
27347 if (PyErr_Occurred()) SWIG_fail;
27348 }
27349 {
27350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27351 }
27352 return resultobj;
27353 fail:
27354 return NULL;
27355 }
27356
27357
27358 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27359 PyObject *obj;
27360 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27361 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27362 Py_INCREF(obj);
27363 return Py_BuildValue((char *)"");
27364 }
27365 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27366 PyObject *resultobj;
27367 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27368 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27369 wxDataObjectSimple *result;
27370 PyObject * obj0 = 0 ;
27371 char *kwnames[] = {
27372 (char *) "format", NULL
27373 };
27374
27375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27376 if (obj0) {
27377 {
27378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27379 if (SWIG_arg_fail(1)) SWIG_fail;
27380 if (arg1 == NULL) {
27381 SWIG_null_ref("wxDataFormat");
27382 }
27383 if (SWIG_arg_fail(1)) SWIG_fail;
27384 }
27385 }
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27389
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27394 return resultobj;
27395 fail:
27396 return NULL;
27397 }
27398
27399
27400 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27401 PyObject *resultobj;
27402 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27403 wxDataFormat *result;
27404 PyObject * obj0 = 0 ;
27405 char *kwnames[] = {
27406 (char *) "self", NULL
27407 };
27408
27409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27411 if (SWIG_arg_fail(1)) SWIG_fail;
27412 {
27413 PyThreadState* __tstate = wxPyBeginAllowThreads();
27414 {
27415 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27416 result = (wxDataFormat *) &_result_ref;
27417 }
27418
27419 wxPyEndAllowThreads(__tstate);
27420 if (PyErr_Occurred()) SWIG_fail;
27421 }
27422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27423 return resultobj;
27424 fail:
27425 return NULL;
27426 }
27427
27428
27429 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27430 PyObject *resultobj;
27431 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27432 wxDataFormat *arg2 = 0 ;
27433 PyObject * obj0 = 0 ;
27434 PyObject * obj1 = 0 ;
27435 char *kwnames[] = {
27436 (char *) "self",(char *) "format", NULL
27437 };
27438
27439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27441 if (SWIG_arg_fail(1)) SWIG_fail;
27442 {
27443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27444 if (SWIG_arg_fail(2)) SWIG_fail;
27445 if (arg2 == NULL) {
27446 SWIG_null_ref("wxDataFormat");
27447 }
27448 if (SWIG_arg_fail(2)) SWIG_fail;
27449 }
27450 {
27451 PyThreadState* __tstate = wxPyBeginAllowThreads();
27452 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27453
27454 wxPyEndAllowThreads(__tstate);
27455 if (PyErr_Occurred()) SWIG_fail;
27456 }
27457 Py_INCREF(Py_None); resultobj = Py_None;
27458 return resultobj;
27459 fail:
27460 return NULL;
27461 }
27462
27463
27464 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27465 PyObject *resultobj;
27466 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27467 size_t result;
27468 PyObject * obj0 = 0 ;
27469 char *kwnames[] = {
27470 (char *) "self", NULL
27471 };
27472
27473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27475 if (SWIG_arg_fail(1)) SWIG_fail;
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27479
27480 wxPyEndAllowThreads(__tstate);
27481 if (PyErr_Occurred()) SWIG_fail;
27482 }
27483 {
27484 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27485 }
27486 return resultobj;
27487 fail:
27488 return NULL;
27489 }
27490
27491
27492 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27493 PyObject *resultobj;
27494 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27495 PyObject *result;
27496 PyObject * obj0 = 0 ;
27497 char *kwnames[] = {
27498 (char *) "self", NULL
27499 };
27500
27501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27503 if (SWIG_arg_fail(1)) SWIG_fail;
27504 {
27505 PyThreadState* __tstate = wxPyBeginAllowThreads();
27506 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27507
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 resultobj = result;
27512 return resultobj;
27513 fail:
27514 return NULL;
27515 }
27516
27517
27518 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27519 PyObject *resultobj;
27520 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27521 PyObject *arg2 = (PyObject *) 0 ;
27522 bool result;
27523 PyObject * obj0 = 0 ;
27524 PyObject * obj1 = 0 ;
27525 char *kwnames[] = {
27526 (char *) "self",(char *) "data", NULL
27527 };
27528
27529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27531 if (SWIG_arg_fail(1)) SWIG_fail;
27532 arg2 = obj1;
27533 {
27534 PyThreadState* __tstate = wxPyBeginAllowThreads();
27535 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27536
27537 wxPyEndAllowThreads(__tstate);
27538 if (PyErr_Occurred()) SWIG_fail;
27539 }
27540 {
27541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27542 }
27543 return resultobj;
27544 fail:
27545 return NULL;
27546 }
27547
27548
27549 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27550 PyObject *obj;
27551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27552 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27553 Py_INCREF(obj);
27554 return Py_BuildValue((char *)"");
27555 }
27556 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27557 PyObject *resultobj;
27558 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27559 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27560 wxPyDataObjectSimple *result;
27561 PyObject * obj0 = 0 ;
27562 char *kwnames[] = {
27563 (char *) "format", NULL
27564 };
27565
27566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27567 if (obj0) {
27568 {
27569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27570 if (SWIG_arg_fail(1)) SWIG_fail;
27571 if (arg1 == NULL) {
27572 SWIG_null_ref("wxDataFormat");
27573 }
27574 if (SWIG_arg_fail(1)) SWIG_fail;
27575 }
27576 }
27577 {
27578 PyThreadState* __tstate = wxPyBeginAllowThreads();
27579 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27580
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27585 return resultobj;
27586 fail:
27587 return NULL;
27588 }
27589
27590
27591 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27592 PyObject *resultobj;
27593 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27594 PyObject *arg2 = (PyObject *) 0 ;
27595 PyObject *arg3 = (PyObject *) 0 ;
27596 PyObject * obj0 = 0 ;
27597 PyObject * obj1 = 0 ;
27598 PyObject * obj2 = 0 ;
27599 char *kwnames[] = {
27600 (char *) "self",(char *) "self",(char *) "_class", NULL
27601 };
27602
27603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27605 if (SWIG_arg_fail(1)) SWIG_fail;
27606 arg2 = obj1;
27607 arg3 = obj2;
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 (arg1)->_setCallbackInfo(arg2,arg3);
27611
27612 wxPyEndAllowThreads(__tstate);
27613 if (PyErr_Occurred()) SWIG_fail;
27614 }
27615 Py_INCREF(Py_None); resultobj = Py_None;
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27623 PyObject *obj;
27624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27625 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27626 Py_INCREF(obj);
27627 return Py_BuildValue((char *)"");
27628 }
27629 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27630 PyObject *resultobj;
27631 wxDataObjectComposite *result;
27632 char *kwnames[] = {
27633 NULL
27634 };
27635
27636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27637 {
27638 PyThreadState* __tstate = wxPyBeginAllowThreads();
27639 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27640
27641 wxPyEndAllowThreads(__tstate);
27642 if (PyErr_Occurred()) SWIG_fail;
27643 }
27644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj;
27653 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27654 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27655 bool arg3 = (bool) false ;
27656 PyObject * obj0 = 0 ;
27657 PyObject * obj1 = 0 ;
27658 PyObject * obj2 = 0 ;
27659 char *kwnames[] = {
27660 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27661 };
27662
27663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27665 if (SWIG_arg_fail(1)) SWIG_fail;
27666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27667 if (SWIG_arg_fail(2)) SWIG_fail;
27668 if (obj2) {
27669 {
27670 arg3 = (bool)(SWIG_As_bool(obj2));
27671 if (SWIG_arg_fail(3)) SWIG_fail;
27672 }
27673 }
27674 {
27675 PyThreadState* __tstate = wxPyBeginAllowThreads();
27676 (arg1)->Add(arg2,arg3);
27677
27678 wxPyEndAllowThreads(__tstate);
27679 if (PyErr_Occurred()) SWIG_fail;
27680 }
27681 Py_INCREF(Py_None); resultobj = Py_None;
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27689 PyObject *obj;
27690 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27691 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27692 Py_INCREF(obj);
27693 return Py_BuildValue((char *)"");
27694 }
27695 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27696 PyObject *resultobj;
27697 wxString const &arg1_defvalue = wxPyEmptyString ;
27698 wxString *arg1 = (wxString *) &arg1_defvalue ;
27699 wxTextDataObject *result;
27700 bool temp1 = false ;
27701 PyObject * obj0 = 0 ;
27702 char *kwnames[] = {
27703 (char *) "text", NULL
27704 };
27705
27706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27707 if (obj0) {
27708 {
27709 arg1 = wxString_in_helper(obj0);
27710 if (arg1 == NULL) SWIG_fail;
27711 temp1 = true;
27712 }
27713 }
27714 {
27715 PyThreadState* __tstate = wxPyBeginAllowThreads();
27716 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27717
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27722 {
27723 if (temp1)
27724 delete arg1;
27725 }
27726 return resultobj;
27727 fail:
27728 {
27729 if (temp1)
27730 delete arg1;
27731 }
27732 return NULL;
27733 }
27734
27735
27736 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27737 PyObject *resultobj;
27738 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27739 size_t result;
27740 PyObject * obj0 = 0 ;
27741 char *kwnames[] = {
27742 (char *) "self", NULL
27743 };
27744
27745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27747 if (SWIG_arg_fail(1)) SWIG_fail;
27748 {
27749 PyThreadState* __tstate = wxPyBeginAllowThreads();
27750 result = (size_t)(arg1)->GetTextLength();
27751
27752 wxPyEndAllowThreads(__tstate);
27753 if (PyErr_Occurred()) SWIG_fail;
27754 }
27755 {
27756 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27757 }
27758 return resultobj;
27759 fail:
27760 return NULL;
27761 }
27762
27763
27764 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27765 PyObject *resultobj;
27766 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27767 wxString result;
27768 PyObject * obj0 = 0 ;
27769 char *kwnames[] = {
27770 (char *) "self", NULL
27771 };
27772
27773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27775 if (SWIG_arg_fail(1)) SWIG_fail;
27776 {
27777 PyThreadState* __tstate = wxPyBeginAllowThreads();
27778 result = (arg1)->GetText();
27779
27780 wxPyEndAllowThreads(__tstate);
27781 if (PyErr_Occurred()) SWIG_fail;
27782 }
27783 {
27784 #if wxUSE_UNICODE
27785 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27786 #else
27787 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27788 #endif
27789 }
27790 return resultobj;
27791 fail:
27792 return NULL;
27793 }
27794
27795
27796 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27797 PyObject *resultobj;
27798 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27799 wxString *arg2 = 0 ;
27800 bool temp2 = false ;
27801 PyObject * obj0 = 0 ;
27802 PyObject * obj1 = 0 ;
27803 char *kwnames[] = {
27804 (char *) "self",(char *) "text", NULL
27805 };
27806
27807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27809 if (SWIG_arg_fail(1)) SWIG_fail;
27810 {
27811 arg2 = wxString_in_helper(obj1);
27812 if (arg2 == NULL) SWIG_fail;
27813 temp2 = true;
27814 }
27815 {
27816 PyThreadState* __tstate = wxPyBeginAllowThreads();
27817 (arg1)->SetText((wxString const &)*arg2);
27818
27819 wxPyEndAllowThreads(__tstate);
27820 if (PyErr_Occurred()) SWIG_fail;
27821 }
27822 Py_INCREF(Py_None); resultobj = Py_None;
27823 {
27824 if (temp2)
27825 delete arg2;
27826 }
27827 return resultobj;
27828 fail:
27829 {
27830 if (temp2)
27831 delete arg2;
27832 }
27833 return NULL;
27834 }
27835
27836
27837 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27838 PyObject *obj;
27839 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27840 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27841 Py_INCREF(obj);
27842 return Py_BuildValue((char *)"");
27843 }
27844 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27845 PyObject *resultobj;
27846 wxString const &arg1_defvalue = wxPyEmptyString ;
27847 wxString *arg1 = (wxString *) &arg1_defvalue ;
27848 wxPyTextDataObject *result;
27849 bool temp1 = false ;
27850 PyObject * obj0 = 0 ;
27851 char *kwnames[] = {
27852 (char *) "text", NULL
27853 };
27854
27855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27856 if (obj0) {
27857 {
27858 arg1 = wxString_in_helper(obj0);
27859 if (arg1 == NULL) SWIG_fail;
27860 temp1 = true;
27861 }
27862 }
27863 {
27864 PyThreadState* __tstate = wxPyBeginAllowThreads();
27865 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27866
27867 wxPyEndAllowThreads(__tstate);
27868 if (PyErr_Occurred()) SWIG_fail;
27869 }
27870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27871 {
27872 if (temp1)
27873 delete arg1;
27874 }
27875 return resultobj;
27876 fail:
27877 {
27878 if (temp1)
27879 delete arg1;
27880 }
27881 return NULL;
27882 }
27883
27884
27885 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27886 PyObject *resultobj;
27887 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27888 PyObject *arg2 = (PyObject *) 0 ;
27889 PyObject *arg3 = (PyObject *) 0 ;
27890 PyObject * obj0 = 0 ;
27891 PyObject * obj1 = 0 ;
27892 PyObject * obj2 = 0 ;
27893 char *kwnames[] = {
27894 (char *) "self",(char *) "self",(char *) "_class", NULL
27895 };
27896
27897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27899 if (SWIG_arg_fail(1)) SWIG_fail;
27900 arg2 = obj1;
27901 arg3 = obj2;
27902 {
27903 PyThreadState* __tstate = wxPyBeginAllowThreads();
27904 (arg1)->_setCallbackInfo(arg2,arg3);
27905
27906 wxPyEndAllowThreads(__tstate);
27907 if (PyErr_Occurred()) SWIG_fail;
27908 }
27909 Py_INCREF(Py_None); resultobj = Py_None;
27910 return resultobj;
27911 fail:
27912 return NULL;
27913 }
27914
27915
27916 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27917 PyObject *obj;
27918 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27919 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27920 Py_INCREF(obj);
27921 return Py_BuildValue((char *)"");
27922 }
27923 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27924 PyObject *resultobj;
27925 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27926 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27927 wxBitmapDataObject *result;
27928 PyObject * obj0 = 0 ;
27929 char *kwnames[] = {
27930 (char *) "bitmap", NULL
27931 };
27932
27933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27934 if (obj0) {
27935 {
27936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27937 if (SWIG_arg_fail(1)) SWIG_fail;
27938 if (arg1 == NULL) {
27939 SWIG_null_ref("wxBitmap");
27940 }
27941 if (SWIG_arg_fail(1)) SWIG_fail;
27942 }
27943 }
27944 {
27945 PyThreadState* __tstate = wxPyBeginAllowThreads();
27946 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27947
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27959 PyObject *resultobj;
27960 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27961 wxBitmap result;
27962 PyObject * obj0 = 0 ;
27963 char *kwnames[] = {
27964 (char *) "self", NULL
27965 };
27966
27967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27969 if (SWIG_arg_fail(1)) SWIG_fail;
27970 {
27971 PyThreadState* __tstate = wxPyBeginAllowThreads();
27972 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27973
27974 wxPyEndAllowThreads(__tstate);
27975 if (PyErr_Occurred()) SWIG_fail;
27976 }
27977 {
27978 wxBitmap * resultptr;
27979 resultptr = new wxBitmap((wxBitmap &)(result));
27980 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27981 }
27982 return resultobj;
27983 fail:
27984 return NULL;
27985 }
27986
27987
27988 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27989 PyObject *resultobj;
27990 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27991 wxBitmap *arg2 = 0 ;
27992 PyObject * obj0 = 0 ;
27993 PyObject * obj1 = 0 ;
27994 char *kwnames[] = {
27995 (char *) "self",(char *) "bitmap", NULL
27996 };
27997
27998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28000 if (SWIG_arg_fail(1)) SWIG_fail;
28001 {
28002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28003 if (SWIG_arg_fail(2)) SWIG_fail;
28004 if (arg2 == NULL) {
28005 SWIG_null_ref("wxBitmap");
28006 }
28007 if (SWIG_arg_fail(2)) SWIG_fail;
28008 }
28009 {
28010 PyThreadState* __tstate = wxPyBeginAllowThreads();
28011 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28012
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 Py_INCREF(Py_None); resultobj = Py_None;
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28024 PyObject *obj;
28025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28026 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28027 Py_INCREF(obj);
28028 return Py_BuildValue((char *)"");
28029 }
28030 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28031 PyObject *resultobj;
28032 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28033 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28034 wxPyBitmapDataObject *result;
28035 PyObject * obj0 = 0 ;
28036 char *kwnames[] = {
28037 (char *) "bitmap", NULL
28038 };
28039
28040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28041 if (obj0) {
28042 {
28043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28044 if (SWIG_arg_fail(1)) SWIG_fail;
28045 if (arg1 == NULL) {
28046 SWIG_null_ref("wxBitmap");
28047 }
28048 if (SWIG_arg_fail(1)) SWIG_fail;
28049 }
28050 }
28051 {
28052 PyThreadState* __tstate = wxPyBeginAllowThreads();
28053 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28054
28055 wxPyEndAllowThreads(__tstate);
28056 if (PyErr_Occurred()) SWIG_fail;
28057 }
28058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28059 return resultobj;
28060 fail:
28061 return NULL;
28062 }
28063
28064
28065 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28066 PyObject *resultobj;
28067 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28068 PyObject *arg2 = (PyObject *) 0 ;
28069 PyObject *arg3 = (PyObject *) 0 ;
28070 PyObject * obj0 = 0 ;
28071 PyObject * obj1 = 0 ;
28072 PyObject * obj2 = 0 ;
28073 char *kwnames[] = {
28074 (char *) "self",(char *) "self",(char *) "_class", NULL
28075 };
28076
28077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28079 if (SWIG_arg_fail(1)) SWIG_fail;
28080 arg2 = obj1;
28081 arg3 = obj2;
28082 {
28083 PyThreadState* __tstate = wxPyBeginAllowThreads();
28084 (arg1)->_setCallbackInfo(arg2,arg3);
28085
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 Py_INCREF(Py_None); resultobj = Py_None;
28090 return resultobj;
28091 fail:
28092 return NULL;
28093 }
28094
28095
28096 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28097 PyObject *obj;
28098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28099 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28100 Py_INCREF(obj);
28101 return Py_BuildValue((char *)"");
28102 }
28103 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj;
28105 wxFileDataObject *result;
28106 char *kwnames[] = {
28107 NULL
28108 };
28109
28110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28111 {
28112 PyThreadState* __tstate = wxPyBeginAllowThreads();
28113 result = (wxFileDataObject *)new wxFileDataObject();
28114
28115 wxPyEndAllowThreads(__tstate);
28116 if (PyErr_Occurred()) SWIG_fail;
28117 }
28118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28119 return resultobj;
28120 fail:
28121 return NULL;
28122 }
28123
28124
28125 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28126 PyObject *resultobj;
28127 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28128 wxArrayString *result;
28129 PyObject * obj0 = 0 ;
28130 char *kwnames[] = {
28131 (char *) "self", NULL
28132 };
28133
28134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28136 if (SWIG_arg_fail(1)) SWIG_fail;
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 {
28140 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28141 result = (wxArrayString *) &_result_ref;
28142 }
28143
28144 wxPyEndAllowThreads(__tstate);
28145 if (PyErr_Occurred()) SWIG_fail;
28146 }
28147 {
28148 resultobj = wxArrayString2PyList_helper(*result);
28149 }
28150 return resultobj;
28151 fail:
28152 return NULL;
28153 }
28154
28155
28156 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28157 PyObject *resultobj;
28158 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28159 wxString *arg2 = 0 ;
28160 bool temp2 = false ;
28161 PyObject * obj0 = 0 ;
28162 PyObject * obj1 = 0 ;
28163 char *kwnames[] = {
28164 (char *) "self",(char *) "filename", NULL
28165 };
28166
28167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28169 if (SWIG_arg_fail(1)) SWIG_fail;
28170 {
28171 arg2 = wxString_in_helper(obj1);
28172 if (arg2 == NULL) SWIG_fail;
28173 temp2 = true;
28174 }
28175 {
28176 PyThreadState* __tstate = wxPyBeginAllowThreads();
28177 (arg1)->AddFile((wxString const &)*arg2);
28178
28179 wxPyEndAllowThreads(__tstate);
28180 if (PyErr_Occurred()) SWIG_fail;
28181 }
28182 Py_INCREF(Py_None); resultobj = Py_None;
28183 {
28184 if (temp2)
28185 delete arg2;
28186 }
28187 return resultobj;
28188 fail:
28189 {
28190 if (temp2)
28191 delete arg2;
28192 }
28193 return NULL;
28194 }
28195
28196
28197 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28198 PyObject *obj;
28199 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28200 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28201 Py_INCREF(obj);
28202 return Py_BuildValue((char *)"");
28203 }
28204 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28205 PyObject *resultobj;
28206 wxDataFormat *arg1 = 0 ;
28207 wxCustomDataObject *result;
28208 PyObject * obj0 = 0 ;
28209
28210 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28211 {
28212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28213 if (SWIG_arg_fail(1)) SWIG_fail;
28214 if (arg1 == NULL) {
28215 SWIG_null_ref("wxDataFormat");
28216 }
28217 if (SWIG_arg_fail(1)) SWIG_fail;
28218 }
28219 {
28220 PyThreadState* __tstate = wxPyBeginAllowThreads();
28221 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28222
28223 wxPyEndAllowThreads(__tstate);
28224 if (PyErr_Occurred()) SWIG_fail;
28225 }
28226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28227 return resultobj;
28228 fail:
28229 return NULL;
28230 }
28231
28232
28233 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28234 PyObject *resultobj;
28235 wxString *arg1 = 0 ;
28236 wxCustomDataObject *result;
28237 bool temp1 = false ;
28238 PyObject * obj0 = 0 ;
28239
28240 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28241 {
28242 arg1 = wxString_in_helper(obj0);
28243 if (arg1 == NULL) SWIG_fail;
28244 temp1 = true;
28245 }
28246 {
28247 PyThreadState* __tstate = wxPyBeginAllowThreads();
28248 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28249
28250 wxPyEndAllowThreads(__tstate);
28251 if (PyErr_Occurred()) SWIG_fail;
28252 }
28253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28254 {
28255 if (temp1)
28256 delete arg1;
28257 }
28258 return resultobj;
28259 fail:
28260 {
28261 if (temp1)
28262 delete arg1;
28263 }
28264 return NULL;
28265 }
28266
28267
28268 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28269 PyObject *resultobj;
28270 wxCustomDataObject *result;
28271
28272 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 result = (wxCustomDataObject *)new wxCustomDataObject();
28276
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28281 return resultobj;
28282 fail:
28283 return NULL;
28284 }
28285
28286
28287 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28288 int argc;
28289 PyObject *argv[2];
28290 int ii;
28291
28292 argc = PyObject_Length(args);
28293 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28294 argv[ii] = PyTuple_GetItem(args,ii);
28295 }
28296 if (argc == 0) {
28297 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28298 }
28299 if (argc == 1) {
28300 int _v;
28301 {
28302 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28303 }
28304 if (_v) {
28305 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28306 }
28307 }
28308 if (argc == 1) {
28309 int _v;
28310 {
28311 void *ptr = 0;
28312 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28313 _v = 0;
28314 PyErr_Clear();
28315 } else {
28316 _v = (ptr != 0);
28317 }
28318 }
28319 if (_v) {
28320 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28321 }
28322 }
28323
28324 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28325 return NULL;
28326 }
28327
28328
28329 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28330 PyObject *resultobj;
28331 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28332 PyObject *arg2 = (PyObject *) 0 ;
28333 bool result;
28334 PyObject * obj0 = 0 ;
28335 PyObject * obj1 = 0 ;
28336 char *kwnames[] = {
28337 (char *) "self",(char *) "data", NULL
28338 };
28339
28340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28342 if (SWIG_arg_fail(1)) SWIG_fail;
28343 arg2 = obj1;
28344 {
28345 PyThreadState* __tstate = wxPyBeginAllowThreads();
28346 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28347
28348 wxPyEndAllowThreads(__tstate);
28349 if (PyErr_Occurred()) SWIG_fail;
28350 }
28351 {
28352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28353 }
28354 return resultobj;
28355 fail:
28356 return NULL;
28357 }
28358
28359
28360 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28361 PyObject *resultobj;
28362 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28363 size_t result;
28364 PyObject * obj0 = 0 ;
28365 char *kwnames[] = {
28366 (char *) "self", NULL
28367 };
28368
28369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28371 if (SWIG_arg_fail(1)) SWIG_fail;
28372 {
28373 PyThreadState* __tstate = wxPyBeginAllowThreads();
28374 result = (size_t)(arg1)->GetSize();
28375
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 {
28380 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28381 }
28382 return resultobj;
28383 fail:
28384 return NULL;
28385 }
28386
28387
28388 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28389 PyObject *resultobj;
28390 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28391 PyObject *result;
28392 PyObject * obj0 = 0 ;
28393 char *kwnames[] = {
28394 (char *) "self", NULL
28395 };
28396
28397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28399 if (SWIG_arg_fail(1)) SWIG_fail;
28400 {
28401 PyThreadState* __tstate = wxPyBeginAllowThreads();
28402 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28403
28404 wxPyEndAllowThreads(__tstate);
28405 if (PyErr_Occurred()) SWIG_fail;
28406 }
28407 resultobj = result;
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28415 PyObject *obj;
28416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28417 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28418 Py_INCREF(obj);
28419 return Py_BuildValue((char *)"");
28420 }
28421 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28422 PyObject *resultobj;
28423 wxURLDataObject *result;
28424 char *kwnames[] = {
28425 NULL
28426 };
28427
28428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28429 {
28430 PyThreadState* __tstate = wxPyBeginAllowThreads();
28431 result = (wxURLDataObject *)new wxURLDataObject();
28432
28433 wxPyEndAllowThreads(__tstate);
28434 if (PyErr_Occurred()) SWIG_fail;
28435 }
28436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28444 PyObject *resultobj;
28445 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28446 wxString result;
28447 PyObject * obj0 = 0 ;
28448 char *kwnames[] = {
28449 (char *) "self", NULL
28450 };
28451
28452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28454 if (SWIG_arg_fail(1)) SWIG_fail;
28455 {
28456 PyThreadState* __tstate = wxPyBeginAllowThreads();
28457 result = (arg1)->GetURL();
28458
28459 wxPyEndAllowThreads(__tstate);
28460 if (PyErr_Occurred()) SWIG_fail;
28461 }
28462 {
28463 #if wxUSE_UNICODE
28464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28465 #else
28466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28467 #endif
28468 }
28469 return resultobj;
28470 fail:
28471 return NULL;
28472 }
28473
28474
28475 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28476 PyObject *resultobj;
28477 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28478 wxString *arg2 = 0 ;
28479 bool temp2 = false ;
28480 PyObject * obj0 = 0 ;
28481 PyObject * obj1 = 0 ;
28482 char *kwnames[] = {
28483 (char *) "self",(char *) "url", NULL
28484 };
28485
28486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28488 if (SWIG_arg_fail(1)) SWIG_fail;
28489 {
28490 arg2 = wxString_in_helper(obj1);
28491 if (arg2 == NULL) SWIG_fail;
28492 temp2 = true;
28493 }
28494 {
28495 PyThreadState* __tstate = wxPyBeginAllowThreads();
28496 (arg1)->SetURL((wxString const &)*arg2);
28497
28498 wxPyEndAllowThreads(__tstate);
28499 if (PyErr_Occurred()) SWIG_fail;
28500 }
28501 Py_INCREF(Py_None); resultobj = Py_None;
28502 {
28503 if (temp2)
28504 delete arg2;
28505 }
28506 return resultobj;
28507 fail:
28508 {
28509 if (temp2)
28510 delete arg2;
28511 }
28512 return NULL;
28513 }
28514
28515
28516 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28517 PyObject *obj;
28518 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28519 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28520 Py_INCREF(obj);
28521 return Py_BuildValue((char *)"");
28522 }
28523 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28524 PyObject *resultobj;
28525 wxMetafileDataObject *result;
28526 char *kwnames[] = {
28527 NULL
28528 };
28529
28530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28531 {
28532 PyThreadState* __tstate = wxPyBeginAllowThreads();
28533 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28534
28535 wxPyEndAllowThreads(__tstate);
28536 if (PyErr_Occurred()) SWIG_fail;
28537 }
28538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28539 return resultobj;
28540 fail:
28541 return NULL;
28542 }
28543
28544
28545 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28546 PyObject *resultobj;
28547 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28548 wxMetafile *arg2 = 0 ;
28549 PyObject * obj0 = 0 ;
28550 PyObject * obj1 = 0 ;
28551 char *kwnames[] = {
28552 (char *) "self",(char *) "metafile", NULL
28553 };
28554
28555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28557 if (SWIG_arg_fail(1)) SWIG_fail;
28558 {
28559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28560 if (SWIG_arg_fail(2)) SWIG_fail;
28561 if (arg2 == NULL) {
28562 SWIG_null_ref("wxMetafile");
28563 }
28564 if (SWIG_arg_fail(2)) SWIG_fail;
28565 }
28566 {
28567 PyThreadState* __tstate = wxPyBeginAllowThreads();
28568 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28569
28570 wxPyEndAllowThreads(__tstate);
28571 if (PyErr_Occurred()) SWIG_fail;
28572 }
28573 Py_INCREF(Py_None); resultobj = Py_None;
28574 return resultobj;
28575 fail:
28576 return NULL;
28577 }
28578
28579
28580 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28581 PyObject *resultobj;
28582 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28583 wxMetafile result;
28584 PyObject * obj0 = 0 ;
28585 char *kwnames[] = {
28586 (char *) "self", NULL
28587 };
28588
28589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28591 if (SWIG_arg_fail(1)) SWIG_fail;
28592 {
28593 PyThreadState* __tstate = wxPyBeginAllowThreads();
28594 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28595
28596 wxPyEndAllowThreads(__tstate);
28597 if (PyErr_Occurred()) SWIG_fail;
28598 }
28599 {
28600 wxMetafile * resultptr;
28601 resultptr = new wxMetafile((wxMetafile &)(result));
28602 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28603 }
28604 return resultobj;
28605 fail:
28606 return NULL;
28607 }
28608
28609
28610 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28611 PyObject *obj;
28612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28613 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28614 Py_INCREF(obj);
28615 return Py_BuildValue((char *)"");
28616 }
28617 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28618 PyObject *resultobj;
28619 wxDragResult arg1 ;
28620 bool result;
28621 PyObject * obj0 = 0 ;
28622 char *kwnames[] = {
28623 (char *) "res", NULL
28624 };
28625
28626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28627 {
28628 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28629 if (SWIG_arg_fail(1)) SWIG_fail;
28630 }
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28634
28635 wxPyEndAllowThreads(__tstate);
28636 if (PyErr_Occurred()) SWIG_fail;
28637 }
28638 {
28639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28640 }
28641 return resultobj;
28642 fail:
28643 return NULL;
28644 }
28645
28646
28647 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28648 PyObject *resultobj;
28649 wxWindow *arg1 = (wxWindow *) 0 ;
28650 wxCursor const &arg2_defvalue = wxNullCursor ;
28651 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28652 wxCursor const &arg3_defvalue = wxNullCursor ;
28653 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28654 wxCursor const &arg4_defvalue = wxNullCursor ;
28655 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28656 wxPyDropSource *result;
28657 PyObject * obj0 = 0 ;
28658 PyObject * obj1 = 0 ;
28659 PyObject * obj2 = 0 ;
28660 PyObject * obj3 = 0 ;
28661 char *kwnames[] = {
28662 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28663 };
28664
28665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28667 if (SWIG_arg_fail(1)) SWIG_fail;
28668 if (obj1) {
28669 {
28670 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28671 if (SWIG_arg_fail(2)) SWIG_fail;
28672 if (arg2 == NULL) {
28673 SWIG_null_ref("wxCursor");
28674 }
28675 if (SWIG_arg_fail(2)) SWIG_fail;
28676 }
28677 }
28678 if (obj2) {
28679 {
28680 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28681 if (SWIG_arg_fail(3)) SWIG_fail;
28682 if (arg3 == NULL) {
28683 SWIG_null_ref("wxCursor");
28684 }
28685 if (SWIG_arg_fail(3)) SWIG_fail;
28686 }
28687 }
28688 if (obj3) {
28689 {
28690 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28691 if (SWIG_arg_fail(4)) SWIG_fail;
28692 if (arg4 == NULL) {
28693 SWIG_null_ref("wxCursor");
28694 }
28695 if (SWIG_arg_fail(4)) SWIG_fail;
28696 }
28697 }
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28701
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28713 PyObject *resultobj;
28714 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28715 PyObject *arg2 = (PyObject *) 0 ;
28716 PyObject *arg3 = (PyObject *) 0 ;
28717 int arg4 ;
28718 PyObject * obj0 = 0 ;
28719 PyObject * obj1 = 0 ;
28720 PyObject * obj2 = 0 ;
28721 PyObject * obj3 = 0 ;
28722 char *kwnames[] = {
28723 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28724 };
28725
28726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28728 if (SWIG_arg_fail(1)) SWIG_fail;
28729 arg2 = obj1;
28730 arg3 = obj2;
28731 {
28732 arg4 = (int)(SWIG_As_int(obj3));
28733 if (SWIG_arg_fail(4)) SWIG_fail;
28734 }
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28738
28739 wxPyEndAllowThreads(__tstate);
28740 if (PyErr_Occurred()) SWIG_fail;
28741 }
28742 Py_INCREF(Py_None); resultobj = Py_None;
28743 return resultobj;
28744 fail:
28745 return NULL;
28746 }
28747
28748
28749 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28750 PyObject *resultobj;
28751 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28752 PyObject * obj0 = 0 ;
28753 char *kwnames[] = {
28754 (char *) "self", NULL
28755 };
28756
28757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28759 if (SWIG_arg_fail(1)) SWIG_fail;
28760 {
28761 PyThreadState* __tstate = wxPyBeginAllowThreads();
28762 delete arg1;
28763
28764 wxPyEndAllowThreads(__tstate);
28765 if (PyErr_Occurred()) SWIG_fail;
28766 }
28767 Py_INCREF(Py_None); resultobj = Py_None;
28768 return resultobj;
28769 fail:
28770 return NULL;
28771 }
28772
28773
28774 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28775 PyObject *resultobj;
28776 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28777 wxDataObject *arg2 = 0 ;
28778 PyObject * obj0 = 0 ;
28779 PyObject * obj1 = 0 ;
28780 char *kwnames[] = {
28781 (char *) "self",(char *) "data", NULL
28782 };
28783
28784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28786 if (SWIG_arg_fail(1)) SWIG_fail;
28787 {
28788 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28789 if (SWIG_arg_fail(2)) SWIG_fail;
28790 if (arg2 == NULL) {
28791 SWIG_null_ref("wxDataObject");
28792 }
28793 if (SWIG_arg_fail(2)) SWIG_fail;
28794 }
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 (arg1)->SetData(*arg2);
28798
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 Py_INCREF(Py_None); resultobj = Py_None;
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28810 PyObject *resultobj;
28811 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28812 wxDataObject *result;
28813 PyObject * obj0 = 0 ;
28814 char *kwnames[] = {
28815 (char *) "self", NULL
28816 };
28817
28818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28820 if (SWIG_arg_fail(1)) SWIG_fail;
28821 {
28822 PyThreadState* __tstate = wxPyBeginAllowThreads();
28823 result = (wxDataObject *)(arg1)->GetDataObject();
28824
28825 wxPyEndAllowThreads(__tstate);
28826 if (PyErr_Occurred()) SWIG_fail;
28827 }
28828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28829 return resultobj;
28830 fail:
28831 return NULL;
28832 }
28833
28834
28835 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28836 PyObject *resultobj;
28837 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28838 wxDragResult arg2 ;
28839 wxCursor *arg3 = 0 ;
28840 PyObject * obj0 = 0 ;
28841 PyObject * obj1 = 0 ;
28842 PyObject * obj2 = 0 ;
28843 char *kwnames[] = {
28844 (char *) "self",(char *) "res",(char *) "cursor", NULL
28845 };
28846
28847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28849 if (SWIG_arg_fail(1)) SWIG_fail;
28850 {
28851 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28852 if (SWIG_arg_fail(2)) SWIG_fail;
28853 }
28854 {
28855 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28856 if (SWIG_arg_fail(3)) SWIG_fail;
28857 if (arg3 == NULL) {
28858 SWIG_null_ref("wxCursor");
28859 }
28860 if (SWIG_arg_fail(3)) SWIG_fail;
28861 }
28862 {
28863 PyThreadState* __tstate = wxPyBeginAllowThreads();
28864 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28865
28866 wxPyEndAllowThreads(__tstate);
28867 if (PyErr_Occurred()) SWIG_fail;
28868 }
28869 Py_INCREF(Py_None); resultobj = Py_None;
28870 return resultobj;
28871 fail:
28872 return NULL;
28873 }
28874
28875
28876 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28877 PyObject *resultobj;
28878 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28879 int arg2 = (int) wxDrag_CopyOnly ;
28880 wxDragResult result;
28881 PyObject * obj0 = 0 ;
28882 PyObject * obj1 = 0 ;
28883 char *kwnames[] = {
28884 (char *) "self",(char *) "flags", NULL
28885 };
28886
28887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28889 if (SWIG_arg_fail(1)) SWIG_fail;
28890 if (obj1) {
28891 {
28892 arg2 = (int)(SWIG_As_int(obj1));
28893 if (SWIG_arg_fail(2)) SWIG_fail;
28894 }
28895 }
28896 {
28897 PyThreadState* __tstate = wxPyBeginAllowThreads();
28898 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28899
28900 wxPyEndAllowThreads(__tstate);
28901 if (PyErr_Occurred()) SWIG_fail;
28902 }
28903 resultobj = SWIG_From_int((result));
28904 return resultobj;
28905 fail:
28906 return NULL;
28907 }
28908
28909
28910 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28911 PyObject *resultobj;
28912 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28913 wxDragResult arg2 ;
28914 bool result;
28915 PyObject * obj0 = 0 ;
28916 PyObject * obj1 = 0 ;
28917 char *kwnames[] = {
28918 (char *) "self",(char *) "effect", NULL
28919 };
28920
28921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28923 if (SWIG_arg_fail(1)) SWIG_fail;
28924 {
28925 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28926 if (SWIG_arg_fail(2)) SWIG_fail;
28927 }
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28931
28932 wxPyEndAllowThreads(__tstate);
28933 if (PyErr_Occurred()) SWIG_fail;
28934 }
28935 {
28936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28937 }
28938 return resultobj;
28939 fail:
28940 return NULL;
28941 }
28942
28943
28944 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28945 PyObject *obj;
28946 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28947 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28948 Py_INCREF(obj);
28949 return Py_BuildValue((char *)"");
28950 }
28951 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28952 PyObject *resultobj;
28953 wxDataObject *arg1 = (wxDataObject *) NULL ;
28954 wxPyDropTarget *result;
28955 PyObject * obj0 = 0 ;
28956 char *kwnames[] = {
28957 (char *) "dataObject", NULL
28958 };
28959
28960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28961 if (obj0) {
28962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28963 if (SWIG_arg_fail(1)) SWIG_fail;
28964 }
28965 {
28966 PyThreadState* __tstate = wxPyBeginAllowThreads();
28967 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28968
28969 wxPyEndAllowThreads(__tstate);
28970 if (PyErr_Occurred()) SWIG_fail;
28971 }
28972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28973 return resultobj;
28974 fail:
28975 return NULL;
28976 }
28977
28978
28979 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28980 PyObject *resultobj;
28981 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28982 PyObject *arg2 = (PyObject *) 0 ;
28983 PyObject *arg3 = (PyObject *) 0 ;
28984 PyObject * obj0 = 0 ;
28985 PyObject * obj1 = 0 ;
28986 PyObject * obj2 = 0 ;
28987 char *kwnames[] = {
28988 (char *) "self",(char *) "self",(char *) "_class", NULL
28989 };
28990
28991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28993 if (SWIG_arg_fail(1)) SWIG_fail;
28994 arg2 = obj1;
28995 arg3 = obj2;
28996 {
28997 PyThreadState* __tstate = wxPyBeginAllowThreads();
28998 (arg1)->_setCallbackInfo(arg2,arg3);
28999
29000 wxPyEndAllowThreads(__tstate);
29001 if (PyErr_Occurred()) SWIG_fail;
29002 }
29003 Py_INCREF(Py_None); resultobj = Py_None;
29004 return resultobj;
29005 fail:
29006 return NULL;
29007 }
29008
29009
29010 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29011 PyObject *resultobj;
29012 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29013 PyObject * obj0 = 0 ;
29014 char *kwnames[] = {
29015 (char *) "self", NULL
29016 };
29017
29018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
29019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29020 if (SWIG_arg_fail(1)) SWIG_fail;
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 delete arg1;
29024
29025 wxPyEndAllowThreads(__tstate);
29026 if (PyErr_Occurred()) SWIG_fail;
29027 }
29028 Py_INCREF(Py_None); resultobj = Py_None;
29029 return resultobj;
29030 fail:
29031 return NULL;
29032 }
29033
29034
29035 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29036 PyObject *resultobj;
29037 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29038 wxDataObject *result;
29039 PyObject * obj0 = 0 ;
29040 char *kwnames[] = {
29041 (char *) "self", NULL
29042 };
29043
29044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29046 if (SWIG_arg_fail(1)) SWIG_fail;
29047 {
29048 PyThreadState* __tstate = wxPyBeginAllowThreads();
29049 result = (wxDataObject *)(arg1)->GetDataObject();
29050
29051 wxPyEndAllowThreads(__tstate);
29052 if (PyErr_Occurred()) SWIG_fail;
29053 }
29054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29055 return resultobj;
29056 fail:
29057 return NULL;
29058 }
29059
29060
29061 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29062 PyObject *resultobj;
29063 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29064 wxDataObject *arg2 = (wxDataObject *) 0 ;
29065 PyObject * obj0 = 0 ;
29066 PyObject * obj1 = 0 ;
29067 char *kwnames[] = {
29068 (char *) "self",(char *) "dataObject", NULL
29069 };
29070
29071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29073 if (SWIG_arg_fail(1)) SWIG_fail;
29074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29075 if (SWIG_arg_fail(2)) SWIG_fail;
29076 {
29077 PyThreadState* __tstate = wxPyBeginAllowThreads();
29078 (arg1)->SetDataObject(arg2);
29079
29080 wxPyEndAllowThreads(__tstate);
29081 if (PyErr_Occurred()) SWIG_fail;
29082 }
29083 Py_INCREF(Py_None); resultobj = Py_None;
29084 return resultobj;
29085 fail:
29086 return NULL;
29087 }
29088
29089
29090 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29091 PyObject *resultobj;
29092 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29093 int arg2 ;
29094 int arg3 ;
29095 wxDragResult arg4 ;
29096 wxDragResult result;
29097 PyObject * obj0 = 0 ;
29098 PyObject * obj1 = 0 ;
29099 PyObject * obj2 = 0 ;
29100 PyObject * obj3 = 0 ;
29101 char *kwnames[] = {
29102 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29103 };
29104
29105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29107 if (SWIG_arg_fail(1)) SWIG_fail;
29108 {
29109 arg2 = (int)(SWIG_As_int(obj1));
29110 if (SWIG_arg_fail(2)) SWIG_fail;
29111 }
29112 {
29113 arg3 = (int)(SWIG_As_int(obj2));
29114 if (SWIG_arg_fail(3)) SWIG_fail;
29115 }
29116 {
29117 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29118 if (SWIG_arg_fail(4)) SWIG_fail;
29119 }
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29123
29124 wxPyEndAllowThreads(__tstate);
29125 if (PyErr_Occurred()) SWIG_fail;
29126 }
29127 resultobj = SWIG_From_int((result));
29128 return resultobj;
29129 fail:
29130 return NULL;
29131 }
29132
29133
29134 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29135 PyObject *resultobj;
29136 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29137 int arg2 ;
29138 int arg3 ;
29139 wxDragResult arg4 ;
29140 wxDragResult result;
29141 PyObject * obj0 = 0 ;
29142 PyObject * obj1 = 0 ;
29143 PyObject * obj2 = 0 ;
29144 PyObject * obj3 = 0 ;
29145 char *kwnames[] = {
29146 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29147 };
29148
29149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29151 if (SWIG_arg_fail(1)) SWIG_fail;
29152 {
29153 arg2 = (int)(SWIG_As_int(obj1));
29154 if (SWIG_arg_fail(2)) SWIG_fail;
29155 }
29156 {
29157 arg3 = (int)(SWIG_As_int(obj2));
29158 if (SWIG_arg_fail(3)) SWIG_fail;
29159 }
29160 {
29161 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29162 if (SWIG_arg_fail(4)) SWIG_fail;
29163 }
29164 {
29165 PyThreadState* __tstate = wxPyBeginAllowThreads();
29166 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29167
29168 wxPyEndAllowThreads(__tstate);
29169 if (PyErr_Occurred()) SWIG_fail;
29170 }
29171 resultobj = SWIG_From_int((result));
29172 return resultobj;
29173 fail:
29174 return NULL;
29175 }
29176
29177
29178 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29179 PyObject *resultobj;
29180 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29181 PyObject * obj0 = 0 ;
29182 char *kwnames[] = {
29183 (char *) "self", NULL
29184 };
29185
29186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29188 if (SWIG_arg_fail(1)) SWIG_fail;
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 (arg1)->base_OnLeave();
29192
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 Py_INCREF(Py_None); resultobj = Py_None;
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29204 PyObject *resultobj;
29205 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29206 int arg2 ;
29207 int arg3 ;
29208 bool result;
29209 PyObject * obj0 = 0 ;
29210 PyObject * obj1 = 0 ;
29211 PyObject * obj2 = 0 ;
29212 char *kwnames[] = {
29213 (char *) "self",(char *) "x",(char *) "y", NULL
29214 };
29215
29216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29218 if (SWIG_arg_fail(1)) SWIG_fail;
29219 {
29220 arg2 = (int)(SWIG_As_int(obj1));
29221 if (SWIG_arg_fail(2)) SWIG_fail;
29222 }
29223 {
29224 arg3 = (int)(SWIG_As_int(obj2));
29225 if (SWIG_arg_fail(3)) SWIG_fail;
29226 }
29227 {
29228 PyThreadState* __tstate = wxPyBeginAllowThreads();
29229 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29230
29231 wxPyEndAllowThreads(__tstate);
29232 if (PyErr_Occurred()) SWIG_fail;
29233 }
29234 {
29235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29236 }
29237 return resultobj;
29238 fail:
29239 return NULL;
29240 }
29241
29242
29243 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29244 PyObject *resultobj;
29245 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29246 bool result;
29247 PyObject * obj0 = 0 ;
29248 char *kwnames[] = {
29249 (char *) "self", NULL
29250 };
29251
29252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29254 if (SWIG_arg_fail(1)) SWIG_fail;
29255 {
29256 PyThreadState* __tstate = wxPyBeginAllowThreads();
29257 result = (bool)(arg1)->GetData();
29258
29259 wxPyEndAllowThreads(__tstate);
29260 if (PyErr_Occurred()) SWIG_fail;
29261 }
29262 {
29263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29264 }
29265 return resultobj;
29266 fail:
29267 return NULL;
29268 }
29269
29270
29271 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29272 PyObject *resultobj;
29273 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29274 wxDragResult arg2 ;
29275 PyObject * obj0 = 0 ;
29276 PyObject * obj1 = 0 ;
29277 char *kwnames[] = {
29278 (char *) "self",(char *) "action", NULL
29279 };
29280
29281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29283 if (SWIG_arg_fail(1)) SWIG_fail;
29284 {
29285 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29286 if (SWIG_arg_fail(2)) SWIG_fail;
29287 }
29288 {
29289 PyThreadState* __tstate = wxPyBeginAllowThreads();
29290 (arg1)->SetDefaultAction((wxDragResult )arg2);
29291
29292 wxPyEndAllowThreads(__tstate);
29293 if (PyErr_Occurred()) SWIG_fail;
29294 }
29295 Py_INCREF(Py_None); resultobj = Py_None;
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29303 PyObject *resultobj;
29304 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29305 wxDragResult result;
29306 PyObject * obj0 = 0 ;
29307 char *kwnames[] = {
29308 (char *) "self", NULL
29309 };
29310
29311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29313 if (SWIG_arg_fail(1)) SWIG_fail;
29314 {
29315 PyThreadState* __tstate = wxPyBeginAllowThreads();
29316 result = (wxDragResult)(arg1)->GetDefaultAction();
29317
29318 wxPyEndAllowThreads(__tstate);
29319 if (PyErr_Occurred()) SWIG_fail;
29320 }
29321 resultobj = SWIG_From_int((result));
29322 return resultobj;
29323 fail:
29324 return NULL;
29325 }
29326
29327
29328 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29329 PyObject *obj;
29330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29331 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29332 Py_INCREF(obj);
29333 return Py_BuildValue((char *)"");
29334 }
29335 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29336 PyObject *resultobj;
29337 wxPyTextDropTarget *result;
29338 char *kwnames[] = {
29339 NULL
29340 };
29341
29342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29343 {
29344 PyThreadState* __tstate = wxPyBeginAllowThreads();
29345 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29346
29347 wxPyEndAllowThreads(__tstate);
29348 if (PyErr_Occurred()) SWIG_fail;
29349 }
29350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29351 return resultobj;
29352 fail:
29353 return NULL;
29354 }
29355
29356
29357 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29358 PyObject *resultobj;
29359 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29360 PyObject *arg2 = (PyObject *) 0 ;
29361 PyObject *arg3 = (PyObject *) 0 ;
29362 PyObject * obj0 = 0 ;
29363 PyObject * obj1 = 0 ;
29364 PyObject * obj2 = 0 ;
29365 char *kwnames[] = {
29366 (char *) "self",(char *) "self",(char *) "_class", NULL
29367 };
29368
29369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29371 if (SWIG_arg_fail(1)) SWIG_fail;
29372 arg2 = obj1;
29373 arg3 = obj2;
29374 {
29375 PyThreadState* __tstate = wxPyBeginAllowThreads();
29376 (arg1)->_setCallbackInfo(arg2,arg3);
29377
29378 wxPyEndAllowThreads(__tstate);
29379 if (PyErr_Occurred()) SWIG_fail;
29380 }
29381 Py_INCREF(Py_None); resultobj = Py_None;
29382 return resultobj;
29383 fail:
29384 return NULL;
29385 }
29386
29387
29388 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29389 PyObject *resultobj;
29390 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29391 int arg2 ;
29392 int arg3 ;
29393 wxDragResult arg4 ;
29394 wxDragResult result;
29395 PyObject * obj0 = 0 ;
29396 PyObject * obj1 = 0 ;
29397 PyObject * obj2 = 0 ;
29398 PyObject * obj3 = 0 ;
29399 char *kwnames[] = {
29400 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29401 };
29402
29403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29405 if (SWIG_arg_fail(1)) SWIG_fail;
29406 {
29407 arg2 = (int)(SWIG_As_int(obj1));
29408 if (SWIG_arg_fail(2)) SWIG_fail;
29409 }
29410 {
29411 arg3 = (int)(SWIG_As_int(obj2));
29412 if (SWIG_arg_fail(3)) SWIG_fail;
29413 }
29414 {
29415 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29416 if (SWIG_arg_fail(4)) SWIG_fail;
29417 }
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29421
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 resultobj = SWIG_From_int((result));
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29433 PyObject *resultobj;
29434 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29435 int arg2 ;
29436 int arg3 ;
29437 wxDragResult arg4 ;
29438 wxDragResult result;
29439 PyObject * obj0 = 0 ;
29440 PyObject * obj1 = 0 ;
29441 PyObject * obj2 = 0 ;
29442 PyObject * obj3 = 0 ;
29443 char *kwnames[] = {
29444 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29445 };
29446
29447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29449 if (SWIG_arg_fail(1)) SWIG_fail;
29450 {
29451 arg2 = (int)(SWIG_As_int(obj1));
29452 if (SWIG_arg_fail(2)) SWIG_fail;
29453 }
29454 {
29455 arg3 = (int)(SWIG_As_int(obj2));
29456 if (SWIG_arg_fail(3)) SWIG_fail;
29457 }
29458 {
29459 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29460 if (SWIG_arg_fail(4)) SWIG_fail;
29461 }
29462 {
29463 PyThreadState* __tstate = wxPyBeginAllowThreads();
29464 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29465
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 resultobj = SWIG_From_int((result));
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj;
29478 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29479 PyObject * obj0 = 0 ;
29480 char *kwnames[] = {
29481 (char *) "self", NULL
29482 };
29483
29484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29486 if (SWIG_arg_fail(1)) SWIG_fail;
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 (arg1)->base_OnLeave();
29490
29491 wxPyEndAllowThreads(__tstate);
29492 if (PyErr_Occurred()) SWIG_fail;
29493 }
29494 Py_INCREF(Py_None); resultobj = Py_None;
29495 return resultobj;
29496 fail:
29497 return NULL;
29498 }
29499
29500
29501 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29502 PyObject *resultobj;
29503 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29504 int arg2 ;
29505 int arg3 ;
29506 bool result;
29507 PyObject * obj0 = 0 ;
29508 PyObject * obj1 = 0 ;
29509 PyObject * obj2 = 0 ;
29510 char *kwnames[] = {
29511 (char *) "self",(char *) "x",(char *) "y", NULL
29512 };
29513
29514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29516 if (SWIG_arg_fail(1)) SWIG_fail;
29517 {
29518 arg2 = (int)(SWIG_As_int(obj1));
29519 if (SWIG_arg_fail(2)) SWIG_fail;
29520 }
29521 {
29522 arg3 = (int)(SWIG_As_int(obj2));
29523 if (SWIG_arg_fail(3)) SWIG_fail;
29524 }
29525 {
29526 PyThreadState* __tstate = wxPyBeginAllowThreads();
29527 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29528
29529 wxPyEndAllowThreads(__tstate);
29530 if (PyErr_Occurred()) SWIG_fail;
29531 }
29532 {
29533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29534 }
29535 return resultobj;
29536 fail:
29537 return NULL;
29538 }
29539
29540
29541 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29542 PyObject *resultobj;
29543 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29544 int arg2 ;
29545 int arg3 ;
29546 wxDragResult arg4 ;
29547 wxDragResult result;
29548 PyObject * obj0 = 0 ;
29549 PyObject * obj1 = 0 ;
29550 PyObject * obj2 = 0 ;
29551 PyObject * obj3 = 0 ;
29552 char *kwnames[] = {
29553 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29554 };
29555
29556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29558 if (SWIG_arg_fail(1)) SWIG_fail;
29559 {
29560 arg2 = (int)(SWIG_As_int(obj1));
29561 if (SWIG_arg_fail(2)) SWIG_fail;
29562 }
29563 {
29564 arg3 = (int)(SWIG_As_int(obj2));
29565 if (SWIG_arg_fail(3)) SWIG_fail;
29566 }
29567 {
29568 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29569 if (SWIG_arg_fail(4)) SWIG_fail;
29570 }
29571 {
29572 PyThreadState* __tstate = wxPyBeginAllowThreads();
29573 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29574
29575 wxPyEndAllowThreads(__tstate);
29576 if (PyErr_Occurred()) SWIG_fail;
29577 }
29578 resultobj = SWIG_From_int((result));
29579 return resultobj;
29580 fail:
29581 return NULL;
29582 }
29583
29584
29585 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29586 PyObject *obj;
29587 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29588 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29589 Py_INCREF(obj);
29590 return Py_BuildValue((char *)"");
29591 }
29592 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29593 PyObject *resultobj;
29594 wxPyFileDropTarget *result;
29595 char *kwnames[] = {
29596 NULL
29597 };
29598
29599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29600 {
29601 PyThreadState* __tstate = wxPyBeginAllowThreads();
29602 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29603
29604 wxPyEndAllowThreads(__tstate);
29605 if (PyErr_Occurred()) SWIG_fail;
29606 }
29607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29608 return resultobj;
29609 fail:
29610 return NULL;
29611 }
29612
29613
29614 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29615 PyObject *resultobj;
29616 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29617 PyObject *arg2 = (PyObject *) 0 ;
29618 PyObject *arg3 = (PyObject *) 0 ;
29619 PyObject * obj0 = 0 ;
29620 PyObject * obj1 = 0 ;
29621 PyObject * obj2 = 0 ;
29622 char *kwnames[] = {
29623 (char *) "self",(char *) "self",(char *) "_class", NULL
29624 };
29625
29626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29628 if (SWIG_arg_fail(1)) SWIG_fail;
29629 arg2 = obj1;
29630 arg3 = obj2;
29631 {
29632 PyThreadState* __tstate = wxPyBeginAllowThreads();
29633 (arg1)->_setCallbackInfo(arg2,arg3);
29634
29635 wxPyEndAllowThreads(__tstate);
29636 if (PyErr_Occurred()) SWIG_fail;
29637 }
29638 Py_INCREF(Py_None); resultobj = Py_None;
29639 return resultobj;
29640 fail:
29641 return NULL;
29642 }
29643
29644
29645 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29646 PyObject *resultobj;
29647 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29648 int arg2 ;
29649 int arg3 ;
29650 wxDragResult arg4 ;
29651 wxDragResult result;
29652 PyObject * obj0 = 0 ;
29653 PyObject * obj1 = 0 ;
29654 PyObject * obj2 = 0 ;
29655 PyObject * obj3 = 0 ;
29656 char *kwnames[] = {
29657 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29658 };
29659
29660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29662 if (SWIG_arg_fail(1)) SWIG_fail;
29663 {
29664 arg2 = (int)(SWIG_As_int(obj1));
29665 if (SWIG_arg_fail(2)) SWIG_fail;
29666 }
29667 {
29668 arg3 = (int)(SWIG_As_int(obj2));
29669 if (SWIG_arg_fail(3)) SWIG_fail;
29670 }
29671 {
29672 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29673 if (SWIG_arg_fail(4)) SWIG_fail;
29674 }
29675 {
29676 PyThreadState* __tstate = wxPyBeginAllowThreads();
29677 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29678
29679 wxPyEndAllowThreads(__tstate);
29680 if (PyErr_Occurred()) SWIG_fail;
29681 }
29682 resultobj = SWIG_From_int((result));
29683 return resultobj;
29684 fail:
29685 return NULL;
29686 }
29687
29688
29689 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29690 PyObject *resultobj;
29691 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29692 int arg2 ;
29693 int arg3 ;
29694 wxDragResult arg4 ;
29695 wxDragResult result;
29696 PyObject * obj0 = 0 ;
29697 PyObject * obj1 = 0 ;
29698 PyObject * obj2 = 0 ;
29699 PyObject * obj3 = 0 ;
29700 char *kwnames[] = {
29701 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29702 };
29703
29704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29706 if (SWIG_arg_fail(1)) SWIG_fail;
29707 {
29708 arg2 = (int)(SWIG_As_int(obj1));
29709 if (SWIG_arg_fail(2)) SWIG_fail;
29710 }
29711 {
29712 arg3 = (int)(SWIG_As_int(obj2));
29713 if (SWIG_arg_fail(3)) SWIG_fail;
29714 }
29715 {
29716 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29717 if (SWIG_arg_fail(4)) SWIG_fail;
29718 }
29719 {
29720 PyThreadState* __tstate = wxPyBeginAllowThreads();
29721 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29722
29723 wxPyEndAllowThreads(__tstate);
29724 if (PyErr_Occurred()) SWIG_fail;
29725 }
29726 resultobj = SWIG_From_int((result));
29727 return resultobj;
29728 fail:
29729 return NULL;
29730 }
29731
29732
29733 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29734 PyObject *resultobj;
29735 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29736 PyObject * obj0 = 0 ;
29737 char *kwnames[] = {
29738 (char *) "self", NULL
29739 };
29740
29741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29743 if (SWIG_arg_fail(1)) SWIG_fail;
29744 {
29745 PyThreadState* __tstate = wxPyBeginAllowThreads();
29746 (arg1)->base_OnLeave();
29747
29748 wxPyEndAllowThreads(__tstate);
29749 if (PyErr_Occurred()) SWIG_fail;
29750 }
29751 Py_INCREF(Py_None); resultobj = Py_None;
29752 return resultobj;
29753 fail:
29754 return NULL;
29755 }
29756
29757
29758 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29759 PyObject *resultobj;
29760 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29761 int arg2 ;
29762 int arg3 ;
29763 bool result;
29764 PyObject * obj0 = 0 ;
29765 PyObject * obj1 = 0 ;
29766 PyObject * obj2 = 0 ;
29767 char *kwnames[] = {
29768 (char *) "self",(char *) "x",(char *) "y", NULL
29769 };
29770
29771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29773 if (SWIG_arg_fail(1)) SWIG_fail;
29774 {
29775 arg2 = (int)(SWIG_As_int(obj1));
29776 if (SWIG_arg_fail(2)) SWIG_fail;
29777 }
29778 {
29779 arg3 = (int)(SWIG_As_int(obj2));
29780 if (SWIG_arg_fail(3)) SWIG_fail;
29781 }
29782 {
29783 PyThreadState* __tstate = wxPyBeginAllowThreads();
29784 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29785
29786 wxPyEndAllowThreads(__tstate);
29787 if (PyErr_Occurred()) SWIG_fail;
29788 }
29789 {
29790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29791 }
29792 return resultobj;
29793 fail:
29794 return NULL;
29795 }
29796
29797
29798 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29799 PyObject *resultobj;
29800 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29801 int arg2 ;
29802 int arg3 ;
29803 wxDragResult arg4 ;
29804 wxDragResult result;
29805 PyObject * obj0 = 0 ;
29806 PyObject * obj1 = 0 ;
29807 PyObject * obj2 = 0 ;
29808 PyObject * obj3 = 0 ;
29809 char *kwnames[] = {
29810 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29811 };
29812
29813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29815 if (SWIG_arg_fail(1)) SWIG_fail;
29816 {
29817 arg2 = (int)(SWIG_As_int(obj1));
29818 if (SWIG_arg_fail(2)) SWIG_fail;
29819 }
29820 {
29821 arg3 = (int)(SWIG_As_int(obj2));
29822 if (SWIG_arg_fail(3)) SWIG_fail;
29823 }
29824 {
29825 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29826 if (SWIG_arg_fail(4)) SWIG_fail;
29827 }
29828 {
29829 PyThreadState* __tstate = wxPyBeginAllowThreads();
29830 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29831
29832 wxPyEndAllowThreads(__tstate);
29833 if (PyErr_Occurred()) SWIG_fail;
29834 }
29835 resultobj = SWIG_From_int((result));
29836 return resultobj;
29837 fail:
29838 return NULL;
29839 }
29840
29841
29842 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29843 PyObject *obj;
29844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29845 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29846 Py_INCREF(obj);
29847 return Py_BuildValue((char *)"");
29848 }
29849 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29850 PyObject *resultobj;
29851 wxClipboard *result;
29852 char *kwnames[] = {
29853 NULL
29854 };
29855
29856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29857 {
29858 PyThreadState* __tstate = wxPyBeginAllowThreads();
29859 result = (wxClipboard *)new wxClipboard();
29860
29861 wxPyEndAllowThreads(__tstate);
29862 if (PyErr_Occurred()) SWIG_fail;
29863 }
29864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29865 return resultobj;
29866 fail:
29867 return NULL;
29868 }
29869
29870
29871 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29872 PyObject *resultobj;
29873 wxClipboard *arg1 = (wxClipboard *) 0 ;
29874 PyObject * obj0 = 0 ;
29875 char *kwnames[] = {
29876 (char *) "self", NULL
29877 };
29878
29879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29881 if (SWIG_arg_fail(1)) SWIG_fail;
29882 {
29883 PyThreadState* __tstate = wxPyBeginAllowThreads();
29884 delete arg1;
29885
29886 wxPyEndAllowThreads(__tstate);
29887 if (PyErr_Occurred()) SWIG_fail;
29888 }
29889 Py_INCREF(Py_None); resultobj = Py_None;
29890 return resultobj;
29891 fail:
29892 return NULL;
29893 }
29894
29895
29896 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29897 PyObject *resultobj;
29898 wxClipboard *arg1 = (wxClipboard *) 0 ;
29899 bool result;
29900 PyObject * obj0 = 0 ;
29901 char *kwnames[] = {
29902 (char *) "self", NULL
29903 };
29904
29905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29907 if (SWIG_arg_fail(1)) SWIG_fail;
29908 {
29909 PyThreadState* __tstate = wxPyBeginAllowThreads();
29910 result = (bool)(arg1)->Open();
29911
29912 wxPyEndAllowThreads(__tstate);
29913 if (PyErr_Occurred()) SWIG_fail;
29914 }
29915 {
29916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29917 }
29918 return resultobj;
29919 fail:
29920 return NULL;
29921 }
29922
29923
29924 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29925 PyObject *resultobj;
29926 wxClipboard *arg1 = (wxClipboard *) 0 ;
29927 PyObject * obj0 = 0 ;
29928 char *kwnames[] = {
29929 (char *) "self", NULL
29930 };
29931
29932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29934 if (SWIG_arg_fail(1)) SWIG_fail;
29935 {
29936 PyThreadState* __tstate = wxPyBeginAllowThreads();
29937 (arg1)->Close();
29938
29939 wxPyEndAllowThreads(__tstate);
29940 if (PyErr_Occurred()) SWIG_fail;
29941 }
29942 Py_INCREF(Py_None); resultobj = Py_None;
29943 return resultobj;
29944 fail:
29945 return NULL;
29946 }
29947
29948
29949 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29950 PyObject *resultobj;
29951 wxClipboard *arg1 = (wxClipboard *) 0 ;
29952 bool result;
29953 PyObject * obj0 = 0 ;
29954 char *kwnames[] = {
29955 (char *) "self", NULL
29956 };
29957
29958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29960 if (SWIG_arg_fail(1)) SWIG_fail;
29961 {
29962 PyThreadState* __tstate = wxPyBeginAllowThreads();
29963 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29964
29965 wxPyEndAllowThreads(__tstate);
29966 if (PyErr_Occurred()) SWIG_fail;
29967 }
29968 {
29969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29970 }
29971 return resultobj;
29972 fail:
29973 return NULL;
29974 }
29975
29976
29977 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29978 PyObject *resultobj;
29979 wxClipboard *arg1 = (wxClipboard *) 0 ;
29980 wxDataObject *arg2 = (wxDataObject *) 0 ;
29981 bool result;
29982 PyObject * obj0 = 0 ;
29983 PyObject * obj1 = 0 ;
29984 char *kwnames[] = {
29985 (char *) "self",(char *) "data", NULL
29986 };
29987
29988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29990 if (SWIG_arg_fail(1)) SWIG_fail;
29991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29992 if (SWIG_arg_fail(2)) SWIG_fail;
29993 {
29994 PyThreadState* __tstate = wxPyBeginAllowThreads();
29995 result = (bool)(arg1)->AddData(arg2);
29996
29997 wxPyEndAllowThreads(__tstate);
29998 if (PyErr_Occurred()) SWIG_fail;
29999 }
30000 {
30001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30002 }
30003 return resultobj;
30004 fail:
30005 return NULL;
30006 }
30007
30008
30009 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
30010 PyObject *resultobj;
30011 wxClipboard *arg1 = (wxClipboard *) 0 ;
30012 wxDataObject *arg2 = (wxDataObject *) 0 ;
30013 bool result;
30014 PyObject * obj0 = 0 ;
30015 PyObject * obj1 = 0 ;
30016 char *kwnames[] = {
30017 (char *) "self",(char *) "data", NULL
30018 };
30019
30020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
30021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30022 if (SWIG_arg_fail(1)) SWIG_fail;
30023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30024 if (SWIG_arg_fail(2)) SWIG_fail;
30025 {
30026 PyThreadState* __tstate = wxPyBeginAllowThreads();
30027 result = (bool)(arg1)->SetData(arg2);
30028
30029 wxPyEndAllowThreads(__tstate);
30030 if (PyErr_Occurred()) SWIG_fail;
30031 }
30032 {
30033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30034 }
30035 return resultobj;
30036 fail:
30037 return NULL;
30038 }
30039
30040
30041 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30042 PyObject *resultobj;
30043 wxClipboard *arg1 = (wxClipboard *) 0 ;
30044 wxDataFormat *arg2 = 0 ;
30045 bool result;
30046 PyObject * obj0 = 0 ;
30047 PyObject * obj1 = 0 ;
30048 char *kwnames[] = {
30049 (char *) "self",(char *) "format", NULL
30050 };
30051
30052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30054 if (SWIG_arg_fail(1)) SWIG_fail;
30055 {
30056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30057 if (SWIG_arg_fail(2)) SWIG_fail;
30058 if (arg2 == NULL) {
30059 SWIG_null_ref("wxDataFormat");
30060 }
30061 if (SWIG_arg_fail(2)) SWIG_fail;
30062 }
30063 {
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30066
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 {
30071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30072 }
30073 return resultobj;
30074 fail:
30075 return NULL;
30076 }
30077
30078
30079 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30080 PyObject *resultobj;
30081 wxClipboard *arg1 = (wxClipboard *) 0 ;
30082 wxDataObject *arg2 = 0 ;
30083 bool result;
30084 PyObject * obj0 = 0 ;
30085 PyObject * obj1 = 0 ;
30086 char *kwnames[] = {
30087 (char *) "self",(char *) "data", NULL
30088 };
30089
30090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30092 if (SWIG_arg_fail(1)) SWIG_fail;
30093 {
30094 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30095 if (SWIG_arg_fail(2)) SWIG_fail;
30096 if (arg2 == NULL) {
30097 SWIG_null_ref("wxDataObject");
30098 }
30099 if (SWIG_arg_fail(2)) SWIG_fail;
30100 }
30101 {
30102 PyThreadState* __tstate = wxPyBeginAllowThreads();
30103 result = (bool)(arg1)->GetData(*arg2);
30104
30105 wxPyEndAllowThreads(__tstate);
30106 if (PyErr_Occurred()) SWIG_fail;
30107 }
30108 {
30109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30110 }
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj;
30119 wxClipboard *arg1 = (wxClipboard *) 0 ;
30120 PyObject * obj0 = 0 ;
30121 char *kwnames[] = {
30122 (char *) "self", NULL
30123 };
30124
30125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30127 if (SWIG_arg_fail(1)) SWIG_fail;
30128 {
30129 PyThreadState* __tstate = wxPyBeginAllowThreads();
30130 (arg1)->Clear();
30131
30132 wxPyEndAllowThreads(__tstate);
30133 if (PyErr_Occurred()) SWIG_fail;
30134 }
30135 Py_INCREF(Py_None); resultobj = Py_None;
30136 return resultobj;
30137 fail:
30138 return NULL;
30139 }
30140
30141
30142 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30143 PyObject *resultobj;
30144 wxClipboard *arg1 = (wxClipboard *) 0 ;
30145 bool result;
30146 PyObject * obj0 = 0 ;
30147 char *kwnames[] = {
30148 (char *) "self", NULL
30149 };
30150
30151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30153 if (SWIG_arg_fail(1)) SWIG_fail;
30154 {
30155 PyThreadState* __tstate = wxPyBeginAllowThreads();
30156 result = (bool)(arg1)->Flush();
30157
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 {
30162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30163 }
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30171 PyObject *resultobj;
30172 wxClipboard *arg1 = (wxClipboard *) 0 ;
30173 bool arg2 = (bool) true ;
30174 PyObject * obj0 = 0 ;
30175 PyObject * obj1 = 0 ;
30176 char *kwnames[] = {
30177 (char *) "self",(char *) "primary", NULL
30178 };
30179
30180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30182 if (SWIG_arg_fail(1)) SWIG_fail;
30183 if (obj1) {
30184 {
30185 arg2 = (bool)(SWIG_As_bool(obj1));
30186 if (SWIG_arg_fail(2)) SWIG_fail;
30187 }
30188 }
30189 {
30190 PyThreadState* __tstate = wxPyBeginAllowThreads();
30191 (arg1)->UsePrimarySelection(arg2);
30192
30193 wxPyEndAllowThreads(__tstate);
30194 if (PyErr_Occurred()) SWIG_fail;
30195 }
30196 Py_INCREF(Py_None); resultobj = Py_None;
30197 return resultobj;
30198 fail:
30199 return NULL;
30200 }
30201
30202
30203 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30204 PyObject *resultobj;
30205 wxClipboard *result;
30206 char *kwnames[] = {
30207 NULL
30208 };
30209
30210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30211 {
30212 PyThreadState* __tstate = wxPyBeginAllowThreads();
30213 result = (wxClipboard *)wxClipboard::Get();
30214
30215 wxPyEndAllowThreads(__tstate);
30216 if (PyErr_Occurred()) SWIG_fail;
30217 }
30218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30219 return resultobj;
30220 fail:
30221 return NULL;
30222 }
30223
30224
30225 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30226 PyObject *obj;
30227 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30228 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30229 Py_INCREF(obj);
30230 return Py_BuildValue((char *)"");
30231 }
30232 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30233 PyObject *resultobj;
30234 wxClipboard *arg1 = (wxClipboard *) NULL ;
30235 wxClipboardLocker *result;
30236 PyObject * obj0 = 0 ;
30237 char *kwnames[] = {
30238 (char *) "clipboard", NULL
30239 };
30240
30241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30242 if (obj0) {
30243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30244 if (SWIG_arg_fail(1)) SWIG_fail;
30245 }
30246 {
30247 PyThreadState* __tstate = wxPyBeginAllowThreads();
30248 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30249
30250 wxPyEndAllowThreads(__tstate);
30251 if (PyErr_Occurred()) SWIG_fail;
30252 }
30253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30254 return resultobj;
30255 fail:
30256 return NULL;
30257 }
30258
30259
30260 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30261 PyObject *resultobj;
30262 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30263 PyObject * obj0 = 0 ;
30264 char *kwnames[] = {
30265 (char *) "self", NULL
30266 };
30267
30268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30270 if (SWIG_arg_fail(1)) SWIG_fail;
30271 {
30272 PyThreadState* __tstate = wxPyBeginAllowThreads();
30273 delete arg1;
30274
30275 wxPyEndAllowThreads(__tstate);
30276 if (PyErr_Occurred()) SWIG_fail;
30277 }
30278 Py_INCREF(Py_None); resultobj = Py_None;
30279 return resultobj;
30280 fail:
30281 return NULL;
30282 }
30283
30284
30285 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30286 PyObject *resultobj;
30287 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30288 bool result;
30289 PyObject * obj0 = 0 ;
30290 char *kwnames[] = {
30291 (char *) "self", NULL
30292 };
30293
30294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30296 if (SWIG_arg_fail(1)) SWIG_fail;
30297 {
30298 PyThreadState* __tstate = wxPyBeginAllowThreads();
30299 result = (bool)wxClipboardLocker___nonzero__(arg1);
30300
30301 wxPyEndAllowThreads(__tstate);
30302 if (PyErr_Occurred()) SWIG_fail;
30303 }
30304 {
30305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30306 }
30307 return resultobj;
30308 fail:
30309 return NULL;
30310 }
30311
30312
30313 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30314 PyObject *obj;
30315 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30316 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30317 Py_INCREF(obj);
30318 return Py_BuildValue((char *)"");
30319 }
30320 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30321 PyObject *resultobj;
30322 int arg1 = (int) 0 ;
30323 int arg2 = (int) 0 ;
30324 int arg3 = (int) 0 ;
30325 int arg4 = (int) 0 ;
30326 wxVideoMode *result;
30327 PyObject * obj0 = 0 ;
30328 PyObject * obj1 = 0 ;
30329 PyObject * obj2 = 0 ;
30330 PyObject * obj3 = 0 ;
30331 char *kwnames[] = {
30332 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30333 };
30334
30335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30336 if (obj0) {
30337 {
30338 arg1 = (int)(SWIG_As_int(obj0));
30339 if (SWIG_arg_fail(1)) SWIG_fail;
30340 }
30341 }
30342 if (obj1) {
30343 {
30344 arg2 = (int)(SWIG_As_int(obj1));
30345 if (SWIG_arg_fail(2)) SWIG_fail;
30346 }
30347 }
30348 if (obj2) {
30349 {
30350 arg3 = (int)(SWIG_As_int(obj2));
30351 if (SWIG_arg_fail(3)) SWIG_fail;
30352 }
30353 }
30354 if (obj3) {
30355 {
30356 arg4 = (int)(SWIG_As_int(obj3));
30357 if (SWIG_arg_fail(4)) SWIG_fail;
30358 }
30359 }
30360 {
30361 PyThreadState* __tstate = wxPyBeginAllowThreads();
30362 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30363
30364 wxPyEndAllowThreads(__tstate);
30365 if (PyErr_Occurred()) SWIG_fail;
30366 }
30367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30368 return resultobj;
30369 fail:
30370 return NULL;
30371 }
30372
30373
30374 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30375 PyObject *resultobj;
30376 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30377 PyObject * obj0 = 0 ;
30378 char *kwnames[] = {
30379 (char *) "self", NULL
30380 };
30381
30382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30384 if (SWIG_arg_fail(1)) SWIG_fail;
30385 {
30386 PyThreadState* __tstate = wxPyBeginAllowThreads();
30387 delete arg1;
30388
30389 wxPyEndAllowThreads(__tstate);
30390 if (PyErr_Occurred()) SWIG_fail;
30391 }
30392 Py_INCREF(Py_None); resultobj = Py_None;
30393 return resultobj;
30394 fail:
30395 return NULL;
30396 }
30397
30398
30399 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30400 PyObject *resultobj;
30401 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30402 wxVideoMode *arg2 = 0 ;
30403 bool result;
30404 PyObject * obj0 = 0 ;
30405 PyObject * obj1 = 0 ;
30406 char *kwnames[] = {
30407 (char *) "self",(char *) "other", NULL
30408 };
30409
30410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30412 if (SWIG_arg_fail(1)) SWIG_fail;
30413 {
30414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30415 if (SWIG_arg_fail(2)) SWIG_fail;
30416 if (arg2 == NULL) {
30417 SWIG_null_ref("wxVideoMode");
30418 }
30419 if (SWIG_arg_fail(2)) SWIG_fail;
30420 }
30421 {
30422 PyThreadState* __tstate = wxPyBeginAllowThreads();
30423 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30424
30425 wxPyEndAllowThreads(__tstate);
30426 if (PyErr_Occurred()) SWIG_fail;
30427 }
30428 {
30429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30430 }
30431 return resultobj;
30432 fail:
30433 return NULL;
30434 }
30435
30436
30437 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30438 PyObject *resultobj;
30439 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30440 int result;
30441 PyObject * obj0 = 0 ;
30442 char *kwnames[] = {
30443 (char *) "self", NULL
30444 };
30445
30446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30448 if (SWIG_arg_fail(1)) SWIG_fail;
30449 {
30450 PyThreadState* __tstate = wxPyBeginAllowThreads();
30451 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30452
30453 wxPyEndAllowThreads(__tstate);
30454 if (PyErr_Occurred()) SWIG_fail;
30455 }
30456 {
30457 resultobj = SWIG_From_int((int)(result));
30458 }
30459 return resultobj;
30460 fail:
30461 return NULL;
30462 }
30463
30464
30465 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30466 PyObject *resultobj;
30467 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30468 int result;
30469 PyObject * obj0 = 0 ;
30470 char *kwnames[] = {
30471 (char *) "self", NULL
30472 };
30473
30474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30476 if (SWIG_arg_fail(1)) SWIG_fail;
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30480
30481 wxPyEndAllowThreads(__tstate);
30482 if (PyErr_Occurred()) SWIG_fail;
30483 }
30484 {
30485 resultobj = SWIG_From_int((int)(result));
30486 }
30487 return resultobj;
30488 fail:
30489 return NULL;
30490 }
30491
30492
30493 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30494 PyObject *resultobj;
30495 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30496 int result;
30497 PyObject * obj0 = 0 ;
30498 char *kwnames[] = {
30499 (char *) "self", NULL
30500 };
30501
30502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30504 if (SWIG_arg_fail(1)) SWIG_fail;
30505 {
30506 PyThreadState* __tstate = wxPyBeginAllowThreads();
30507 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30508
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 {
30513 resultobj = SWIG_From_int((int)(result));
30514 }
30515 return resultobj;
30516 fail:
30517 return NULL;
30518 }
30519
30520
30521 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30522 PyObject *resultobj;
30523 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30524 bool result;
30525 PyObject * obj0 = 0 ;
30526 char *kwnames[] = {
30527 (char *) "self", NULL
30528 };
30529
30530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30532 if (SWIG_arg_fail(1)) SWIG_fail;
30533 {
30534 PyThreadState* __tstate = wxPyBeginAllowThreads();
30535 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30536
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 {
30541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30542 }
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30550 PyObject *resultobj;
30551 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30552 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30553 bool result;
30554 PyObject * obj0 = 0 ;
30555 PyObject * obj1 = 0 ;
30556 char *kwnames[] = {
30557 (char *) "self",(char *) "other", NULL
30558 };
30559
30560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30562 if (SWIG_arg_fail(1)) SWIG_fail;
30563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30564 if (SWIG_arg_fail(2)) SWIG_fail;
30565 {
30566 PyThreadState* __tstate = wxPyBeginAllowThreads();
30567 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30568
30569 wxPyEndAllowThreads(__tstate);
30570 if (PyErr_Occurred()) SWIG_fail;
30571 }
30572 {
30573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30574 }
30575 return resultobj;
30576 fail:
30577 return NULL;
30578 }
30579
30580
30581 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30582 PyObject *resultobj;
30583 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30584 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30585 bool result;
30586 PyObject * obj0 = 0 ;
30587 PyObject * obj1 = 0 ;
30588 char *kwnames[] = {
30589 (char *) "self",(char *) "other", NULL
30590 };
30591
30592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30594 if (SWIG_arg_fail(1)) SWIG_fail;
30595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30596 if (SWIG_arg_fail(2)) SWIG_fail;
30597 {
30598 PyThreadState* __tstate = wxPyBeginAllowThreads();
30599 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30600
30601 wxPyEndAllowThreads(__tstate);
30602 if (PyErr_Occurred()) SWIG_fail;
30603 }
30604 {
30605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30606 }
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30614 PyObject *resultobj;
30615 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30616 int arg2 ;
30617 PyObject * obj0 = 0 ;
30618 PyObject * obj1 = 0 ;
30619 char *kwnames[] = {
30620 (char *) "self",(char *) "w", NULL
30621 };
30622
30623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30625 if (SWIG_arg_fail(1)) SWIG_fail;
30626 {
30627 arg2 = (int)(SWIG_As_int(obj1));
30628 if (SWIG_arg_fail(2)) SWIG_fail;
30629 }
30630 if (arg1) (arg1)->w = arg2;
30631
30632 Py_INCREF(Py_None); resultobj = Py_None;
30633 return resultobj;
30634 fail:
30635 return NULL;
30636 }
30637
30638
30639 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30640 PyObject *resultobj;
30641 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30642 int result;
30643 PyObject * obj0 = 0 ;
30644 char *kwnames[] = {
30645 (char *) "self", NULL
30646 };
30647
30648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30650 if (SWIG_arg_fail(1)) SWIG_fail;
30651 result = (int) ((arg1)->w);
30652
30653 {
30654 resultobj = SWIG_From_int((int)(result));
30655 }
30656 return resultobj;
30657 fail:
30658 return NULL;
30659 }
30660
30661
30662 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30663 PyObject *resultobj;
30664 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30665 int arg2 ;
30666 PyObject * obj0 = 0 ;
30667 PyObject * obj1 = 0 ;
30668 char *kwnames[] = {
30669 (char *) "self",(char *) "h", NULL
30670 };
30671
30672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30674 if (SWIG_arg_fail(1)) SWIG_fail;
30675 {
30676 arg2 = (int)(SWIG_As_int(obj1));
30677 if (SWIG_arg_fail(2)) SWIG_fail;
30678 }
30679 if (arg1) (arg1)->h = arg2;
30680
30681 Py_INCREF(Py_None); resultobj = Py_None;
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30689 PyObject *resultobj;
30690 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30691 int result;
30692 PyObject * obj0 = 0 ;
30693 char *kwnames[] = {
30694 (char *) "self", NULL
30695 };
30696
30697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30699 if (SWIG_arg_fail(1)) SWIG_fail;
30700 result = (int) ((arg1)->h);
30701
30702 {
30703 resultobj = SWIG_From_int((int)(result));
30704 }
30705 return resultobj;
30706 fail:
30707 return NULL;
30708 }
30709
30710
30711 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30712 PyObject *resultobj;
30713 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30714 int arg2 ;
30715 PyObject * obj0 = 0 ;
30716 PyObject * obj1 = 0 ;
30717 char *kwnames[] = {
30718 (char *) "self",(char *) "bpp", NULL
30719 };
30720
30721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30723 if (SWIG_arg_fail(1)) SWIG_fail;
30724 {
30725 arg2 = (int)(SWIG_As_int(obj1));
30726 if (SWIG_arg_fail(2)) SWIG_fail;
30727 }
30728 if (arg1) (arg1)->bpp = arg2;
30729
30730 Py_INCREF(Py_None); resultobj = Py_None;
30731 return resultobj;
30732 fail:
30733 return NULL;
30734 }
30735
30736
30737 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30738 PyObject *resultobj;
30739 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30740 int result;
30741 PyObject * obj0 = 0 ;
30742 char *kwnames[] = {
30743 (char *) "self", NULL
30744 };
30745
30746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30748 if (SWIG_arg_fail(1)) SWIG_fail;
30749 result = (int) ((arg1)->bpp);
30750
30751 {
30752 resultobj = SWIG_From_int((int)(result));
30753 }
30754 return resultobj;
30755 fail:
30756 return NULL;
30757 }
30758
30759
30760 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30761 PyObject *resultobj;
30762 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30763 int arg2 ;
30764 PyObject * obj0 = 0 ;
30765 PyObject * obj1 = 0 ;
30766 char *kwnames[] = {
30767 (char *) "self",(char *) "refresh", NULL
30768 };
30769
30770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30772 if (SWIG_arg_fail(1)) SWIG_fail;
30773 {
30774 arg2 = (int)(SWIG_As_int(obj1));
30775 if (SWIG_arg_fail(2)) SWIG_fail;
30776 }
30777 if (arg1) (arg1)->refresh = arg2;
30778
30779 Py_INCREF(Py_None); resultobj = Py_None;
30780 return resultobj;
30781 fail:
30782 return NULL;
30783 }
30784
30785
30786 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30787 PyObject *resultobj;
30788 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30789 int result;
30790 PyObject * obj0 = 0 ;
30791 char *kwnames[] = {
30792 (char *) "self", NULL
30793 };
30794
30795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30797 if (SWIG_arg_fail(1)) SWIG_fail;
30798 result = (int) ((arg1)->refresh);
30799
30800 {
30801 resultobj = SWIG_From_int((int)(result));
30802 }
30803 return resultobj;
30804 fail:
30805 return NULL;
30806 }
30807
30808
30809 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30810 PyObject *obj;
30811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30812 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30813 Py_INCREF(obj);
30814 return Py_BuildValue((char *)"");
30815 }
30816 static int _wrap_DefaultVideoMode_set(PyObject *) {
30817 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30818 return 1;
30819 }
30820
30821
30822 static PyObject *_wrap_DefaultVideoMode_get(void) {
30823 PyObject *pyobj;
30824
30825 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30826 return pyobj;
30827 }
30828
30829
30830 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30831 PyObject *resultobj;
30832 size_t arg1 = (size_t) 0 ;
30833 wxDisplay *result;
30834 PyObject * obj0 = 0 ;
30835 char *kwnames[] = {
30836 (char *) "index", NULL
30837 };
30838
30839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30840 if (obj0) {
30841 {
30842 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30843 if (SWIG_arg_fail(1)) SWIG_fail;
30844 }
30845 }
30846 {
30847 PyThreadState* __tstate = wxPyBeginAllowThreads();
30848 result = (wxDisplay *)new wxDisplay(arg1);
30849
30850 wxPyEndAllowThreads(__tstate);
30851 if (PyErr_Occurred()) SWIG_fail;
30852 }
30853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30854 return resultobj;
30855 fail:
30856 return NULL;
30857 }
30858
30859
30860 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30861 PyObject *resultobj;
30862 wxDisplay *arg1 = (wxDisplay *) 0 ;
30863 PyObject * obj0 = 0 ;
30864 char *kwnames[] = {
30865 (char *) "self", NULL
30866 };
30867
30868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30870 if (SWIG_arg_fail(1)) SWIG_fail;
30871 {
30872 PyThreadState* __tstate = wxPyBeginAllowThreads();
30873 delete arg1;
30874
30875 wxPyEndAllowThreads(__tstate);
30876 if (PyErr_Occurred()) SWIG_fail;
30877 }
30878 Py_INCREF(Py_None); resultobj = Py_None;
30879 return resultobj;
30880 fail:
30881 return NULL;
30882 }
30883
30884
30885 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30886 PyObject *resultobj;
30887 size_t result;
30888 char *kwnames[] = {
30889 NULL
30890 };
30891
30892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30893 {
30894 PyThreadState* __tstate = wxPyBeginAllowThreads();
30895 result = (size_t)wxDisplay::GetCount();
30896
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 {
30901 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30902 }
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30910 PyObject *resultobj;
30911 wxPoint *arg1 = 0 ;
30912 int result;
30913 wxPoint temp1 ;
30914 PyObject * obj0 = 0 ;
30915 char *kwnames[] = {
30916 (char *) "pt", NULL
30917 };
30918
30919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30920 {
30921 arg1 = &temp1;
30922 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30923 }
30924 {
30925 PyThreadState* __tstate = wxPyBeginAllowThreads();
30926 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30927
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 {
30932 resultobj = SWIG_From_int((int)(result));
30933 }
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30941 PyObject *resultobj;
30942 wxWindow *arg1 = (wxWindow *) 0 ;
30943 int result;
30944 PyObject * obj0 = 0 ;
30945 char *kwnames[] = {
30946 (char *) "window", NULL
30947 };
30948
30949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30951 if (SWIG_arg_fail(1)) SWIG_fail;
30952 {
30953 PyThreadState* __tstate = wxPyBeginAllowThreads();
30954 result = (int)wxDisplay::GetFromWindow(arg1);
30955
30956 wxPyEndAllowThreads(__tstate);
30957 if (PyErr_Occurred()) SWIG_fail;
30958 }
30959 {
30960 resultobj = SWIG_From_int((int)(result));
30961 }
30962 return resultobj;
30963 fail:
30964 return NULL;
30965 }
30966
30967
30968 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30969 PyObject *resultobj;
30970 wxDisplay *arg1 = (wxDisplay *) 0 ;
30971 bool result;
30972 PyObject * obj0 = 0 ;
30973 char *kwnames[] = {
30974 (char *) "self", NULL
30975 };
30976
30977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30979 if (SWIG_arg_fail(1)) SWIG_fail;
30980 {
30981 PyThreadState* __tstate = wxPyBeginAllowThreads();
30982 result = (bool)((wxDisplay const *)arg1)->IsOk();
30983
30984 wxPyEndAllowThreads(__tstate);
30985 if (PyErr_Occurred()) SWIG_fail;
30986 }
30987 {
30988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30989 }
30990 return resultobj;
30991 fail:
30992 return NULL;
30993 }
30994
30995
30996 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30997 PyObject *resultobj;
30998 wxDisplay *arg1 = (wxDisplay *) 0 ;
30999 wxRect result;
31000 PyObject * obj0 = 0 ;
31001 char *kwnames[] = {
31002 (char *) "self", NULL
31003 };
31004
31005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
31006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31007 if (SWIG_arg_fail(1)) SWIG_fail;
31008 {
31009 PyThreadState* __tstate = wxPyBeginAllowThreads();
31010 result = ((wxDisplay const *)arg1)->GetGeometry();
31011
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 {
31016 wxRect * resultptr;
31017 resultptr = new wxRect((wxRect &)(result));
31018 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
31019 }
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
31027 PyObject *resultobj;
31028 wxDisplay *arg1 = (wxDisplay *) 0 ;
31029 wxString result;
31030 PyObject * obj0 = 0 ;
31031 char *kwnames[] = {
31032 (char *) "self", NULL
31033 };
31034
31035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31037 if (SWIG_arg_fail(1)) SWIG_fail;
31038 {
31039 PyThreadState* __tstate = wxPyBeginAllowThreads();
31040 result = ((wxDisplay const *)arg1)->GetName();
31041
31042 wxPyEndAllowThreads(__tstate);
31043 if (PyErr_Occurred()) SWIG_fail;
31044 }
31045 {
31046 #if wxUSE_UNICODE
31047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31048 #else
31049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31050 #endif
31051 }
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31059 PyObject *resultobj;
31060 wxDisplay *arg1 = (wxDisplay *) 0 ;
31061 bool result;
31062 PyObject * obj0 = 0 ;
31063 char *kwnames[] = {
31064 (char *) "self", NULL
31065 };
31066
31067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31069 if (SWIG_arg_fail(1)) SWIG_fail;
31070 {
31071 PyThreadState* __tstate = wxPyBeginAllowThreads();
31072 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31073
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 {
31078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31079 }
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj;
31088 wxDisplay *arg1 = (wxDisplay *) 0 ;
31089 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31090 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31091 PyObject *result;
31092 PyObject * obj0 = 0 ;
31093 PyObject * obj1 = 0 ;
31094 char *kwnames[] = {
31095 (char *) "self",(char *) "mode", NULL
31096 };
31097
31098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31100 if (SWIG_arg_fail(1)) SWIG_fail;
31101 if (obj1) {
31102 {
31103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31104 if (SWIG_arg_fail(2)) SWIG_fail;
31105 if (arg2 == NULL) {
31106 SWIG_null_ref("wxVideoMode");
31107 }
31108 if (SWIG_arg_fail(2)) SWIG_fail;
31109 }
31110 }
31111 {
31112 PyThreadState* __tstate = wxPyBeginAllowThreads();
31113 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31114
31115 wxPyEndAllowThreads(__tstate);
31116 if (PyErr_Occurred()) SWIG_fail;
31117 }
31118 resultobj = result;
31119 return resultobj;
31120 fail:
31121 return NULL;
31122 }
31123
31124
31125 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31126 PyObject *resultobj;
31127 wxDisplay *arg1 = (wxDisplay *) 0 ;
31128 wxVideoMode result;
31129 PyObject * obj0 = 0 ;
31130 char *kwnames[] = {
31131 (char *) "self", NULL
31132 };
31133
31134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31136 if (SWIG_arg_fail(1)) SWIG_fail;
31137 {
31138 PyThreadState* __tstate = wxPyBeginAllowThreads();
31139 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31140
31141 wxPyEndAllowThreads(__tstate);
31142 if (PyErr_Occurred()) SWIG_fail;
31143 }
31144 {
31145 wxVideoMode * resultptr;
31146 resultptr = new wxVideoMode((wxVideoMode &)(result));
31147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31148 }
31149 return resultobj;
31150 fail:
31151 return NULL;
31152 }
31153
31154
31155 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31156 PyObject *resultobj;
31157 wxDisplay *arg1 = (wxDisplay *) 0 ;
31158 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31159 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31160 bool result;
31161 PyObject * obj0 = 0 ;
31162 PyObject * obj1 = 0 ;
31163 char *kwnames[] = {
31164 (char *) "self",(char *) "mode", NULL
31165 };
31166
31167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31169 if (SWIG_arg_fail(1)) SWIG_fail;
31170 if (obj1) {
31171 {
31172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31173 if (SWIG_arg_fail(2)) SWIG_fail;
31174 if (arg2 == NULL) {
31175 SWIG_null_ref("wxVideoMode");
31176 }
31177 if (SWIG_arg_fail(2)) SWIG_fail;
31178 }
31179 }
31180 {
31181 PyThreadState* __tstate = wxPyBeginAllowThreads();
31182 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31183
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 {
31188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31189 }
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31197 PyObject *resultobj;
31198 wxDisplay *arg1 = (wxDisplay *) 0 ;
31199 PyObject * obj0 = 0 ;
31200 char *kwnames[] = {
31201 (char *) "self", NULL
31202 };
31203
31204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31206 if (SWIG_arg_fail(1)) SWIG_fail;
31207 {
31208 PyThreadState* __tstate = wxPyBeginAllowThreads();
31209 (arg1)->ResetMode();
31210
31211 wxPyEndAllowThreads(__tstate);
31212 if (PyErr_Occurred()) SWIG_fail;
31213 }
31214 Py_INCREF(Py_None); resultobj = Py_None;
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31222 PyObject *obj;
31223 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31224 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31225 Py_INCREF(obj);
31226 return Py_BuildValue((char *)"");
31227 }
31228 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31229 PyObject *resultobj;
31230 wxStandardPaths *result;
31231 char *kwnames[] = {
31232 NULL
31233 };
31234
31235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 result = (wxStandardPaths *)StandardPaths_Get();
31239
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31244 return resultobj;
31245 fail:
31246 return NULL;
31247 }
31248
31249
31250 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31251 PyObject *resultobj;
31252 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31253 wxString result;
31254 PyObject * obj0 = 0 ;
31255 char *kwnames[] = {
31256 (char *) "self", NULL
31257 };
31258
31259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31261 if (SWIG_arg_fail(1)) SWIG_fail;
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31265
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 {
31270 #if wxUSE_UNICODE
31271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31272 #else
31273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31274 #endif
31275 }
31276 return resultobj;
31277 fail:
31278 return NULL;
31279 }
31280
31281
31282 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31283 PyObject *resultobj;
31284 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31285 wxString result;
31286 PyObject * obj0 = 0 ;
31287 char *kwnames[] = {
31288 (char *) "self", NULL
31289 };
31290
31291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31293 if (SWIG_arg_fail(1)) SWIG_fail;
31294 {
31295 PyThreadState* __tstate = wxPyBeginAllowThreads();
31296 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31297
31298 wxPyEndAllowThreads(__tstate);
31299 if (PyErr_Occurred()) SWIG_fail;
31300 }
31301 {
31302 #if wxUSE_UNICODE
31303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31304 #else
31305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31306 #endif
31307 }
31308 return resultobj;
31309 fail:
31310 return NULL;
31311 }
31312
31313
31314 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31315 PyObject *resultobj;
31316 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31317 wxString result;
31318 PyObject * obj0 = 0 ;
31319 char *kwnames[] = {
31320 (char *) "self", NULL
31321 };
31322
31323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31325 if (SWIG_arg_fail(1)) SWIG_fail;
31326 {
31327 PyThreadState* __tstate = wxPyBeginAllowThreads();
31328 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31329
31330 wxPyEndAllowThreads(__tstate);
31331 if (PyErr_Occurred()) SWIG_fail;
31332 }
31333 {
31334 #if wxUSE_UNICODE
31335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31336 #else
31337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31338 #endif
31339 }
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31347 PyObject *resultobj;
31348 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31349 wxString result;
31350 PyObject * obj0 = 0 ;
31351 char *kwnames[] = {
31352 (char *) "self", NULL
31353 };
31354
31355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31357 if (SWIG_arg_fail(1)) SWIG_fail;
31358 {
31359 PyThreadState* __tstate = wxPyBeginAllowThreads();
31360 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31361
31362 wxPyEndAllowThreads(__tstate);
31363 if (PyErr_Occurred()) SWIG_fail;
31364 }
31365 {
31366 #if wxUSE_UNICODE
31367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31368 #else
31369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31370 #endif
31371 }
31372 return resultobj;
31373 fail:
31374 return NULL;
31375 }
31376
31377
31378 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31379 PyObject *resultobj;
31380 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31381 wxString result;
31382 PyObject * obj0 = 0 ;
31383 char *kwnames[] = {
31384 (char *) "self", NULL
31385 };
31386
31387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31389 if (SWIG_arg_fail(1)) SWIG_fail;
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31393
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 {
31398 #if wxUSE_UNICODE
31399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31400 #else
31401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31402 #endif
31403 }
31404 return resultobj;
31405 fail:
31406 return NULL;
31407 }
31408
31409
31410 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31411 PyObject *resultobj;
31412 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31413 wxString result;
31414 PyObject * obj0 = 0 ;
31415 char *kwnames[] = {
31416 (char *) "self", NULL
31417 };
31418
31419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31421 if (SWIG_arg_fail(1)) SWIG_fail;
31422 {
31423 PyThreadState* __tstate = wxPyBeginAllowThreads();
31424 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31425
31426 wxPyEndAllowThreads(__tstate);
31427 if (PyErr_Occurred()) SWIG_fail;
31428 }
31429 {
31430 #if wxUSE_UNICODE
31431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31432 #else
31433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31434 #endif
31435 }
31436 return resultobj;
31437 fail:
31438 return NULL;
31439 }
31440
31441
31442 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31443 PyObject *resultobj;
31444 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31445 wxString result;
31446 PyObject * obj0 = 0 ;
31447 char *kwnames[] = {
31448 (char *) "self", NULL
31449 };
31450
31451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31453 if (SWIG_arg_fail(1)) SWIG_fail;
31454 {
31455 PyThreadState* __tstate = wxPyBeginAllowThreads();
31456 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31457
31458 wxPyEndAllowThreads(__tstate);
31459 if (PyErr_Occurred()) SWIG_fail;
31460 }
31461 {
31462 #if wxUSE_UNICODE
31463 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31464 #else
31465 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31466 #endif
31467 }
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31475 PyObject *resultobj;
31476 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31477 wxString *arg2 = 0 ;
31478 bool temp2 = false ;
31479 PyObject * obj0 = 0 ;
31480 PyObject * obj1 = 0 ;
31481 char *kwnames[] = {
31482 (char *) "self",(char *) "prefix", NULL
31483 };
31484
31485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31487 if (SWIG_arg_fail(1)) SWIG_fail;
31488 {
31489 arg2 = wxString_in_helper(obj1);
31490 if (arg2 == NULL) SWIG_fail;
31491 temp2 = true;
31492 }
31493 {
31494 PyThreadState* __tstate = wxPyBeginAllowThreads();
31495 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31496
31497 wxPyEndAllowThreads(__tstate);
31498 if (PyErr_Occurred()) SWIG_fail;
31499 }
31500 Py_INCREF(Py_None); resultobj = Py_None;
31501 {
31502 if (temp2)
31503 delete arg2;
31504 }
31505 return resultobj;
31506 fail:
31507 {
31508 if (temp2)
31509 delete arg2;
31510 }
31511 return NULL;
31512 }
31513
31514
31515 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31516 PyObject *resultobj;
31517 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31518 wxString result;
31519 PyObject * obj0 = 0 ;
31520 char *kwnames[] = {
31521 (char *) "self", NULL
31522 };
31523
31524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31526 if (SWIG_arg_fail(1)) SWIG_fail;
31527 {
31528 PyThreadState* __tstate = wxPyBeginAllowThreads();
31529 result = wxStandardPaths_GetInstallPrefix(arg1);
31530
31531 wxPyEndAllowThreads(__tstate);
31532 if (PyErr_Occurred()) SWIG_fail;
31533 }
31534 {
31535 #if wxUSE_UNICODE
31536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31537 #else
31538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31539 #endif
31540 }
31541 return resultobj;
31542 fail:
31543 return NULL;
31544 }
31545
31546
31547 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31548 PyObject *obj;
31549 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31550 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31551 Py_INCREF(obj);
31552 return Py_BuildValue((char *)"");
31553 }
31554 static PyMethodDef SwigMethods[] = {
31555 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31562 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31570 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31636 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31644 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31662 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31665 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31668 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31671 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31677 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31691 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31697 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31703 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31706 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31720 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31723 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31724 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31727 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31754 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31756 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31758 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31760 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31767 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31773 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31787 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31791 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31794 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31811 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31819 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31866 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31884 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31894 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31910 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31926 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31940 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31950 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31993 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31996 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31999 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
32003 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32096 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32097 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32098 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32099 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32116 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32161 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32195 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32203 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32204 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32209 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32218 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32225 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32228 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32231 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32236 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32239 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32243 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32246 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32250 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32251 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32255 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32259 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32263 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32273 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32286 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32294 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32302 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32308 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32316 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32318 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32320 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32329 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32330 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32331 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32332 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32333 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32334 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32335 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32336 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32337 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32338 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32339 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32340 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32341 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32342 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32343 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32344 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32345 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32346 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32347 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32348 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32349 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32350 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32351 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32352 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32353 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32354 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32355 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32356 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32357 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32358 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32359 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32360 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32361 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32362 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32363 { NULL, NULL, 0, NULL }
32364 };
32365
32366
32367 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32368
32369 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32370 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32371 }
32372 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32373 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32374 }
32375 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32376 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32377 }
32378 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32379 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32380 }
32381 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32382 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32383 }
32384 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32385 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32386 }
32387 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32388 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32389 }
32390 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32391 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32392 }
32393 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32394 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32395 }
32396 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32397 return (void *)((wxEvent *) ((wxPyEvent *) x));
32398 }
32399 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32400 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32401 }
32402 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32403 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32404 }
32405 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32406 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32407 }
32408 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32409 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32410 }
32411 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32412 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32413 }
32414 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32415 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32416 }
32417 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32418 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32419 }
32420 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32421 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32422 }
32423 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32424 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32425 }
32426 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32427 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32428 }
32429 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32430 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32431 }
32432 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32433 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32434 }
32435 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32436 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32437 }
32438 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32439 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32440 }
32441 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32442 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32443 }
32444 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32445 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32446 }
32447 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32448 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32449 }
32450 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32451 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32452 }
32453 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32454 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32455 }
32456 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32457 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32458 }
32459 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32460 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32461 }
32462 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32463 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32464 }
32465 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32466 return (void *)((wxEvent *) ((wxShowEvent *) x));
32467 }
32468 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32469 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32470 }
32471 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32472 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32473 }
32474 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32475 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32476 }
32477 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32478 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32479 }
32480 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32481 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32482 }
32483 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32484 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32485 }
32486 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32487 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32488 }
32489 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32490 return (void *)((wxConfigBase *) ((wxConfig *) x));
32491 }
32492 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32493 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32494 }
32495 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32496 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32497 }
32498 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32499 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32500 }
32501 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32502 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32503 }
32504 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32505 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32506 }
32507 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32508 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32509 }
32510 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32511 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32512 }
32513 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32514 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32515 }
32516 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32517 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32518 }
32519 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32520 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32521 }
32522 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32523 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32524 }
32525 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32526 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32527 }
32528 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32529 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32530 }
32531 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32532 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32533 }
32534 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32535 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32536 }
32537 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32538 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32539 }
32540 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32541 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32542 }
32543 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32544 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32545 }
32546 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32547 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32548 }
32549 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32550 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32551 }
32552 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32553 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32554 }
32555 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32556 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32557 }
32558 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32559 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32560 }
32561 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32562 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32563 }
32564 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32565 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32566 }
32567 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32568 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32569 }
32570 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32571 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32572 }
32573 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32574 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32575 }
32576 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32577 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32578 }
32579 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32580 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32581 }
32582 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32583 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32584 }
32585 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32586 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32587 }
32588 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32589 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32590 }
32591 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32592 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32593 }
32594 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32595 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32596 }
32597 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32598 return (void *)((wxObject *) ((wxSizerItem *) x));
32599 }
32600 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32601 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32602 }
32603 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32604 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32605 }
32606 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32607 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32608 }
32609 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32610 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32611 }
32612 static void *_p_wxSizerTo_p_wxObject(void *x) {
32613 return (void *)((wxObject *) ((wxSizer *) x));
32614 }
32615 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32616 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32617 }
32618 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32619 return (void *)((wxObject *) ((wxFileHistory *) x));
32620 }
32621 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32622 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32623 }
32624 static void *_p_wxEventTo_p_wxObject(void *x) {
32625 return (void *)((wxObject *) ((wxEvent *) x));
32626 }
32627 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32628 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32629 }
32630 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32631 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32632 }
32633 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32634 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32635 }
32636 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32637 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32638 }
32639 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32640 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32641 }
32642 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32643 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32644 }
32645 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32646 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32647 }
32648 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32649 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32650 }
32651 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32652 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32653 }
32654 static void *_p_wxControlTo_p_wxObject(void *x) {
32655 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32656 }
32657 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32658 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32659 }
32660 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32661 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32662 }
32663 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32664 return (void *)((wxObject *) ((wxFSFile *) x));
32665 }
32666 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32667 return (void *)((wxObject *) ((wxClipboard *) x));
32668 }
32669 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32670 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32671 }
32672 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32673 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32674 }
32675 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32676 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32677 }
32678 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32679 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32680 }
32681 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32682 return (void *)((wxObject *) ((wxToolTip *) x));
32683 }
32684 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32685 return (void *)((wxObject *) ((wxMenuItem *) x));
32686 }
32687 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32688 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32689 }
32690 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32691 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32692 }
32693 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32694 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32695 }
32696 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32697 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32698 }
32699 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32700 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32701 }
32702 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32703 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32704 }
32705 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32706 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32707 }
32708 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32709 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32710 }
32711 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32712 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32713 }
32714 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32715 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32716 }
32717 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32718 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32719 }
32720 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32721 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32722 }
32723 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32724 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32725 }
32726 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32727 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32728 }
32729 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32730 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32731 }
32732 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32733 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32734 }
32735 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32736 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32737 }
32738 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32739 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32740 }
32741 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32742 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32743 }
32744 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32745 return (void *)((wxObject *) ((wxImageHandler *) x));
32746 }
32747 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32748 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32749 }
32750 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32751 return (void *)((wxObject *) ((wxEvtHandler *) x));
32752 }
32753 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32754 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32755 }
32756 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32757 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32758 }
32759 static void *_p_wxImageTo_p_wxObject(void *x) {
32760 return (void *)((wxObject *) ((wxImage *) x));
32761 }
32762 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32763 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32764 }
32765 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32766 return (void *)((wxObject *) ((wxSystemOptions *) x));
32767 }
32768 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32769 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32770 }
32771 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32772 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32773 }
32774 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32775 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32776 }
32777 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32778 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32779 }
32780 static void *_p_wxWindowTo_p_wxObject(void *x) {
32781 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32782 }
32783 static void *_p_wxMenuTo_p_wxObject(void *x) {
32784 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32785 }
32786 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32787 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32788 }
32789 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32790 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32791 }
32792 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32793 return (void *)((wxObject *) ((wxFileSystem *) x));
32794 }
32795 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32796 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32797 }
32798 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32799 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32800 }
32801 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32802 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32803 }
32804 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32805 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32806 }
32807 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32808 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32809 }
32810 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32811 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32812 }
32813 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32814 return (void *)((wxObject *) ((wxBusyInfo *) x));
32815 }
32816 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32817 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32818 }
32819 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32820 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32821 }
32822 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32823 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32824 }
32825 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32826 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32827 }
32828 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32829 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32830 }
32831 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32832 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32833 }
32834 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32835 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32836 }
32837 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32838 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32839 }
32840 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32841 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32842 }
32843 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32844 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32845 }
32846 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32847 return (void *)((wxLog *) ((wxLogStderr *) x));
32848 }
32849 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32850 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32851 }
32852 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32853 return (void *)((wxLog *) ((wxLogWindow *) x));
32854 }
32855 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32856 return (void *)((wxLog *) ((wxLogChain *) x));
32857 }
32858 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32859 return (void *)((wxLog *) ((wxLogGui *) x));
32860 }
32861 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32862 return (void *)((wxLog *) ((wxPyLog *) x));
32863 }
32864 static void *_p_wxControlTo_p_wxWindow(void *x) {
32865 return (void *)((wxWindow *) ((wxControl *) x));
32866 }
32867 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32868 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32869 }
32870 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32871 return (void *)((wxWindow *) ((wxMenuBar *) x));
32872 }
32873 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32874 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32875 }
32876 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32877 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32878 }
32879 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}};
32880 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}};
32881 static swig_type_info _swigt__p_wxMetafile[] = {{"_p_wxMetafile", 0, "wxMetafile *", 0, 0, 0, 0},{"_p_wxMetafile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32882 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}};
32883 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}};
32884 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}};
32885 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}};
32886 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}};
32887 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}};
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0, 0, 0, 0},{"_p_void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905 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}};
32906 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}};
32907 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}};
32908 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}};
32909 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}};
32910 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}};
32911 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}};
32912 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}};
32913 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}};
32914 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}};
32915 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}};
32916 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}};
32917 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}};
32918 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}};
32919 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}};
32920 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}};
32921 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}};
32922 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}};
32923 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}};
32924 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}};
32925 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}};
32926 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}};
32927 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}};
32928 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}};
32929 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}};
32930 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}};
32931 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}};
32932 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}};
32933 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}};
32934 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}};
32935 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}};
32936 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}};
32937 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}};
32938 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}};
32939 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}};
32940 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}};
32941 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}};
32942 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}};
32943 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}};
32944 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}};
32945 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}};
32946 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}};
32947 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}};
32948 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}};
32949 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}};
32950 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}};
32951 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}};
32952 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}};
32953 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}};
32954 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}};
32955 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}};
32956 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}};
32957 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}};
32958 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}};
32959 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}};
32960 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}};
32961 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}};
32962 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}};
32963 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}};
32964 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}};
32965 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}};
32966 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}};
32967 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}};
32968 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}};
32969 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}};
32970 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}};
32971 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}};
32972 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}};
32973 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}};
32974 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}};
32975 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}};
32976 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}};
32977
32978 static swig_type_info *swig_types_initial[] = {
32979 _swigt__p_wxLogChain,
32980 _swigt__p_wxMutexGuiLocker,
32981 _swigt__p_wxMetafile,
32982 _swigt__p_wxFileHistory,
32983 _swigt__p_wxLog,
32984 _swigt__p_wxMenu,
32985 _swigt__p_wxEvent,
32986 _swigt__p_wxDateTime__TimeZone,
32987 _swigt__p_wxConfigBase,
32988 _swigt__p_wxDisplay,
32989 _swigt__p_wxFileType,
32990 _swigt__p_wxLogGui,
32991 _swigt__p_wxFont,
32992 _swigt__p_wxDataFormat,
32993 _swigt__p_wxTimerEvent,
32994 _swigt__p_wxCaret,
32995 _swigt__ptrdiff_t,
32996 _swigt__std__ptrdiff_t,
32997 _swigt__p_void,
32998 _swigt__p_int,
32999 _swigt__p_wxSize,
33000 _swigt__p_wxClipboard,
33001 _swigt__p_wxStopWatch,
33002 _swigt__p_wxDC,
33003 _swigt__p_wxClipboardLocker,
33004 _swigt__p_wxIcon,
33005 _swigt__p_wxLogStderr,
33006 _swigt__p_wxLogTextCtrl,
33007 _swigt__p_wxTextCtrl,
33008 _swigt__p_wxBusyCursor,
33009 _swigt__p_wxBitmapDataObject,
33010 _swigt__p_wxTextDataObject,
33011 _swigt__p_wxDataObject,
33012 _swigt__p_wxPyTextDataObject,
33013 _swigt__p_wxPyBitmapDataObject,
33014 _swigt__p_wxFileDataObject,
33015 _swigt__p_wxCustomDataObject,
33016 _swigt__p_wxURLDataObject,
33017 _swigt__p_wxMetafileDataObject,
33018 _swigt__p_wxSound,
33019 _swigt__p_wxTimerRunner,
33020 _swigt__p_wxLogWindow,
33021 _swigt__p_wxTimeSpan,
33022 _swigt__p_wxArrayString,
33023 _swigt__p_wxWindowDisabler,
33024 _swigt__p_form_ops_t,
33025 _swigt__p_wxToolTip,
33026 _swigt__p_wxDataObjectComposite,
33027 _swigt__p_wxSystemSettings,
33028 _swigt__p_wxFileConfig,
33029 _swigt__p_wxVideoMode,
33030 _swigt__p_wxDataObjectSimple,
33031 _swigt__p_wxPyDataObjectSimple,
33032 _swigt__p_wxDuplexMode,
33033 _swigt__p_wxEvtHandler,
33034 _swigt__p_wxRect,
33035 _swigt__p_char,
33036 _swigt__p_wxSingleInstanceChecker,
33037 _swigt__p_wxStandardPaths,
33038 _swigt__p_wxFileTypeInfo,
33039 _swigt__p_wxFrame,
33040 _swigt__p_wxTimer,
33041 _swigt__p_wxPaperSize,
33042 _swigt__p_wxMimeTypesManager,
33043 _swigt__p_wxPyArtProvider,
33044 _swigt__p_wxPyTipProvider,
33045 _swigt__p_wxTipProvider,
33046 _swigt__p_wxJoystick,
33047 _swigt__p_wxSystemOptions,
33048 _swigt__p_wxPoint,
33049 _swigt__p_wxJoystickEvent,
33050 _swigt__p_wxCursor,
33051 _swigt__p_wxObject,
33052 _swigt__p_wxOutputStream,
33053 _swigt__p_wxDateTime,
33054 _swigt__p_wxPyDropSource,
33055 _swigt__p_unsigned_long,
33056 _swigt__p_wxKillError,
33057 _swigt__p_wxWindow,
33058 _swigt__p_wxString,
33059 _swigt__p_wxPyProcess,
33060 _swigt__p_wxBitmap,
33061 _swigt__unsigned_int,
33062 _swigt__p_unsigned_int,
33063 _swigt__p_wxConfig,
33064 _swigt__p_unsigned_char,
33065 _swigt__p_wxChar,
33066 _swigt__p_wxBusyInfo,
33067 _swigt__p_wxPyDropTarget,
33068 _swigt__p_wxPyTextDropTarget,
33069 _swigt__p_wxPyFileDropTarget,
33070 _swigt__p_wxProcessEvent,
33071 _swigt__p_wxPyLog,
33072 _swigt__p_wxLogNull,
33073 _swigt__p_wxColour,
33074 _swigt__p_wxPyTimer,
33075 _swigt__p_wxConfigPathChanger,
33076 _swigt__p_wxDateSpan,
33077 0
33078 };
33079
33080
33081 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33082
33083 static swig_const_info swig_const_table[] = {
33084 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33085 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33086 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33087 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33088 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33089 {0, 0, 0, 0.0, 0, 0}};
33090
33091 #ifdef __cplusplus
33092 }
33093 #endif
33094
33095
33096 #ifdef __cplusplus
33097 extern "C" {
33098 #endif
33099
33100 /* Python-specific SWIG API */
33101 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33102 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33103 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33104
33105 /* -----------------------------------------------------------------------------
33106 * global variable support code.
33107 * ----------------------------------------------------------------------------- */
33108
33109 typedef struct swig_globalvar {
33110 char *name; /* Name of global variable */
33111 PyObject *(*get_attr)(); /* Return the current value */
33112 int (*set_attr)(PyObject *); /* Set the value */
33113 struct swig_globalvar *next;
33114 } swig_globalvar;
33115
33116 typedef struct swig_varlinkobject {
33117 PyObject_HEAD
33118 swig_globalvar *vars;
33119 } swig_varlinkobject;
33120
33121 static PyObject *
33122 swig_varlink_repr(swig_varlinkobject *v) {
33123 v = v;
33124 return PyString_FromString("<Swig global variables>");
33125 }
33126
33127 static int
33128 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33129 swig_globalvar *var;
33130 flags = flags;
33131 fprintf(fp,"Swig global variables { ");
33132 for (var = v->vars; var; var=var->next) {
33133 fprintf(fp,"%s", var->name);
33134 if (var->next) fprintf(fp,", ");
33135 }
33136 fprintf(fp," }\n");
33137 return 0;
33138 }
33139
33140 static PyObject *
33141 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33142 swig_globalvar *var = v->vars;
33143 while (var) {
33144 if (strcmp(var->name,n) == 0) {
33145 return (*var->get_attr)();
33146 }
33147 var = var->next;
33148 }
33149 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33150 return NULL;
33151 }
33152
33153 static int
33154 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33155 swig_globalvar *var = v->vars;
33156 while (var) {
33157 if (strcmp(var->name,n) == 0) {
33158 return (*var->set_attr)(p);
33159 }
33160 var = var->next;
33161 }
33162 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33163 return 1;
33164 }
33165
33166 static PyTypeObject varlinktype = {
33167 PyObject_HEAD_INIT(0)
33168 0, /* Number of items in variable part (ob_size) */
33169 (char *)"swigvarlink", /* Type name (tp_name) */
33170 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33171 0, /* Itemsize (tp_itemsize) */
33172 0, /* Deallocator (tp_dealloc) */
33173 (printfunc) swig_varlink_print, /* Print (tp_print) */
33174 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33175 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33176 0, /* tp_compare */
33177 (reprfunc) swig_varlink_repr, /* tp_repr */
33178 0, /* tp_as_number */
33179 0, /* tp_as_sequence */
33180 0, /* tp_as_mapping */
33181 0, /* tp_hash */
33182 0, /* tp_call */
33183 0, /* tp_str */
33184 0, /* tp_getattro */
33185 0, /* tp_setattro */
33186 0, /* tp_as_buffer */
33187 0, /* tp_flags */
33188 0, /* tp_doc */
33189 #if PY_VERSION_HEX >= 0x02000000
33190 0, /* tp_traverse */
33191 0, /* tp_clear */
33192 #endif
33193 #if PY_VERSION_HEX >= 0x02010000
33194 0, /* tp_richcompare */
33195 0, /* tp_weaklistoffset */
33196 #endif
33197 #if PY_VERSION_HEX >= 0x02020000
33198 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33199 #endif
33200 #if PY_VERSION_HEX >= 0x02030000
33201 0, /* tp_del */
33202 #endif
33203 #ifdef COUNT_ALLOCS
33204 0,0,0,0 /* tp_alloc -> tp_next */
33205 #endif
33206 };
33207
33208 /* Create a variable linking object for use later */
33209 static PyObject *
33210 SWIG_Python_newvarlink(void) {
33211 swig_varlinkobject *result = 0;
33212 result = PyMem_NEW(swig_varlinkobject,1);
33213 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33214 result->ob_type = &varlinktype;
33215 result->vars = 0;
33216 result->ob_refcnt = 0;
33217 Py_XINCREF((PyObject *) result);
33218 return ((PyObject*) result);
33219 }
33220
33221 static void
33222 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33223 swig_varlinkobject *v;
33224 swig_globalvar *gv;
33225 v= (swig_varlinkobject *) p;
33226 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33227 gv->name = (char *) malloc(strlen(name)+1);
33228 strcpy(gv->name,name);
33229 gv->get_attr = get_attr;
33230 gv->set_attr = set_attr;
33231 gv->next = v->vars;
33232 v->vars = gv;
33233 }
33234
33235 /* -----------------------------------------------------------------------------
33236 * constants/methods manipulation
33237 * ----------------------------------------------------------------------------- */
33238
33239 /* Install Constants */
33240 static void
33241 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33242 PyObject *obj = 0;
33243 size_t i;
33244 for (i = 0; constants[i].type; i++) {
33245 switch(constants[i].type) {
33246 case SWIG_PY_INT:
33247 obj = PyInt_FromLong(constants[i].lvalue);
33248 break;
33249 case SWIG_PY_FLOAT:
33250 obj = PyFloat_FromDouble(constants[i].dvalue);
33251 break;
33252 case SWIG_PY_STRING:
33253 if (constants[i].pvalue) {
33254 obj = PyString_FromString((char *) constants[i].pvalue);
33255 } else {
33256 Py_INCREF(Py_None);
33257 obj = Py_None;
33258 }
33259 break;
33260 case SWIG_PY_POINTER:
33261 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33262 break;
33263 case SWIG_PY_BINARY:
33264 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33265 break;
33266 default:
33267 obj = 0;
33268 break;
33269 }
33270 if (obj) {
33271 PyDict_SetItemString(d,constants[i].name,obj);
33272 Py_DECREF(obj);
33273 }
33274 }
33275 }
33276
33277 /* -----------------------------------------------------------------------------*/
33278 /* Fix SwigMethods to carry the callback ptrs when needed */
33279 /* -----------------------------------------------------------------------------*/
33280
33281 static void
33282 SWIG_Python_FixMethods(PyMethodDef *methods,
33283 swig_const_info *const_table,
33284 swig_type_info **types,
33285 swig_type_info **types_initial) {
33286 size_t i;
33287 for (i = 0; methods[i].ml_name; ++i) {
33288 char *c = methods[i].ml_doc;
33289 if (c && (c = strstr(c, "swig_ptr: "))) {
33290 int j;
33291 swig_const_info *ci = 0;
33292 char *name = c + 10;
33293 for (j = 0; const_table[j].type; j++) {
33294 if (strncmp(const_table[j].name, name,
33295 strlen(const_table[j].name)) == 0) {
33296 ci = &(const_table[j]);
33297 break;
33298 }
33299 }
33300 if (ci) {
33301 size_t shift = (ci->ptype) - types;
33302 swig_type_info *ty = types_initial[shift];
33303 size_t ldoc = (c - methods[i].ml_doc);
33304 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33305 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33306 char *buff = ndoc;
33307 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33308 strncpy(buff, methods[i].ml_doc, ldoc);
33309 buff += ldoc;
33310 strncpy(buff, "swig_ptr: ", 10);
33311 buff += 10;
33312 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33313 methods[i].ml_doc = ndoc;
33314 }
33315 }
33316 }
33317 }
33318
33319 /* -----------------------------------------------------------------------------*
33320 * Initialize type list
33321 * -----------------------------------------------------------------------------*/
33322
33323 #if PY_MAJOR_VERSION < 2
33324 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33325 is copied out of Python/modsupport.c in python version 2.3.4 */
33326 static int
33327 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33328 {
33329 PyObject *dict;
33330 if (!PyModule_Check(m)) {
33331 PyErr_SetString(PyExc_TypeError,
33332 "PyModule_AddObject() needs module as first arg");
33333 return -1;
33334 }
33335 if (!o) {
33336 PyErr_SetString(PyExc_TypeError,
33337 "PyModule_AddObject() needs non-NULL value");
33338 return -1;
33339 }
33340
33341 dict = PyModule_GetDict(m);
33342 if (dict == NULL) {
33343 /* Internal error -- modules must have a dict! */
33344 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33345 PyModule_GetName(m));
33346 return -1;
33347 }
33348 if (PyDict_SetItemString(dict, name, o))
33349 return -1;
33350 Py_DECREF(o);
33351 return 0;
33352 }
33353 #endif
33354
33355 static swig_type_info **
33356 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33357 static PyMethodDef swig_empty_runtime_method_table[] = {
33358 {
33359 NULL, NULL, 0, NULL
33360 }
33361 };/* Sentinel */
33362
33363 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33364 swig_empty_runtime_method_table);
33365 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33366 if (pointer && module) {
33367 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33368 }
33369 return type_list_handle;
33370 }
33371
33372 static swig_type_info **
33373 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33374 swig_type_info **type_pointer;
33375
33376 /* first check if module already created */
33377 type_pointer = SWIG_Python_GetTypeListHandle();
33378 if (type_pointer) {
33379 return type_pointer;
33380 } else {
33381 /* create a new module and variable */
33382 return SWIG_Python_SetTypeListHandle(type_list_handle);
33383 }
33384 }
33385
33386 #ifdef __cplusplus
33387 }
33388 #endif
33389
33390 /* -----------------------------------------------------------------------------*
33391 * Partial Init method
33392 * -----------------------------------------------------------------------------*/
33393
33394 #ifdef SWIG_LINK_RUNTIME
33395 #ifdef __cplusplus
33396 extern "C"
33397 #endif
33398 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33399 #endif
33400
33401 #ifdef __cplusplus
33402 extern "C"
33403 #endif
33404 SWIGEXPORT(void) SWIG_init(void) {
33405 static PyObject *SWIG_globals = 0;
33406 static int typeinit = 0;
33407 PyObject *m, *d;
33408 int i;
33409 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33410
33411 /* Fix SwigMethods to carry the callback ptrs when needed */
33412 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33413
33414 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33415 d = PyModule_GetDict(m);
33416
33417 if (!typeinit) {
33418 #ifdef SWIG_LINK_RUNTIME
33419 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33420 #else
33421 # ifndef SWIG_STATIC_RUNTIME
33422 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33423 # endif
33424 #endif
33425 for (i = 0; swig_types_initial[i]; i++) {
33426 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33427 }
33428 typeinit = 1;
33429 }
33430 SWIG_InstallConstants(d,swig_const_table);
33431
33432 {
33433 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33704 }
33705 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33706 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33707 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33708 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33709 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33710 {
33711 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33721 }
33722 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33723
33724 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33725
33726 {
33727 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33758 }
33759 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33760 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33761 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33762 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33763 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33764 {
33765 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33856 }
33857 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33858 {
33859 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33872 }
33873
33874 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33875
33876 {
33877 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33896 }
33897 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33898 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33899 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33900 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33901 {
33902 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33924 }
33925 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33926 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33927 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33928 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33929 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33930 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33931 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33932 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33933 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33934 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33935 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33936 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33937 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33938 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33939 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33940 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33941 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33942 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33943 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33944 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33945 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33946 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33947 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33948 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33949 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33950 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33951 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33952 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33953 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33954 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33955 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33956 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33957 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33958 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33959 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33960 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33961 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33962 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33963 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33964 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33965 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33966 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33967 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33968 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33969 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33970 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33971 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33972 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33973 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33974 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33975 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33976 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33977 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33978 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33979 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33980 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33981
33982 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33983
33984 {
33985 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
34010 }
34011 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
34012 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
34013 {
34014 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34129 }
34130 {
34131 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34132 }
34133 {
34134 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34135 }
34136 {
34137 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34138 }
34139 {
34140 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34141 }
34142 {
34143 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34144 }
34145 {
34146 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34147 }
34148 {
34149 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34150 }
34151 {
34152 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34153 }
34154 {
34155 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34156 }
34157 {
34158 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34159 }
34160 {
34161 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34162 }
34163 {
34164 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34165 }
34166 {
34167 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34168 }
34169 {
34170 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34171 }
34172 {
34173 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34174 }
34175 {
34176 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34177 }
34178 {
34179 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34180 }
34181 {
34182 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34183 }
34184 {
34185 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34186 }
34187 {
34188 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34189 }
34190 {
34191 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34192 }
34193 {
34194 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34195 }
34196 {
34197 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34198 }
34199 {
34200 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34201 }
34202 {
34203 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34204 }
34205 {
34206 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34207 }
34208 {
34209 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34210 }
34211 {
34212 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34213 }
34214 {
34215 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34216 }
34217 {
34218 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34219 }
34220 {
34221 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34222 }
34223 {
34224 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34225 }
34226 {
34227 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34228 }
34229 {
34230 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34231 }
34232 {
34233 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34234 }
34235 {
34236 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34237 }
34238 {
34239 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34240 }
34241 {
34242 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34243 }
34244 {
34245 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34246 }
34247 {
34248 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34249 }
34250 {
34251 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34252 }
34253 {
34254 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34255 }
34256 {
34257 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34258 }
34259 {
34260 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34261 }
34262 {
34263 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34264 }
34265 {
34266 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34267 }
34268 {
34269 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34297 }
34298 {
34299 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34300 }
34301 {
34302 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34303 }
34304 {
34305 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34306 }
34307 {
34308 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34309 }
34310 {
34311 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34312 }
34313 {
34314 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34315 }
34316 {
34317 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34318 }
34319 {
34320 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34321 }
34322 {
34323 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34324 }
34325 {
34326 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34327 }
34328 {
34329 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34330 }
34331 {
34332 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34333 }
34334 {
34335 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34336 }
34337 {
34338 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34339 }
34340 {
34341 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34342 }
34343 {
34344 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34345 }
34346 {
34347 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34348 }
34349 {
34350 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34351 }
34352 {
34353 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34354 }
34355 {
34356 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34357 }
34358 {
34359 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34360 }
34361 {
34362 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34363 }
34364 {
34365 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34366 }
34367 {
34368 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34369 }
34370 {
34371 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34372 }
34373 {
34374 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34375 }
34376 {
34377 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34378 }
34379 {
34380 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34381 }
34382 {
34383 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34384 }
34385 {
34386 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34387 }
34388 {
34389 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34390 }
34391 {
34392 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34393 }
34394 {
34395 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34396 }
34397 {
34398 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34399 }
34400 {
34401 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34402 }
34403 {
34404 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34405 }
34406 {
34407 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34408 }
34409 {
34410 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34411 }
34412 {
34413 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34414 }
34415 {
34416 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34417 }
34418 {
34419 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34420 }
34421 {
34422 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34423 }
34424 {
34425 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34426 }
34427 {
34428 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34429 }
34430 {
34431 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34432 }
34433 {
34434 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34435 }
34436 {
34437 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34438 }
34439 {
34440 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34441 }
34442 {
34443 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34444 }
34445 {
34446 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34447 }
34448 {
34449 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34450 }
34451 {
34452 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34453 }
34454 {
34455 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34456 }
34457 {
34458 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34459 }
34460 {
34461 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34462 }
34463 {
34464 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34465 }
34466 {
34467 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34468 }
34469 {
34470 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34471 }
34472 {
34473 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34474 }
34475 {
34476 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34477 }
34478 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34479 {
34480 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34481 }
34482 {
34483 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34484 }
34485 {
34486 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34487 }
34488 {
34489 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34490 }
34491 {
34492 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34493 }
34494 {
34495 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34496 }
34497 {
34498 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34499 }
34500 {
34501 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34502 }
34503 {
34504 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34505 }
34506 {
34507 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34508 }
34509 {
34510 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34511 }
34512 {
34513 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34514 }
34515 {
34516 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34517 }
34518 {
34519 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34520 }
34521 {
34522 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34523 }
34524 {
34525 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34526 }
34527 {
34528 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34529 }
34530 {
34531 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34532 }
34533 {
34534 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34535 }
34536 {
34537 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34538 }
34539 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34540 {
34541 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34542 }
34543 {
34544 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34545 }
34546 {
34547 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34548 }
34549 {
34550 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34551 }
34552 {
34553 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34554 }
34555 {
34556 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34557 }
34558 {
34559 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34560 }
34561 {
34562 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34563 }
34564 {
34565 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34566 }
34567 {
34568 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34569 }
34570 {
34571 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34572 }
34573 {
34574 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34575 }
34576
34577 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34578 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34579 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34580 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34581
34582 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34583 }
34584
wxWidgets (Impactor)