]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:


e6fe38300b0cc707fd9b614d010fc2259c5d2484
[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_wxLogBuffer swig_types[77]
1420 #define SWIGTYPE_p_wxKillError swig_types[78]
1421 #define SWIGTYPE_p_wxWindow swig_types[79]
1422 #define SWIGTYPE_p_wxString swig_types[80]
1423 #define SWIGTYPE_p_wxPyProcess swig_types[81]
1424 #define SWIGTYPE_p_wxBitmap swig_types[82]
1425 #define SWIGTYPE_unsigned_int swig_types[83]
1426 #define SWIGTYPE_p_unsigned_int swig_types[84]
1427 #define SWIGTYPE_p_wxConfig swig_types[85]
1428 #define SWIGTYPE_p_unsigned_char swig_types[86]
1429 #define SWIGTYPE_p_wxChar swig_types[87]
1430 #define SWIGTYPE_p_wxBusyInfo swig_types[88]
1431 #define SWIGTYPE_p_wxPyDropTarget swig_types[89]
1432 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[90]
1433 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[91]
1434 #define SWIGTYPE_p_wxProcessEvent swig_types[92]
1435 #define SWIGTYPE_p_wxPyLog swig_types[93]
1436 #define SWIGTYPE_p_wxLogNull swig_types[94]
1437 #define SWIGTYPE_p_wxColour swig_types[95]
1438 #define SWIGTYPE_p_wxPyTimer swig_types[96]
1439 #define SWIGTYPE_p_wxConfigPathChanger swig_types[97]
1440 #define SWIGTYPE_p_wxDateSpan swig_types[98]
1441 static swig_type_info *swig_types[100];
1442
1443 /* -------- TYPES TABLE (END) -------- */
1444
1445
1446 /*-----------------------------------------------
1447 @(target):= _misc_.so
1448 ------------------------------------------------*/
1449 #define SWIG_init init_misc_
1450
1451 #define SWIG_name "_misc_"
1452
1453 #include "wx/wxPython/wxPython.h"
1454 #include "wx/wxPython/pyclasses.h"
1455 #include "wx/wxPython/pyistream.h"
1456
1457 static const wxString wxPyEmptyString(wxEmptyString);
1458
1459
1460
1461 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1462 #define SWIG_From_int PyInt_FromLong
1463 /*@@*/
1464
1465
1466 #include <limits.h>
1467
1468
1469 SWIGINTERN int
1470 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1471 const char *errmsg)
1472 {
1473 if (value < min_value) {
1474 if (errmsg) {
1475 PyErr_Format(PyExc_OverflowError,
1476 "value %ld is less than '%s' minimum %ld",
1477 value, errmsg, min_value);
1478 }
1479 return 0;
1480 } else if (value > max_value) {
1481 if (errmsg) {
1482 PyErr_Format(PyExc_OverflowError,
1483 "value %ld is greater than '%s' maximum %ld",
1484 value, errmsg, max_value);
1485 }
1486 return 0;
1487 }
1488 return 1;
1489 }
1490
1491
1492 SWIGINTERN int
1493 SWIG_AsVal_long(PyObject* obj, long* val)
1494 {
1495 if (PyNumber_Check(obj)) {
1496 if (val) *val = PyInt_AsLong(obj);
1497 return 1;
1498 }
1499 else {
1500 SWIG_type_error("number", obj);
1501 }
1502 return 0;
1503 }
1504
1505
1506 #if INT_MAX != LONG_MAX
1507 SWIGINTERN int
1508 SWIG_AsVal_int(PyObject *obj, int *val)
1509 {
1510 const char* errmsg = val ? "int" : (char*)0;
1511 long v;
1512 if (SWIG_AsVal_long(obj, &v)) {
1513 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1514 if (val) *val = (int)(v);
1515 return 1;
1516 } else {
1517 return 0;
1518 }
1519 } else {
1520 PyErr_Clear();
1521 }
1522 if (val) {
1523 SWIG_type_error(errmsg, obj);
1524 }
1525 return 0;
1526 }
1527 #else
1528 SWIGINTERNSHORT int
1529 SWIG_AsVal_int(PyObject *obj, int *val)
1530 {
1531 return SWIG_AsVal_long(obj,(long*)val);
1532 }
1533 #endif
1534
1535
1536 SWIGINTERNSHORT int
1537 SWIG_As_int(PyObject* obj)
1538 {
1539 int v;
1540 if (!SWIG_AsVal_int(obj, &v)) {
1541 /*
1542 this is needed to make valgrind/purify happier.
1543 */
1544 memset((void*)&v, 0, sizeof(int));
1545 }
1546 return v;
1547 }
1548
1549
1550 SWIGINTERNSHORT int
1551 SWIG_Check_int(PyObject* obj)
1552 {
1553 return SWIG_AsVal_int(obj, (int*)0);
1554 }
1555
1556 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1557
1558 #include <wx/stockitem.h>
1559
1560 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1561 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1562 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1563
1564 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1565 #define SWIG_From_long PyInt_FromLong
1566 /*@@*/
1567
1568
1569 SWIGINTERNSHORT long
1570 SWIG_As_long(PyObject* obj)
1571 {
1572 long v;
1573 if (!SWIG_AsVal_long(obj, &v)) {
1574 /*
1575 this is needed to make valgrind/purify happier.
1576 */
1577 memset((void*)&v, 0, sizeof(long));
1578 }
1579 return v;
1580 }
1581
1582
1583 SWIGINTERNSHORT int
1584 SWIG_Check_long(PyObject* obj)
1585 {
1586 return SWIG_AsVal_long(obj, (long*)0);
1587 }
1588
1589
1590 SWIGINTERN int
1591 SWIG_AsVal_bool(PyObject *obj, bool *val)
1592 {
1593 if (obj == Py_True) {
1594 if (val) *val = true;
1595 return 1;
1596 }
1597 if (obj == Py_False) {
1598 if (val) *val = false;
1599 return 1;
1600 }
1601 int res = 0;
1602 if (SWIG_AsVal_int(obj, &res)) {
1603 if (val) *val = res ? true : false;
1604 return 1;
1605 } else {
1606 PyErr_Clear();
1607 }
1608 if (val) {
1609 SWIG_type_error("bool", obj);
1610 }
1611 return 0;
1612 }
1613
1614
1615 SWIGINTERNSHORT bool
1616 SWIG_As_bool(PyObject* obj)
1617 {
1618 bool v;
1619 if (!SWIG_AsVal_bool(obj, &v)) {
1620 /*
1621 this is needed to make valgrind/purify happier.
1622 */
1623 memset((void*)&v, 0, sizeof(bool));
1624 }
1625 return v;
1626 }
1627
1628
1629 SWIGINTERNSHORT int
1630 SWIG_Check_bool(PyObject* obj)
1631 {
1632 return SWIG_AsVal_bool(obj, (bool*)0);
1633 }
1634
1635
1636 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1637 PyObject* o2;
1638 PyObject* o3;
1639
1640 if (!target) {
1641 target = o;
1642 } else if (target == Py_None) {
1643 Py_DECREF(Py_None);
1644 target = o;
1645 } else {
1646 if (!PyTuple_Check(target)) {
1647 o2 = target;
1648 target = PyTuple_New(1);
1649 PyTuple_SetItem(target, 0, o2);
1650 }
1651 o3 = PyTuple_New(1);
1652 PyTuple_SetItem(o3, 0, o);
1653
1654 o2 = target;
1655 target = PySequence_Concat(o2, o3);
1656 Py_DECREF(o2);
1657 Py_DECREF(o3);
1658 }
1659 return target;
1660 }
1661
1662
1663
1664 SWIGINTERN int
1665 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1666 {
1667 long v = 0;
1668 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1669 SWIG_type_error("unsigned number", obj);
1670 }
1671 else if (val)
1672 *val = (unsigned long)v;
1673 return 1;
1674 }
1675
1676
1677 SWIGINTERNSHORT unsigned long
1678 SWIG_As_unsigned_SS_long(PyObject* obj)
1679 {
1680 unsigned long v;
1681 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1682 /*
1683 this is needed to make valgrind/purify happier.
1684 */
1685 memset((void*)&v, 0, sizeof(unsigned long));
1686 }
1687 return v;
1688 }
1689
1690
1691 SWIGINTERNSHORT int
1692 SWIG_Check_unsigned_SS_long(PyObject* obj)
1693 {
1694 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1695 }
1696
1697
1698 SWIGINTERNSHORT PyObject*
1699 SWIG_From_unsigned_SS_long(unsigned long value)
1700 {
1701 return (value > LONG_MAX) ?
1702 PyLong_FromUnsignedLong(value)
1703 : PyInt_FromLong((long)(value));
1704 }
1705
1706
1707 void* wxGetXDisplay()
1708 {
1709 #ifdef __WXGTK__
1710 return wxGetDisplay();
1711 #else
1712 return NULL;
1713 #endif
1714 }
1715
1716
1717 bool wxThread_IsMain() {
1718 #ifdef WXP_WITH_THREAD
1719 return wxThread::IsMain();
1720 #else
1721 return true;
1722 #endif
1723 }
1724
1725 static void wxCaret_Destroy(wxCaret *self){
1726 delete self;
1727 }
1728
1729 #include <wx/snglinst.h>
1730
1731
1732 #ifdef __WXMSW__
1733 #include <wx/msw/private.h>
1734 #include <wx/dynload.h>
1735 #endif
1736
1737
1738
1739 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1740 #if 0
1741 , int method
1742 #endif
1743 )
1744 {
1745 #ifdef __WXMSW__
1746 #if 0
1747 switch (method)
1748 {
1749 case 1:
1750 // This one only partially works. Appears to be an undocumented
1751 // "standard" convention that not all widgets adhear to. For
1752 // example, for some widgets backgrounds or non-client areas may
1753 // not be painted.
1754 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1755 break;
1756
1757 case 2:
1758 #endif
1759 // This one works much better, nearly all widgets and their
1760 // children are captured correctly[**]. Prior to the big
1761 // background erase changes that Vadim did in 2004-2005 this
1762 // method failed badly on XP with Themes activated, most native
1763 // widgets draw only partially, if at all. Without themes it
1764 // worked just like on Win2k. After those changes this method
1765 // works very well.
1766 //
1767 // ** For example the radio buttons in a wxRadioBox are not its
1768 // children by default, but you can capture it via the panel
1769 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1770 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1771 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1772 PRF_ERASEBKGND | PRF_OWNED );
1773 return true;
1774 #if 0
1775 break;
1776
1777 case 3:
1778 // This one is only defined in the latest SDK and is only
1779 // available on XP. MSDN says it is similar to sending WM_PRINT
1780 // so I expect that it will work similar to the above. Since it
1781 // is avaialble only on XP, it can't be compiled like this and
1782 // will have to be loaded dynamically.
1783 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1784
1785 // fall through
1786
1787 case 4:
1788 // Use PrintWindow if available, or fallback to WM_PRINT
1789 // otherwise. Unfortunately using PrintWindow is even worse than
1790 // WM_PRINT. For most native widgets nothing is drawn to the dc
1791 // at all, with or without Themes.
1792 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1793 static bool s_triedToLoad = false;
1794 static PrintWindow_t pfnPrintWindow = NULL;
1795 if ( !s_triedToLoad )
1796 {
1797
1798 s_triedToLoad = true;
1799 wxDynamicLibrary dllUser32(_T("user32.dll"));
1800 if ( dllUser32.IsLoaded() )
1801 {
1802 wxLogNull nolog; // Don't report errors here
1803 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1804 }
1805 }
1806 if (pfnPrintWindow)
1807 {
1808 //printf("Using PrintWindow\n");
1809 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1810 }
1811 else
1812 {
1813 //printf("Using WM_PRINT\n");
1814 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1815 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1816 PRF_ERASEBKGND | PRF_OWNED );
1817 }
1818 }
1819 #endif // 0
1820 #else
1821 return false;
1822 #endif // __WXMSW__
1823 }
1824
1825
1826
1827 #include <wx/tipdlg.h>
1828
1829
1830 class wxPyTipProvider : public wxTipProvider {
1831 public:
1832 wxPyTipProvider(size_t currentTip)
1833 : wxTipProvider(currentTip) {}
1834
1835 DEC_PYCALLBACK_STRING__pure(GetTip);
1836 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1837 PYPRIVATE;
1838 };
1839
1840 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1841 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1842
1843
1844 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1845
1846 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1847
1848 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1849 : wxTimer(owner, id)
1850 {
1851 if (owner == NULL) SetOwner(this);
1852 }
1853
1854
1855 void wxPyTimer::Notify() {
1856 bool found;
1857 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1858 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1859 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1860 wxPyEndBlockThreads(blocked);
1861 if (! found)
1862 wxTimer::Notify();
1863 }
1864 void wxPyTimer::base_Notify() {
1865 wxTimer::Notify();
1866 }
1867
1868
1869
1870 SWIGINTERN PyObject *
1871 SWIG_FromCharPtr(const char* cptr)
1872 {
1873 if (cptr) {
1874 size_t size = strlen(cptr);
1875 if (size > INT_MAX) {
1876 return SWIG_NewPointerObj((char*)(cptr),
1877 SWIG_TypeQuery("char *"), 0);
1878 } else {
1879 if (size != 0) {
1880 return PyString_FromStringAndSize(cptr, size);
1881 } else {
1882 return PyString_FromString(cptr);
1883 }
1884 }
1885 }
1886 Py_INCREF(Py_None);
1887 return Py_None;
1888 }
1889
1890
1891 SWIGINTERNSHORT int
1892 SWIG_CheckUnsignedLongInRange(unsigned long value,
1893 unsigned long max_value,
1894 const char *errmsg)
1895 {
1896 if (value > max_value) {
1897 if (errmsg) {
1898 PyErr_Format(PyExc_OverflowError,
1899 "value %lu is greater than '%s' minimum %lu",
1900 value, errmsg, max_value);
1901 }
1902 return 0;
1903 }
1904 return 1;
1905 }
1906
1907
1908 #if UINT_MAX != ULONG_MAX
1909 SWIGINTERN int
1910 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1911 {
1912 const char* errmsg = val ? "unsigned int" : (char*)0;
1913 unsigned long v;
1914 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1915 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1916 if (val) *val = (unsigned int)(v);
1917 return 1;
1918 }
1919 } else {
1920 PyErr_Clear();
1921 }
1922 if (val) {
1923 SWIG_type_error(errmsg, obj);
1924 }
1925 return 0;
1926 }
1927 #else
1928 SWIGINTERNSHORT unsigned int
1929 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1930 {
1931 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1932 }
1933 #endif
1934
1935
1936 SWIGINTERNSHORT unsigned int
1937 SWIG_As_unsigned_SS_int(PyObject* obj)
1938 {
1939 unsigned int v;
1940 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1941 /*
1942 this is needed to make valgrind/purify happier.
1943 */
1944 memset((void*)&v, 0, sizeof(unsigned int));
1945 }
1946 return v;
1947 }
1948
1949
1950 SWIGINTERNSHORT int
1951 SWIG_Check_unsigned_SS_int(PyObject* obj)
1952 {
1953 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1954 }
1955
1956 static wxString Log_TimeStamp(){
1957 wxString msg;
1958 wxLog::TimeStamp(&msg);
1959 return msg;
1960 }
1961 static void wxLog_Destroy(wxLog *self){ delete self; }
1962 // Make somce wrappers that double any % signs so they are 'escaped'
1963 void wxPyLogFatalError(const wxString& msg)
1964 {
1965 wxString m(msg);
1966 m.Replace(wxT("%"), wxT("%%"));
1967 wxLogFatalError(m);
1968 }
1969
1970 void wxPyLogError(const wxString& msg)
1971 {
1972 wxString m(msg);
1973 m.Replace(wxT("%"), wxT("%%"));
1974 wxLogError(m);
1975 }
1976
1977 void wxPyLogWarning(const wxString& msg)
1978 {
1979 wxString m(msg);
1980 m.Replace(wxT("%"), wxT("%%"));
1981 wxLogWarning(m);
1982 }
1983
1984 void wxPyLogMessage(const wxString& msg)
1985 {
1986 wxString m(msg);
1987 m.Replace(wxT("%"), wxT("%%"));
1988 wxLogMessage(m);
1989 }
1990
1991 void wxPyLogInfo(const wxString& msg)
1992 {
1993 wxString m(msg);
1994 m.Replace(wxT("%"), wxT("%%"));
1995 wxLogInfo(m);
1996 }
1997
1998 void wxPyLogDebug(const wxString& msg)
1999 {
2000 wxString m(msg);
2001 m.Replace(wxT("%"), wxT("%%"));
2002 wxLogDebug(m);
2003 }
2004
2005 void wxPyLogVerbose(const wxString& msg)
2006 {
2007 wxString m(msg);
2008 m.Replace(wxT("%"), wxT("%%"));
2009 wxLogVerbose(m);
2010 }
2011
2012 void wxPyLogStatus(const wxString& msg)
2013 {
2014 wxString m(msg);
2015 m.Replace(wxT("%"), wxT("%%"));
2016 wxLogStatus(m);
2017 }
2018
2019 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2020 {
2021 wxString m(msg);
2022 m.Replace(wxT("%"), wxT("%%"));
2023 wxLogStatus(pFrame, m);
2024 }
2025
2026 void wxPyLogSysError(const wxString& msg)
2027 {
2028 wxString m(msg);
2029 m.Replace(wxT("%"), wxT("%%"));
2030 wxLogSysError(m);
2031 }
2032
2033 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2034 {
2035 wxString m(msg);
2036 m.Replace(wxT("%"), wxT("%%"));
2037 wxLogGeneric(level, m);
2038 }
2039
2040 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2041 {
2042 wxString m(msg);
2043 m.Replace(wxT("%"), wxT("%%"));
2044 wxLogTrace(mask, m);
2045 }
2046
2047 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2048 {
2049 wxString m(msg);
2050 m.Replace(wxT("%"), wxT("%%"));
2051 wxLogTrace(mask, m);
2052 }
2053
2054
2055
2056 // A wxLog class that can be derived from in wxPython
2057 class wxPyLog : public wxLog {
2058 public:
2059 wxPyLog() : wxLog() {}
2060
2061 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2062 bool found;
2063 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2064 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2065 PyObject* s = wx2PyString(szString);
2066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2067 Py_DECREF(s);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 if (! found)
2071 wxLog::DoLog(level, szString, t);
2072 }
2073
2074 virtual void DoLogString(const wxChar *szString, time_t t) {
2075 bool found;
2076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2077 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2078 PyObject* s = wx2PyString(szString);
2079 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2080 Py_DECREF(s);
2081 }
2082 wxPyEndBlockThreads(blocked);
2083 if (! found)
2084 wxLog::DoLogString(szString, t);
2085 }
2086
2087 PYPRIVATE;
2088 };
2089
2090
2091
2092
2093 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2094
2095
2096 #include <wx/joystick.h>
2097
2098
2099 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2100 // A C++ stub class for wxJoystick for platforms that don't have it.
2101 class wxJoystick : public wxObject {
2102 public:
2103 wxJoystick(int joystick = wxJOYSTICK1) {
2104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2105 PyErr_SetString(PyExc_NotImplementedError,
2106 "wxJoystick is not available on this platform.");
2107 wxPyEndBlockThreads(blocked);
2108 }
2109 wxPoint GetPosition() { return wxPoint(-1,-1); }
2110 int GetZPosition() { return -1; }
2111 int GetButtonState() { return -1; }
2112 int GetPOVPosition() { return -1; }
2113 int GetPOVCTSPosition() { return -1; }
2114 int GetRudderPosition() { return -1; }
2115 int GetUPosition() { return -1; }
2116 int GetVPosition() { return -1; }
2117 int GetMovementThreshold() { return -1; }
2118 void SetMovementThreshold(int threshold) {}
2119
2120 bool IsOk(void) { return false; }
2121 int GetNumberJoysticks() { return -1; }
2122 int GetManufacturerId() { return -1; }
2123 int GetProductId() { return -1; }
2124 wxString GetProductName() { return wxEmptyString; }
2125 int GetXMin() { return -1; }
2126 int GetYMin() { return -1; }
2127 int GetZMin() { return -1; }
2128 int GetXMax() { return -1; }
2129 int GetYMax() { return -1; }
2130 int GetZMax() { return -1; }
2131 int GetNumberButtons() { return -1; }
2132 int GetNumberAxes() { return -1; }
2133 int GetMaxButtons() { return -1; }
2134 int GetMaxAxes() { return -1; }
2135 int GetPollingMin() { return -1; }
2136 int GetPollingMax() { return -1; }
2137 int GetRudderMin() { return -1; }
2138 int GetRudderMax() { return -1; }
2139 int GetUMin() { return -1; }
2140 int GetUMax() { return -1; }
2141 int GetVMin() { return -1; }
2142 int GetVMax() { return -1; }
2143
2144 bool HasRudder() { return false; }
2145 bool HasZ() { return false; }
2146 bool HasU() { return false; }
2147 bool HasV() { return false; }
2148 bool HasPOV() { return false; }
2149 bool HasPOV4Dir() { return false; }
2150 bool HasPOVCTS() { return false; }
2151
2152 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2153 bool ReleaseCapture() { return false; }
2154 };
2155 #endif
2156
2157
2158 #include <wx/sound.h>
2159
2160
2161 #if !wxUSE_SOUND
2162 // A C++ stub class for wxWave for platforms that don't have it.
2163 class wxSound : public wxObject
2164 {
2165 public:
2166 wxSound() {
2167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2168 PyErr_SetString(PyExc_NotImplementedError,
2169 "wxSound is not available on this platform.");
2170 wxPyEndBlockThreads(blocked);
2171 }
2172 wxSound(const wxString&/*, bool*/) {
2173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2174 PyErr_SetString(PyExc_NotImplementedError,
2175 "wxSound is not available on this platform.");
2176 wxPyEndBlockThreads(blocked);
2177 }
2178 wxSound(int, const wxByte*) {
2179 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2180 PyErr_SetString(PyExc_NotImplementedError,
2181 "wxSound is not available on this platform.");
2182 wxPyEndBlockThreads(blocked);
2183 }
2184
2185 ~wxSound() {};
2186
2187 bool Create(const wxString&/*, bool*/) { return false; }
2188 bool Create(int, const wxByte*) { return false; };
2189 bool IsOk() { return false; };
2190 bool Play(unsigned) const { return false; }
2191 static bool Play(const wxString&, unsigned) { return false; }
2192 static void Stop() {}
2193 };
2194
2195 #endif
2196
2197 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2198 if (fileName.Length() == 0)
2199 return new wxSound;
2200 else
2201 return new wxSound(fileName);
2202 }
2203 static wxSound *new_wxSound(PyObject *data){
2204 unsigned char* buffer; int size;
2205 wxSound *sound = NULL;
2206
2207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2208 if (!PyArg_Parse(data, "t#", &buffer, &size))
2209 goto done;
2210 sound = new wxSound(size, buffer);
2211 done:
2212 wxPyEndBlockThreads(blocked);
2213 return sound;
2214 }
2215 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2216 #ifndef __WXMAC__
2217 unsigned char* buffer;
2218 int size;
2219 bool rv = false;
2220
2221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2222 if (!PyArg_Parse(data, "t#", &buffer, &size))
2223 goto done;
2224 rv = self->Create(size, buffer);
2225 done:
2226 wxPyEndBlockThreads(blocked);
2227 return rv;
2228 #else
2229 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2230 PyErr_SetString(PyExc_NotImplementedError,
2231 "Create from data is not available on this platform.");
2232 wxPyEndBlockThreads(blocked);
2233 return false;
2234 #endif
2235 }
2236
2237 #include <wx/mimetype.h>
2238
2239 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2240 wxString str;
2241 if (self->GetMimeType(&str))
2242 return wx2PyString(str);
2243 else
2244 RETURN_NONE();
2245 }
2246 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2247 wxArrayString arr;
2248 if (self->GetMimeTypes(arr))
2249 return wxArrayString2PyList_helper(arr);
2250 else
2251 RETURN_NONE();
2252 }
2253 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2254 wxArrayString arr;
2255 if (self->GetExtensions(arr))
2256 return wxArrayString2PyList_helper(arr);
2257 else
2258 RETURN_NONE();
2259 }
2260 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2261 wxIconLocation loc;
2262 if (self->GetIcon(&loc))
2263 return new wxIcon(loc);
2264 else
2265 return NULL;
2266 }
2267 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2268 wxIconLocation loc;
2269 if (self->GetIcon(&loc)) {
2270 wxString iconFile = loc.GetFileName();
2271 int iconIndex = -1;
2272
2273 iconIndex = loc.GetIndex();
2274
2275 // Make a tuple and put the values in it
2276 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2277 PyObject* tuple = PyTuple_New(3);
2278 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2279 wxT("wxIcon"), true));
2280 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2281 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2282 wxPyEndBlockThreads(blocked);
2283 return tuple;
2284 }
2285 else
2286 RETURN_NONE();
2287 }
2288 static PyObject *wxFileType_GetDescription(wxFileType *self){
2289 wxString str;
2290 if (self->GetDescription(&str))
2291 return wx2PyString(str);
2292 else
2293 RETURN_NONE();
2294 }
2295 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2296 wxString str;
2297 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2298 return wx2PyString(str);
2299 else
2300 RETURN_NONE();
2301 }
2302 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2303 wxString str;
2304 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2305 return wx2PyString(str);
2306 else
2307 RETURN_NONE();
2308 }
2309 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2310 wxArrayString verbs;
2311 wxArrayString commands;
2312 if (self->GetAllCommands(&verbs, &commands,
2313 wxFileType::MessageParameters(filename, mimetype))) {
2314 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2315 PyObject* tuple = PyTuple_New(2);
2316 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2317 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2318 wxPyEndBlockThreads(blocked);
2319 return tuple;
2320 }
2321 else
2322 RETURN_NONE();
2323 }
2324 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2325 return wxFileType::ExpandCommand(command,
2326 wxFileType::MessageParameters(filename, mimetype));
2327 }
2328 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2329 wxArrayString arr;
2330 self->EnumAllFileTypes(arr);
2331 return wxArrayString2PyList_helper(arr);
2332 }
2333
2334 #include <wx/artprov.h>
2335
2336 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2337 static const wxString wxPyART_MENU(wxART_MENU);
2338 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2339 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2340 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2341 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2342 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2343 static const wxString wxPyART_OTHER(wxART_OTHER);
2344 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2345 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2346 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2347 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2348 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2349 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2350 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2351 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2352 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2353 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2354 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2355 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2356 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2357 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2358 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2359 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2360 static const wxString wxPyART_PRINT(wxART_PRINT);
2361 static const wxString wxPyART_HELP(wxART_HELP);
2362 static const wxString wxPyART_TIP(wxART_TIP);
2363 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2364 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2365 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2366 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2367 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2368 static const wxString wxPyART_CDROM(wxART_CDROM);
2369 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2370 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2371 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2372 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2373 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2374 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2375 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2376 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2377 static const wxString wxPyART_ERROR(wxART_ERROR);
2378 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2379 static const wxString wxPyART_WARNING(wxART_WARNING);
2380 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2381 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2382 static const wxString wxPyART_COPY(wxART_COPY);
2383 static const wxString wxPyART_CUT(wxART_CUT);
2384 static const wxString wxPyART_PASTE(wxART_PASTE);
2385 static const wxString wxPyART_DELETE(wxART_DELETE);
2386 static const wxString wxPyART_NEW(wxART_NEW);
2387 static const wxString wxPyART_UNDO(wxART_UNDO);
2388 static const wxString wxPyART_REDO(wxART_REDO);
2389 static const wxString wxPyART_QUIT(wxART_QUIT);
2390 static const wxString wxPyART_FIND(wxART_FIND);
2391 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2392 // Python aware wxArtProvider
2393 class wxPyArtProvider : public wxArtProvider {
2394 public:
2395
2396 virtual wxBitmap CreateBitmap(const wxArtID& id,
2397 const wxArtClient& client,
2398 const wxSize& size) {
2399 wxBitmap rval = wxNullBitmap;
2400 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2401 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2402 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2403 PyObject* ro;
2404 wxBitmap* ptr;
2405 PyObject* s1, *s2;
2406 s1 = wx2PyString(id);
2407 s2 = wx2PyString(client);
2408 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2409 Py_DECREF(so);
2410 Py_DECREF(s1);
2411 Py_DECREF(s2);
2412 if (ro) {
2413 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2414 rval = *ptr;
2415 Py_DECREF(ro);
2416 }
2417 }
2418 wxPyEndBlockThreads(blocked);
2419 return rval;
2420 }
2421
2422 PYPRIVATE;
2423 };
2424
2425 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2426
2427
2428
2429 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2430 PyObject* ret = PyTuple_New(3);
2431 if (ret) {
2432 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2433 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2434 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2435 }
2436 return ret;
2437 }
2438
2439 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2440 bool cont;
2441 long index = 0;
2442 wxString value;
2443
2444 cont = self->GetFirstGroup(value, index);
2445 return __EnumerationHelper(cont, value, index);
2446 }
2447 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2448 bool cont;
2449 wxString value;
2450
2451 cont = self->GetNextGroup(value, index);
2452 return __EnumerationHelper(cont, value, index);
2453 }
2454 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2455 bool cont;
2456 long index = 0;
2457 wxString value;
2458
2459 cont = self->GetFirstEntry(value, index);
2460 return __EnumerationHelper(cont, value, index);
2461 }
2462 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2463 bool cont;
2464 wxString value;
2465
2466 cont = self->GetNextEntry(value, index);
2467 return __EnumerationHelper(cont, value, index);
2468 }
2469 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2470 long rv;
2471 self->Read(key, &rv, defaultVal);
2472 return rv;
2473 }
2474
2475 SWIGINTERN int
2476 SWIG_AsVal_double(PyObject *obj, double* val)
2477 {
2478 if (PyNumber_Check(obj)) {
2479 if (val) *val = PyFloat_AsDouble(obj);
2480 return 1;
2481 }
2482 else {
2483 SWIG_type_error("number", obj);
2484 }
2485 return 0;
2486 }
2487
2488
2489 SWIGINTERNSHORT double
2490 SWIG_As_double(PyObject* obj)
2491 {
2492 double v;
2493 if (!SWIG_AsVal_double(obj, &v)) {
2494 /*
2495 this is needed to make valgrind/purify happier.
2496 */
2497 memset((void*)&v, 0, sizeof(double));
2498 }
2499 return v;
2500 }
2501
2502
2503 SWIGINTERNSHORT int
2504 SWIG_Check_double(PyObject* obj)
2505 {
2506 return SWIG_AsVal_double(obj, (double*)0);
2507 }
2508
2509 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2510 double rv;
2511 self->Read(key, &rv, defaultVal);
2512 return rv;
2513 }
2514
2515 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2516 #define SWIG_From_double PyFloat_FromDouble
2517 /*@@*/
2518
2519 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2520 bool rv;
2521 self->Read(key, &rv, defaultVal);
2522 return rv;
2523 }
2524
2525 #include <wx/datetime.h>
2526
2527 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2528 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2529
2530 #define LOCAL_TZ wxDateTime::Local
2531
2532 static PyObject *DateTime_GetAmPmStrings(){
2533 wxString am;
2534 wxString pm;
2535 wxDateTime::GetAmPmStrings(&am, &pm);
2536 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2537 PyObject* tup = PyTuple_New(2);
2538 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2539 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2540 wxPyEndBlockThreads(blocked);
2541 return tup;
2542 }
2543
2544 #if UINT_MAX < LONG_MAX
2545 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2546 #define SWIG_From_unsigned_SS_int SWIG_From_long
2547 /*@@*/
2548 #else
2549 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2550 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2551 /*@@*/
2552 #endif
2553
2554 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2555 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2556 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2557 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2558 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2559 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2560 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2561 return (*self < *other);
2562 }
2563 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2564 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2565 return (*self <= *other);
2566 }
2567 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2568 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2569 return (*self > *other);
2570 }
2571 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2572 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2573 return (*self >= *other);
2574 }
2575 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2576 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2577 return (*self == *other);
2578 }
2579 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2580 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2581 return (*self != *other);
2582 }
2583 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2584 const wxChar* rv;
2585 const wxChar* _date = date;
2586 rv = self->ParseRfc822Date(_date);
2587 if (rv == NULL) return -1;
2588 return rv - _date;
2589 }
2590 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2591 const wxChar* rv;
2592 const wxChar* _date = date;
2593 rv = self->ParseFormat(_date, format, dateDef);
2594 if (rv == NULL) return -1;
2595 return rv - _date;
2596 }
2597 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2598 const wxChar* rv;
2599 const wxChar* _datetime = datetime;
2600 rv = self->ParseDateTime(_datetime);
2601 if (rv == NULL) return -1;
2602 return rv - _datetime;
2603 }
2604 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2605 const wxChar* rv;
2606 const wxChar* _date = date;
2607 rv = self->ParseDate(_date);
2608 if (rv == NULL) return -1;
2609 return rv - _date;
2610 }
2611 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2612 const wxChar* rv;
2613 const wxChar* _time = time;
2614 rv = self->ParseTime(_time);
2615 if (rv == NULL) return -1;
2616 return rv - _time;
2617 }
2618 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2619 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2620 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2621 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2622 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2623 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2624 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2625 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2626 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2627 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2628 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2629 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2630 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2631 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2632 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2633 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2634
2635 #include <wx/dataobj.h>
2636
2637 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2638 size_t count = self->GetFormatCount(dir);
2639 wxDataFormat* formats = new wxDataFormat[count];
2640 self->GetAllFormats(formats, dir);
2641
2642 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2643 PyObject* list = PyList_New(count);
2644 for (size_t i=0; i<count; i++) {
2645 wxDataFormat* format = new wxDataFormat(formats[i]);
2646 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2647 PyList_Append(list, obj);
2648 Py_DECREF(obj);
2649 }
2650 wxPyEndBlockThreads(blocked);
2651 delete [] formats;
2652 return list;
2653 }
2654 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2655 PyObject* rval = NULL;
2656 size_t size = self->GetDataSize(format);
2657 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2658 if (size) {
2659 char* buf = new char[size];
2660 if (self->GetDataHere(format, buf))
2661 rval = PyString_FromStringAndSize(buf, size);
2662 delete [] buf;
2663 }
2664 if (! rval) {
2665 rval = Py_None;
2666 Py_INCREF(rval);
2667 }
2668 wxPyEndBlockThreads(blocked);
2669 return rval;
2670 }
2671 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2672 bool rval;
2673 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2674 if (PyString_Check(data)) {
2675 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2676 }
2677 else {
2678 // raise a TypeError if not a string
2679 PyErr_SetString(PyExc_TypeError, "String expected.");
2680 rval = false;
2681 }
2682 wxPyEndBlockThreads(blocked);
2683 return rval;
2684 }
2685 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2686 PyObject* rval = NULL;
2687 size_t size = self->GetDataSize();
2688 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2689 if (size) {
2690 char* buf = new char[size];
2691 if (self->GetDataHere(buf))
2692 rval = PyString_FromStringAndSize(buf, size);
2693 delete [] buf;
2694 }
2695 if (! rval) {
2696 rval = Py_None;
2697 Py_INCREF(rval);
2698 }
2699 wxPyEndBlockThreads(blocked);
2700 return rval;
2701 }
2702 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2703 bool rval;
2704 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2705 if (PyString_Check(data)) {
2706 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2707 }
2708 else {
2709 // raise a TypeError if not a string
2710 PyErr_SetString(PyExc_TypeError, "String expected.");
2711 rval = false;
2712 }
2713 wxPyEndBlockThreads(blocked);
2714 return rval;
2715 }
2716 // Create a new class for wxPython to use
2717 class wxPyDataObjectSimple : public wxDataObjectSimple {
2718 public:
2719 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2720 : wxDataObjectSimple(format) {}
2721
2722 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2723 bool GetDataHere(void *buf) const;
2724 bool SetData(size_t len, const void *buf) const;
2725 PYPRIVATE;
2726 };
2727
2728 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2729
2730 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2731 // We need to get the data for this object and write it to buf. I think
2732 // the best way to do this for wxPython is to have the Python method
2733 // return either a string or None and then act appropriately with the
2734 // C++ version.
2735
2736 bool rval = false;
2737 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2738 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2739 PyObject* ro;
2740 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2741 if (ro) {
2742 rval = (ro != Py_None && PyString_Check(ro));
2743 if (rval)
2744 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2745 Py_DECREF(ro);
2746 }
2747 }
2748 wxPyEndBlockThreads(blocked);
2749 return rval;
2750 }
2751
2752 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2753 // For this one we simply need to make a string from buf and len
2754 // and send it to the Python method.
2755 bool rval = false;
2756 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2757 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2758 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2759 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2760 Py_DECREF(data);
2761 }
2762 wxPyEndBlockThreads(blocked);
2763 return rval;
2764 }
2765
2766 // Create a new class for wxPython to use
2767 class wxPyTextDataObject : public wxTextDataObject {
2768 public:
2769 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2770 : wxTextDataObject(text) {}
2771
2772 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2773 DEC_PYCALLBACK_STRING__const(GetText);
2774 DEC_PYCALLBACK__STRING(SetText);
2775 PYPRIVATE;
2776 };
2777
2778 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2779 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2780 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2781
2782
2783 // Create a new class for wxPython to use
2784 class wxPyBitmapDataObject : public wxBitmapDataObject {
2785 public:
2786 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2787 : wxBitmapDataObject(bitmap) {}
2788
2789 wxBitmap GetBitmap() const;
2790 void SetBitmap(const wxBitmap& bitmap);
2791 PYPRIVATE;
2792 };
2793
2794 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2795 wxBitmap* rval = &wxNullBitmap;
2796 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2797 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2798 PyObject* ro;
2799 wxBitmap* ptr;
2800 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2801 if (ro) {
2802 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2803 rval = ptr;
2804 Py_DECREF(ro);
2805 }
2806 }
2807 wxPyEndBlockThreads(blocked);
2808 return *rval;
2809 }
2810
2811 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2813 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2814 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2815 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2816 Py_DECREF(bo);
2817 }
2818 wxPyEndBlockThreads(blocked);
2819 }
2820
2821 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2822 return new wxCustomDataObject(wxDataFormat(formatName));
2823 }
2824 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2825 bool rval;
2826 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2827 if (PyString_Check(data)) {
2828 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2829 }
2830 else {
2831 // raise a TypeError if not a string
2832 PyErr_SetString(PyExc_TypeError, "String expected.");
2833 rval = false;
2834 }
2835 wxPyEndBlockThreads(blocked);
2836 return rval;
2837 }
2838 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2839 PyObject* obj;
2840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2841 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2842 wxPyEndBlockThreads(blocked);
2843 return obj;
2844 }
2845
2846 #include <wx/metafile.h>
2847
2848
2849 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2850
2851
2852 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2853 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2854 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2855 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2856 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2857
2858
2859 class wxPyTextDropTarget : public wxTextDropTarget {
2860 public:
2861 wxPyTextDropTarget() {}
2862
2863 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2864
2865 DEC_PYCALLBACK__(OnLeave);
2866 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2867 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2868 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2869 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2870
2871 PYPRIVATE;
2872 };
2873
2874 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2875 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2876 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2877 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2878 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2879 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2880
2881
2882
2883 class wxPyFileDropTarget : public wxFileDropTarget {
2884 public:
2885 wxPyFileDropTarget() {}
2886
2887 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2888
2889 DEC_PYCALLBACK__(OnLeave);
2890 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2891 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2892 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2893 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2894
2895 PYPRIVATE;
2896 };
2897
2898 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2899 const wxArrayString& filenames) {
2900 bool rval = false;
2901 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2902 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2903 PyObject* list = wxArrayString2PyList_helper(filenames);
2904 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2905 Py_DECREF(list);
2906 }
2907 wxPyEndBlockThreads(blocked);
2908 return rval;
2909 }
2910
2911
2912
2913 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2914 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2915 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2916 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2917 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2918
2919
2920
2921
2922 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2923
2924 #include <wx/display.h>
2925
2926 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2927 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2928
2929 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2930 #if !wxUSE_DISPLAY
2931 #include <wx/dynarray.h>
2932 #include <wx/vidmode.h>
2933
2934 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2935 #include "wx/arrimpl.cpp"
2936 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2937 const wxVideoMode wxDefaultVideoMode;
2938
2939 class wxDisplay
2940 {
2941 public:
2942 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2943 ~wxDisplay() {}
2944
2945 static size_t GetCount()
2946 { wxPyRaiseNotImplemented(); return 0; }
2947
2948 static int GetFromPoint(const wxPoint& pt)
2949 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2950 static int GetFromWindow(wxWindow *window)
2951 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2952
2953 virtual bool IsOk() const { return false; }
2954 virtual wxRect GetGeometry() const { wxRect r; return r; }
2955 virtual wxString GetName() const { return wxEmptyString; }
2956 bool IsPrimary() const { return false; }
2957
2958 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2959 { wxArrayVideoModes a; return a; }
2960
2961 virtual wxVideoMode GetCurrentMode() const
2962 { return wxDefaultVideoMode; }
2963
2964 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2965 { return false; }
2966
2967 void ResetMode() {}
2968 };
2969 #endif
2970
2971 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2972 PyObject* pyList = NULL;
2973 wxArrayVideoModes arr = self->GetModes(mode);
2974 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2975 pyList = PyList_New(0);
2976 for (int i=0; i < arr.GetCount(); i++) {
2977 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2978 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2979 PyList_Append(pyList, pyObj);
2980 Py_DECREF(pyObj);
2981 }
2982 wxPyEndBlockThreads(blocked);
2983 return pyList;
2984 }
2985
2986 #include <wx/stdpaths.h>
2987
2988 static wxStandardPaths *StandardPaths_Get(){
2989 return (wxStandardPaths*) &wxStandardPaths::Get();
2990 }
2991 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2992 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2993 #ifdef __cplusplus
2994 extern "C" {
2995 #endif
2996 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2997 PyObject *resultobj;
2998 wxSystemColour arg1 ;
2999 wxColour result;
3000 PyObject * obj0 = 0 ;
3001 char *kwnames[] = {
3002 (char *) "index", NULL
3003 };
3004
3005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3006 {
3007 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3008 if (SWIG_arg_fail(1)) SWIG_fail;
3009 }
3010 {
3011 if (!wxPyCheckForApp()) SWIG_fail;
3012 PyThreadState* __tstate = wxPyBeginAllowThreads();
3013 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3014
3015 wxPyEndAllowThreads(__tstate);
3016 if (PyErr_Occurred()) SWIG_fail;
3017 }
3018 {
3019 wxColour * resultptr;
3020 resultptr = new wxColour((wxColour &)(result));
3021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3022 }
3023 return resultobj;
3024 fail:
3025 return NULL;
3026 }
3027
3028
3029 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3030 PyObject *resultobj;
3031 wxSystemFont arg1 ;
3032 wxFont result;
3033 PyObject * obj0 = 0 ;
3034 char *kwnames[] = {
3035 (char *) "index", NULL
3036 };
3037
3038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3039 {
3040 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3041 if (SWIG_arg_fail(1)) SWIG_fail;
3042 }
3043 {
3044 if (!wxPyCheckForApp()) SWIG_fail;
3045 PyThreadState* __tstate = wxPyBeginAllowThreads();
3046 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3047
3048 wxPyEndAllowThreads(__tstate);
3049 if (PyErr_Occurred()) SWIG_fail;
3050 }
3051 {
3052 wxFont * resultptr;
3053 resultptr = new wxFont((wxFont &)(result));
3054 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3055 }
3056 return resultobj;
3057 fail:
3058 return NULL;
3059 }
3060
3061
3062 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3063 PyObject *resultobj;
3064 wxSystemMetric arg1 ;
3065 wxWindow *arg2 = (wxWindow *) NULL ;
3066 int result;
3067 PyObject * obj0 = 0 ;
3068 PyObject * obj1 = 0 ;
3069 char *kwnames[] = {
3070 (char *) "index",(char *) "win", NULL
3071 };
3072
3073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3074 {
3075 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3076 if (SWIG_arg_fail(1)) SWIG_fail;
3077 }
3078 if (obj1) {
3079 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3080 if (SWIG_arg_fail(2)) SWIG_fail;
3081 }
3082 {
3083 if (!wxPyCheckForApp()) SWIG_fail;
3084 PyThreadState* __tstate = wxPyBeginAllowThreads();
3085 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3086
3087 wxPyEndAllowThreads(__tstate);
3088 if (PyErr_Occurred()) SWIG_fail;
3089 }
3090 {
3091 resultobj = SWIG_From_int((int)(result));
3092 }
3093 return resultobj;
3094 fail:
3095 return NULL;
3096 }
3097
3098
3099 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3100 PyObject *resultobj;
3101 wxSystemFeature arg1 ;
3102 bool result;
3103 PyObject * obj0 = 0 ;
3104 char *kwnames[] = {
3105 (char *) "index", NULL
3106 };
3107
3108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3109 {
3110 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3111 if (SWIG_arg_fail(1)) SWIG_fail;
3112 }
3113 {
3114 if (!wxPyCheckForApp()) SWIG_fail;
3115 PyThreadState* __tstate = wxPyBeginAllowThreads();
3116 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3117
3118 wxPyEndAllowThreads(__tstate);
3119 if (PyErr_Occurred()) SWIG_fail;
3120 }
3121 {
3122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3123 }
3124 return resultobj;
3125 fail:
3126 return NULL;
3127 }
3128
3129
3130 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3131 PyObject *resultobj;
3132 wxSystemScreenType result;
3133 char *kwnames[] = {
3134 NULL
3135 };
3136
3137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3138 {
3139 if (!wxPyCheckForApp()) SWIG_fail;
3140 PyThreadState* __tstate = wxPyBeginAllowThreads();
3141 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3142
3143 wxPyEndAllowThreads(__tstate);
3144 if (PyErr_Occurred()) SWIG_fail;
3145 }
3146 resultobj = SWIG_From_int((result));
3147 return resultobj;
3148 fail:
3149 return NULL;
3150 }
3151
3152
3153 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3154 PyObject *resultobj;
3155 wxSystemScreenType arg1 ;
3156 PyObject * obj0 = 0 ;
3157 char *kwnames[] = {
3158 (char *) "screen", NULL
3159 };
3160
3161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3162 {
3163 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3164 if (SWIG_arg_fail(1)) SWIG_fail;
3165 }
3166 {
3167 if (!wxPyCheckForApp()) SWIG_fail;
3168 PyThreadState* __tstate = wxPyBeginAllowThreads();
3169 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3170
3171 wxPyEndAllowThreads(__tstate);
3172 if (PyErr_Occurred()) SWIG_fail;
3173 }
3174 Py_INCREF(Py_None); resultobj = Py_None;
3175 return resultobj;
3176 fail:
3177 return NULL;
3178 }
3179
3180
3181 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3182 PyObject *obj;
3183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3184 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3185 Py_INCREF(obj);
3186 return Py_BuildValue((char *)"");
3187 }
3188 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3189 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3190 return 1;
3191 }
3192
3193
3194 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3195 PyObject *pyobj;
3196
3197 {
3198 #if wxUSE_UNICODE
3199 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3200 #else
3201 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3202 #endif
3203 }
3204 return pyobj;
3205 }
3206
3207
3208 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3209 PyObject *resultobj;
3210 wxSystemOptions *result;
3211 char *kwnames[] = {
3212 NULL
3213 };
3214
3215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3216 {
3217 PyThreadState* __tstate = wxPyBeginAllowThreads();
3218 result = (wxSystemOptions *)new wxSystemOptions();
3219
3220 wxPyEndAllowThreads(__tstate);
3221 if (PyErr_Occurred()) SWIG_fail;
3222 }
3223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3224 return resultobj;
3225 fail:
3226 return NULL;
3227 }
3228
3229
3230 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3231 PyObject *resultobj;
3232 wxString *arg1 = 0 ;
3233 wxString *arg2 = 0 ;
3234 bool temp1 = false ;
3235 bool temp2 = false ;
3236 PyObject * obj0 = 0 ;
3237 PyObject * obj1 = 0 ;
3238 char *kwnames[] = {
3239 (char *) "name",(char *) "value", NULL
3240 };
3241
3242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3243 {
3244 arg1 = wxString_in_helper(obj0);
3245 if (arg1 == NULL) SWIG_fail;
3246 temp1 = true;
3247 }
3248 {
3249 arg2 = wxString_in_helper(obj1);
3250 if (arg2 == NULL) SWIG_fail;
3251 temp2 = true;
3252 }
3253 {
3254 PyThreadState* __tstate = wxPyBeginAllowThreads();
3255 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3256
3257 wxPyEndAllowThreads(__tstate);
3258 if (PyErr_Occurred()) SWIG_fail;
3259 }
3260 Py_INCREF(Py_None); resultobj = Py_None;
3261 {
3262 if (temp1)
3263 delete arg1;
3264 }
3265 {
3266 if (temp2)
3267 delete arg2;
3268 }
3269 return resultobj;
3270 fail:
3271 {
3272 if (temp1)
3273 delete arg1;
3274 }
3275 {
3276 if (temp2)
3277 delete arg2;
3278 }
3279 return NULL;
3280 }
3281
3282
3283 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3284 PyObject *resultobj;
3285 wxString *arg1 = 0 ;
3286 int arg2 ;
3287 bool temp1 = false ;
3288 PyObject * obj0 = 0 ;
3289 PyObject * obj1 = 0 ;
3290 char *kwnames[] = {
3291 (char *) "name",(char *) "value", NULL
3292 };
3293
3294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3295 {
3296 arg1 = wxString_in_helper(obj0);
3297 if (arg1 == NULL) SWIG_fail;
3298 temp1 = true;
3299 }
3300 {
3301 arg2 = (int)(SWIG_As_int(obj1));
3302 if (SWIG_arg_fail(2)) SWIG_fail;
3303 }
3304 {
3305 PyThreadState* __tstate = wxPyBeginAllowThreads();
3306 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3307
3308 wxPyEndAllowThreads(__tstate);
3309 if (PyErr_Occurred()) SWIG_fail;
3310 }
3311 Py_INCREF(Py_None); resultobj = Py_None;
3312 {
3313 if (temp1)
3314 delete arg1;
3315 }
3316 return resultobj;
3317 fail:
3318 {
3319 if (temp1)
3320 delete arg1;
3321 }
3322 return NULL;
3323 }
3324
3325
3326 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3327 PyObject *resultobj;
3328 wxString *arg1 = 0 ;
3329 wxString result;
3330 bool temp1 = false ;
3331 PyObject * obj0 = 0 ;
3332 char *kwnames[] = {
3333 (char *) "name", NULL
3334 };
3335
3336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3337 {
3338 arg1 = wxString_in_helper(obj0);
3339 if (arg1 == NULL) SWIG_fail;
3340 temp1 = true;
3341 }
3342 {
3343 PyThreadState* __tstate = wxPyBeginAllowThreads();
3344 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3345
3346 wxPyEndAllowThreads(__tstate);
3347 if (PyErr_Occurred()) SWIG_fail;
3348 }
3349 {
3350 #if wxUSE_UNICODE
3351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3352 #else
3353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3354 #endif
3355 }
3356 {
3357 if (temp1)
3358 delete arg1;
3359 }
3360 return resultobj;
3361 fail:
3362 {
3363 if (temp1)
3364 delete arg1;
3365 }
3366 return NULL;
3367 }
3368
3369
3370 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3371 PyObject *resultobj;
3372 wxString *arg1 = 0 ;
3373 int result;
3374 bool temp1 = false ;
3375 PyObject * obj0 = 0 ;
3376 char *kwnames[] = {
3377 (char *) "name", NULL
3378 };
3379
3380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3381 {
3382 arg1 = wxString_in_helper(obj0);
3383 if (arg1 == NULL) SWIG_fail;
3384 temp1 = true;
3385 }
3386 {
3387 PyThreadState* __tstate = wxPyBeginAllowThreads();
3388 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3389
3390 wxPyEndAllowThreads(__tstate);
3391 if (PyErr_Occurred()) SWIG_fail;
3392 }
3393 {
3394 resultobj = SWIG_From_int((int)(result));
3395 }
3396 {
3397 if (temp1)
3398 delete arg1;
3399 }
3400 return resultobj;
3401 fail:
3402 {
3403 if (temp1)
3404 delete arg1;
3405 }
3406 return NULL;
3407 }
3408
3409
3410 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3411 PyObject *resultobj;
3412 wxString *arg1 = 0 ;
3413 bool result;
3414 bool temp1 = false ;
3415 PyObject * obj0 = 0 ;
3416 char *kwnames[] = {
3417 (char *) "name", NULL
3418 };
3419
3420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3421 {
3422 arg1 = wxString_in_helper(obj0);
3423 if (arg1 == NULL) SWIG_fail;
3424 temp1 = true;
3425 }
3426 {
3427 PyThreadState* __tstate = wxPyBeginAllowThreads();
3428 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3429
3430 wxPyEndAllowThreads(__tstate);
3431 if (PyErr_Occurred()) SWIG_fail;
3432 }
3433 {
3434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3435 }
3436 {
3437 if (temp1)
3438 delete arg1;
3439 }
3440 return resultobj;
3441 fail:
3442 {
3443 if (temp1)
3444 delete arg1;
3445 }
3446 return NULL;
3447 }
3448
3449
3450 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3451 PyObject *resultobj;
3452 wxString *arg1 = 0 ;
3453 bool result;
3454 bool temp1 = false ;
3455 PyObject * obj0 = 0 ;
3456 char *kwnames[] = {
3457 (char *) "name", NULL
3458 };
3459
3460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3461 {
3462 arg1 = wxString_in_helper(obj0);
3463 if (arg1 == NULL) SWIG_fail;
3464 temp1 = true;
3465 }
3466 {
3467 PyThreadState* __tstate = wxPyBeginAllowThreads();
3468 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3469
3470 wxPyEndAllowThreads(__tstate);
3471 if (PyErr_Occurred()) SWIG_fail;
3472 }
3473 {
3474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3475 }
3476 {
3477 if (temp1)
3478 delete arg1;
3479 }
3480 return resultobj;
3481 fail:
3482 {
3483 if (temp1)
3484 delete arg1;
3485 }
3486 return NULL;
3487 }
3488
3489
3490 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3491 PyObject *obj;
3492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3493 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3494 Py_INCREF(obj);
3495 return Py_BuildValue((char *)"");
3496 }
3497 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3498 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3499 return 1;
3500 }
3501
3502
3503 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3504 PyObject *pyobj;
3505
3506 {
3507 #if wxUSE_UNICODE
3508 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3509 #else
3510 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3511 #endif
3512 }
3513 return pyobj;
3514 }
3515
3516
3517 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3518 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3519 return 1;
3520 }
3521
3522
3523 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3524 PyObject *pyobj;
3525
3526 {
3527 #if wxUSE_UNICODE
3528 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3529 #else
3530 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3531 #endif
3532 }
3533 return pyobj;
3534 }
3535
3536
3537 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3538 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3539 return 1;
3540 }
3541
3542
3543 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3544 PyObject *pyobj;
3545
3546 {
3547 #if wxUSE_UNICODE
3548 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3549 #else
3550 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3551 #endif
3552 }
3553 return pyobj;
3554 }
3555
3556
3557 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 long result;
3560 char *kwnames[] = {
3561 NULL
3562 };
3563
3564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3565 {
3566 PyThreadState* __tstate = wxPyBeginAllowThreads();
3567 result = (long)wxNewId();
3568
3569 wxPyEndAllowThreads(__tstate);
3570 if (PyErr_Occurred()) SWIG_fail;
3571 }
3572 {
3573 resultobj = SWIG_From_long((long)(result));
3574 }
3575 return resultobj;
3576 fail:
3577 return NULL;
3578 }
3579
3580
3581 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3582 PyObject *resultobj;
3583 long arg1 ;
3584 PyObject * obj0 = 0 ;
3585 char *kwnames[] = {
3586 (char *) "id", NULL
3587 };
3588
3589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3590 {
3591 arg1 = (long)(SWIG_As_long(obj0));
3592 if (SWIG_arg_fail(1)) SWIG_fail;
3593 }
3594 {
3595 PyThreadState* __tstate = wxPyBeginAllowThreads();
3596 wxRegisterId(arg1);
3597
3598 wxPyEndAllowThreads(__tstate);
3599 if (PyErr_Occurred()) SWIG_fail;
3600 }
3601 Py_INCREF(Py_None); resultobj = Py_None;
3602 return resultobj;
3603 fail:
3604 return NULL;
3605 }
3606
3607
3608 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3609 PyObject *resultobj;
3610 long result;
3611 char *kwnames[] = {
3612 NULL
3613 };
3614
3615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3616 {
3617 PyThreadState* __tstate = wxPyBeginAllowThreads();
3618 result = (long)wxGetCurrentId();
3619
3620 wxPyEndAllowThreads(__tstate);
3621 if (PyErr_Occurred()) SWIG_fail;
3622 }
3623 {
3624 resultobj = SWIG_From_long((long)(result));
3625 }
3626 return resultobj;
3627 fail:
3628 return NULL;
3629 }
3630
3631
3632 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3633 PyObject *resultobj;
3634 int arg1 ;
3635 bool result;
3636 PyObject * obj0 = 0 ;
3637 char *kwnames[] = {
3638 (char *) "id", NULL
3639 };
3640
3641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3642 {
3643 arg1 = (int)(SWIG_As_int(obj0));
3644 if (SWIG_arg_fail(1)) SWIG_fail;
3645 }
3646 {
3647 PyThreadState* __tstate = wxPyBeginAllowThreads();
3648 result = (bool)wxIsStockID(arg1);
3649
3650 wxPyEndAllowThreads(__tstate);
3651 if (PyErr_Occurred()) SWIG_fail;
3652 }
3653 {
3654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3655 }
3656 return resultobj;
3657 fail:
3658 return NULL;
3659 }
3660
3661
3662 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3663 PyObject *resultobj;
3664 int arg1 ;
3665 wxString *arg2 = 0 ;
3666 bool result;
3667 bool temp2 = false ;
3668 PyObject * obj0 = 0 ;
3669 PyObject * obj1 = 0 ;
3670 char *kwnames[] = {
3671 (char *) "id",(char *) "label", NULL
3672 };
3673
3674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3675 {
3676 arg1 = (int)(SWIG_As_int(obj0));
3677 if (SWIG_arg_fail(1)) SWIG_fail;
3678 }
3679 {
3680 arg2 = wxString_in_helper(obj1);
3681 if (arg2 == NULL) SWIG_fail;
3682 temp2 = true;
3683 }
3684 {
3685 PyThreadState* __tstate = wxPyBeginAllowThreads();
3686 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3687
3688 wxPyEndAllowThreads(__tstate);
3689 if (PyErr_Occurred()) SWIG_fail;
3690 }
3691 {
3692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3693 }
3694 {
3695 if (temp2)
3696 delete arg2;
3697 }
3698 return resultobj;
3699 fail:
3700 {
3701 if (temp2)
3702 delete arg2;
3703 }
3704 return NULL;
3705 }
3706
3707
3708 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3709 PyObject *resultobj;
3710 int arg1 ;
3711 bool arg2 = (bool) true ;
3712 wxString arg3 = (wxString) wxPyEmptyString ;
3713 wxString result;
3714 PyObject * obj0 = 0 ;
3715 PyObject * obj1 = 0 ;
3716 PyObject * obj2 = 0 ;
3717 char *kwnames[] = {
3718 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3719 };
3720
3721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3722 {
3723 arg1 = (int)(SWIG_As_int(obj0));
3724 if (SWIG_arg_fail(1)) SWIG_fail;
3725 }
3726 if (obj1) {
3727 {
3728 arg2 = (bool)(SWIG_As_bool(obj1));
3729 if (SWIG_arg_fail(2)) SWIG_fail;
3730 }
3731 }
3732 if (obj2) {
3733 {
3734 wxString* sptr = wxString_in_helper(obj2);
3735 if (sptr == NULL) SWIG_fail;
3736 arg3 = *sptr;
3737 delete sptr;
3738 }
3739 }
3740 {
3741 PyThreadState* __tstate = wxPyBeginAllowThreads();
3742 result = wxGetStockLabel(arg1,arg2,arg3);
3743
3744 wxPyEndAllowThreads(__tstate);
3745 if (PyErr_Occurred()) SWIG_fail;
3746 }
3747 {
3748 #if wxUSE_UNICODE
3749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3750 #else
3751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3752 #endif
3753 }
3754 return resultobj;
3755 fail:
3756 return NULL;
3757 }
3758
3759
3760 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3761 PyObject *resultobj;
3762 char *kwnames[] = {
3763 NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3767 {
3768 if (!wxPyCheckForApp()) SWIG_fail;
3769 PyThreadState* __tstate = wxPyBeginAllowThreads();
3770 wxBell();
3771
3772 wxPyEndAllowThreads(__tstate);
3773 if (PyErr_Occurred()) SWIG_fail;
3774 }
3775 Py_INCREF(Py_None); resultobj = Py_None;
3776 return resultobj;
3777 fail:
3778 return NULL;
3779 }
3780
3781
3782 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3783 PyObject *resultobj;
3784 char *kwnames[] = {
3785 NULL
3786 };
3787
3788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3789 {
3790 if (!wxPyCheckForApp()) SWIG_fail;
3791 PyThreadState* __tstate = wxPyBeginAllowThreads();
3792 wxEndBusyCursor();
3793
3794 wxPyEndAllowThreads(__tstate);
3795 if (PyErr_Occurred()) SWIG_fail;
3796 }
3797 Py_INCREF(Py_None); resultobj = Py_None;
3798 return resultobj;
3799 fail:
3800 return NULL;
3801 }
3802
3803
3804 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3805 PyObject *resultobj;
3806 bool arg1 = (bool) true ;
3807 long result;
3808 PyObject * obj0 = 0 ;
3809 char *kwnames[] = {
3810 (char *) "resetTimer", NULL
3811 };
3812
3813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3814 if (obj0) {
3815 {
3816 arg1 = (bool)(SWIG_As_bool(obj0));
3817 if (SWIG_arg_fail(1)) SWIG_fail;
3818 }
3819 }
3820 {
3821 PyThreadState* __tstate = wxPyBeginAllowThreads();
3822 result = (long)wxGetElapsedTime(arg1);
3823
3824 wxPyEndAllowThreads(__tstate);
3825 if (PyErr_Occurred()) SWIG_fail;
3826 }
3827 {
3828 resultobj = SWIG_From_long((long)(result));
3829 }
3830 return resultobj;
3831 fail:
3832 return NULL;
3833 }
3834
3835
3836 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3837 PyObject *resultobj;
3838 int *arg1 = (int *) 0 ;
3839 int *arg2 = (int *) 0 ;
3840 int temp1 ;
3841 int res1 = 0 ;
3842 int temp2 ;
3843 int res2 = 0 ;
3844 char *kwnames[] = {
3845 NULL
3846 };
3847
3848 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3849 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3851 {
3852 if (!wxPyCheckForApp()) SWIG_fail;
3853 PyThreadState* __tstate = wxPyBeginAllowThreads();
3854 wxGetMousePosition(arg1,arg2);
3855
3856 wxPyEndAllowThreads(__tstate);
3857 if (PyErr_Occurred()) SWIG_fail;
3858 }
3859 Py_INCREF(Py_None); resultobj = Py_None;
3860 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3861 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3862 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3863 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3864 return resultobj;
3865 fail:
3866 return NULL;
3867 }
3868
3869
3870 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3871 PyObject *resultobj;
3872 bool result;
3873 char *kwnames[] = {
3874 NULL
3875 };
3876
3877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3878 {
3879 PyThreadState* __tstate = wxPyBeginAllowThreads();
3880 result = (bool)wxIsBusy();
3881
3882 wxPyEndAllowThreads(__tstate);
3883 if (PyErr_Occurred()) SWIG_fail;
3884 }
3885 {
3886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3887 }
3888 return resultobj;
3889 fail:
3890 return NULL;
3891 }
3892
3893
3894 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3895 PyObject *resultobj;
3896 wxString result;
3897 char *kwnames[] = {
3898 NULL
3899 };
3900
3901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3902 {
3903 PyThreadState* __tstate = wxPyBeginAllowThreads();
3904 result = wxNow();
3905
3906 wxPyEndAllowThreads(__tstate);
3907 if (PyErr_Occurred()) SWIG_fail;
3908 }
3909 {
3910 #if wxUSE_UNICODE
3911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3912 #else
3913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3914 #endif
3915 }
3916 return resultobj;
3917 fail:
3918 return NULL;
3919 }
3920
3921
3922 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3923 PyObject *resultobj;
3924 wxString const &arg1_defvalue = wxPyEmptyString ;
3925 wxString *arg1 = (wxString *) &arg1_defvalue ;
3926 bool result;
3927 bool temp1 = false ;
3928 PyObject * obj0 = 0 ;
3929 char *kwnames[] = {
3930 (char *) "command", NULL
3931 };
3932
3933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3934 if (obj0) {
3935 {
3936 arg1 = wxString_in_helper(obj0);
3937 if (arg1 == NULL) SWIG_fail;
3938 temp1 = true;
3939 }
3940 }
3941 {
3942 PyThreadState* __tstate = wxPyBeginAllowThreads();
3943 result = (bool)wxShell((wxString const &)*arg1);
3944
3945 wxPyEndAllowThreads(__tstate);
3946 if (PyErr_Occurred()) SWIG_fail;
3947 }
3948 {
3949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3950 }
3951 {
3952 if (temp1)
3953 delete arg1;
3954 }
3955 return resultobj;
3956 fail:
3957 {
3958 if (temp1)
3959 delete arg1;
3960 }
3961 return NULL;
3962 }
3963
3964
3965 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3966 PyObject *resultobj;
3967 char *kwnames[] = {
3968 NULL
3969 };
3970
3971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3972 {
3973 PyThreadState* __tstate = wxPyBeginAllowThreads();
3974 wxStartTimer();
3975
3976 wxPyEndAllowThreads(__tstate);
3977 if (PyErr_Occurred()) SWIG_fail;
3978 }
3979 Py_INCREF(Py_None); resultobj = Py_None;
3980 return resultobj;
3981 fail:
3982 return NULL;
3983 }
3984
3985
3986 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3987 PyObject *resultobj;
3988 int *arg1 = (int *) 0 ;
3989 int *arg2 = (int *) 0 ;
3990 int result;
3991 int temp1 ;
3992 int res1 = 0 ;
3993 int temp2 ;
3994 int res2 = 0 ;
3995 char *kwnames[] = {
3996 NULL
3997 };
3998
3999 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4000 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4002 {
4003 PyThreadState* __tstate = wxPyBeginAllowThreads();
4004 result = (int)wxGetOsVersion(arg1,arg2);
4005
4006 wxPyEndAllowThreads(__tstate);
4007 if (PyErr_Occurred()) SWIG_fail;
4008 }
4009 {
4010 resultobj = SWIG_From_int((int)(result));
4011 }
4012 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4013 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4014 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4015 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4016 return resultobj;
4017 fail:
4018 return NULL;
4019 }
4020
4021
4022 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4023 PyObject *resultobj;
4024 wxString result;
4025 char *kwnames[] = {
4026 NULL
4027 };
4028
4029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4030 {
4031 PyThreadState* __tstate = wxPyBeginAllowThreads();
4032 result = wxGetOsDescription();
4033
4034 wxPyEndAllowThreads(__tstate);
4035 if (PyErr_Occurred()) SWIG_fail;
4036 }
4037 {
4038 #if wxUSE_UNICODE
4039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4040 #else
4041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4042 #endif
4043 }
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 long result;
4053 char *kwnames[] = {
4054 NULL
4055 };
4056
4057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4058 {
4059 PyThreadState* __tstate = wxPyBeginAllowThreads();
4060 result = (long)wxGetFreeMemory();
4061
4062 wxPyEndAllowThreads(__tstate);
4063 if (PyErr_Occurred()) SWIG_fail;
4064 }
4065 {
4066 resultobj = SWIG_From_long((long)(result));
4067 }
4068 return resultobj;
4069 fail:
4070 return NULL;
4071 }
4072
4073
4074 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4075 PyObject *resultobj;
4076 wxShutdownFlags arg1 ;
4077 bool result;
4078 PyObject * obj0 = 0 ;
4079 char *kwnames[] = {
4080 (char *) "wFlags", NULL
4081 };
4082
4083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4084 {
4085 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4086 if (SWIG_arg_fail(1)) SWIG_fail;
4087 }
4088 {
4089 if (!wxPyCheckForApp()) SWIG_fail;
4090 PyThreadState* __tstate = wxPyBeginAllowThreads();
4091 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4092
4093 wxPyEndAllowThreads(__tstate);
4094 if (PyErr_Occurred()) SWIG_fail;
4095 }
4096 {
4097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4098 }
4099 return resultobj;
4100 fail:
4101 return NULL;
4102 }
4103
4104
4105 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4106 PyObject *resultobj;
4107 int arg1 ;
4108 PyObject * obj0 = 0 ;
4109 char *kwnames[] = {
4110 (char *) "secs", NULL
4111 };
4112
4113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4114 {
4115 arg1 = (int)(SWIG_As_int(obj0));
4116 if (SWIG_arg_fail(1)) SWIG_fail;
4117 }
4118 {
4119 PyThreadState* __tstate = wxPyBeginAllowThreads();
4120 wxSleep(arg1);
4121
4122 wxPyEndAllowThreads(__tstate);
4123 if (PyErr_Occurred()) SWIG_fail;
4124 }
4125 Py_INCREF(Py_None); resultobj = Py_None;
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4133 PyObject *resultobj;
4134 unsigned long arg1 ;
4135 PyObject * obj0 = 0 ;
4136 char *kwnames[] = {
4137 (char *) "milliseconds", NULL
4138 };
4139
4140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4141 {
4142 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4143 if (SWIG_arg_fail(1)) SWIG_fail;
4144 }
4145 {
4146 PyThreadState* __tstate = wxPyBeginAllowThreads();
4147 wxMilliSleep(arg1);
4148
4149 wxPyEndAllowThreads(__tstate);
4150 if (PyErr_Occurred()) SWIG_fail;
4151 }
4152 Py_INCREF(Py_None); resultobj = Py_None;
4153 return resultobj;
4154 fail:
4155 return NULL;
4156 }
4157
4158
4159 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4160 PyObject *resultobj;
4161 unsigned long arg1 ;
4162 PyObject * obj0 = 0 ;
4163 char *kwnames[] = {
4164 (char *) "microseconds", NULL
4165 };
4166
4167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4168 {
4169 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4170 if (SWIG_arg_fail(1)) SWIG_fail;
4171 }
4172 {
4173 PyThreadState* __tstate = wxPyBeginAllowThreads();
4174 wxMicroSleep(arg1);
4175
4176 wxPyEndAllowThreads(__tstate);
4177 if (PyErr_Occurred()) SWIG_fail;
4178 }
4179 Py_INCREF(Py_None); resultobj = Py_None;
4180 return resultobj;
4181 fail:
4182 return NULL;
4183 }
4184
4185
4186 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4187 PyObject *resultobj;
4188 bool arg1 ;
4189 PyObject * obj0 = 0 ;
4190 char *kwnames[] = {
4191 (char *) "enable", NULL
4192 };
4193
4194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4195 {
4196 arg1 = (bool)(SWIG_As_bool(obj0));
4197 if (SWIG_arg_fail(1)) SWIG_fail;
4198 }
4199 {
4200 PyThreadState* __tstate = wxPyBeginAllowThreads();
4201 wxEnableTopLevelWindows(arg1);
4202
4203 wxPyEndAllowThreads(__tstate);
4204 if (PyErr_Occurred()) SWIG_fail;
4205 }
4206 Py_INCREF(Py_None); resultobj = Py_None;
4207 return resultobj;
4208 fail:
4209 return NULL;
4210 }
4211
4212
4213 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4214 PyObject *resultobj;
4215 wxString *arg1 = 0 ;
4216 wxString result;
4217 bool temp1 = false ;
4218 PyObject * obj0 = 0 ;
4219 char *kwnames[] = {
4220 (char *) "in", NULL
4221 };
4222
4223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4224 {
4225 arg1 = wxString_in_helper(obj0);
4226 if (arg1 == NULL) SWIG_fail;
4227 temp1 = true;
4228 }
4229 {
4230 PyThreadState* __tstate = wxPyBeginAllowThreads();
4231 result = wxStripMenuCodes((wxString const &)*arg1);
4232
4233 wxPyEndAllowThreads(__tstate);
4234 if (PyErr_Occurred()) SWIG_fail;
4235 }
4236 {
4237 #if wxUSE_UNICODE
4238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4239 #else
4240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4241 #endif
4242 }
4243 {
4244 if (temp1)
4245 delete arg1;
4246 }
4247 return resultobj;
4248 fail:
4249 {
4250 if (temp1)
4251 delete arg1;
4252 }
4253 return NULL;
4254 }
4255
4256
4257 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4258 PyObject *resultobj;
4259 wxString result;
4260 char *kwnames[] = {
4261 NULL
4262 };
4263
4264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4265 {
4266 PyThreadState* __tstate = wxPyBeginAllowThreads();
4267 result = wxGetEmailAddress();
4268
4269 wxPyEndAllowThreads(__tstate);
4270 if (PyErr_Occurred()) SWIG_fail;
4271 }
4272 {
4273 #if wxUSE_UNICODE
4274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4275 #else
4276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4277 #endif
4278 }
4279 return resultobj;
4280 fail:
4281 return NULL;
4282 }
4283
4284
4285 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4286 PyObject *resultobj;
4287 wxString result;
4288 char *kwnames[] = {
4289 NULL
4290 };
4291
4292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4293 {
4294 PyThreadState* __tstate = wxPyBeginAllowThreads();
4295 result = wxGetHostName();
4296
4297 wxPyEndAllowThreads(__tstate);
4298 if (PyErr_Occurred()) SWIG_fail;
4299 }
4300 {
4301 #if wxUSE_UNICODE
4302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4303 #else
4304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4305 #endif
4306 }
4307 return resultobj;
4308 fail:
4309 return NULL;
4310 }
4311
4312
4313 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4314 PyObject *resultobj;
4315 wxString result;
4316 char *kwnames[] = {
4317 NULL
4318 };
4319
4320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4321 {
4322 PyThreadState* __tstate = wxPyBeginAllowThreads();
4323 result = wxGetFullHostName();
4324
4325 wxPyEndAllowThreads(__tstate);
4326 if (PyErr_Occurred()) SWIG_fail;
4327 }
4328 {
4329 #if wxUSE_UNICODE
4330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4331 #else
4332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4333 #endif
4334 }
4335 return resultobj;
4336 fail:
4337 return NULL;
4338 }
4339
4340
4341 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4342 PyObject *resultobj;
4343 wxString result;
4344 char *kwnames[] = {
4345 NULL
4346 };
4347
4348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4349 {
4350 PyThreadState* __tstate = wxPyBeginAllowThreads();
4351 result = wxGetUserId();
4352
4353 wxPyEndAllowThreads(__tstate);
4354 if (PyErr_Occurred()) SWIG_fail;
4355 }
4356 {
4357 #if wxUSE_UNICODE
4358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4359 #else
4360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4361 #endif
4362 }
4363 return resultobj;
4364 fail:
4365 return NULL;
4366 }
4367
4368
4369 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj;
4371 wxString result;
4372 char *kwnames[] = {
4373 NULL
4374 };
4375
4376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4377 {
4378 PyThreadState* __tstate = wxPyBeginAllowThreads();
4379 result = wxGetUserName();
4380
4381 wxPyEndAllowThreads(__tstate);
4382 if (PyErr_Occurred()) SWIG_fail;
4383 }
4384 {
4385 #if wxUSE_UNICODE
4386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4387 #else
4388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4389 #endif
4390 }
4391 return resultobj;
4392 fail:
4393 return NULL;
4394 }
4395
4396
4397 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4398 PyObject *resultobj;
4399 wxString result;
4400 char *kwnames[] = {
4401 NULL
4402 };
4403
4404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4405 {
4406 PyThreadState* __tstate = wxPyBeginAllowThreads();
4407 result = wxGetHomeDir();
4408
4409 wxPyEndAllowThreads(__tstate);
4410 if (PyErr_Occurred()) SWIG_fail;
4411 }
4412 {
4413 #if wxUSE_UNICODE
4414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4415 #else
4416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4417 #endif
4418 }
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4426 PyObject *resultobj;
4427 wxString const &arg1_defvalue = wxPyEmptyString ;
4428 wxString *arg1 = (wxString *) &arg1_defvalue ;
4429 wxString result;
4430 bool temp1 = false ;
4431 PyObject * obj0 = 0 ;
4432 char *kwnames[] = {
4433 (char *) "user", NULL
4434 };
4435
4436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4437 if (obj0) {
4438 {
4439 arg1 = wxString_in_helper(obj0);
4440 if (arg1 == NULL) SWIG_fail;
4441 temp1 = true;
4442 }
4443 }
4444 {
4445 PyThreadState* __tstate = wxPyBeginAllowThreads();
4446 result = wxGetUserHome((wxString const &)*arg1);
4447
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 {
4452 #if wxUSE_UNICODE
4453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4454 #else
4455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4456 #endif
4457 }
4458 {
4459 if (temp1)
4460 delete arg1;
4461 }
4462 return resultobj;
4463 fail:
4464 {
4465 if (temp1)
4466 delete arg1;
4467 }
4468 return NULL;
4469 }
4470
4471
4472 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4473 PyObject *resultobj;
4474 unsigned long result;
4475 char *kwnames[] = {
4476 NULL
4477 };
4478
4479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4480 {
4481 PyThreadState* __tstate = wxPyBeginAllowThreads();
4482 result = (unsigned long)wxGetProcessId();
4483
4484 wxPyEndAllowThreads(__tstate);
4485 if (PyErr_Occurred()) SWIG_fail;
4486 }
4487 {
4488 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4489 }
4490 return resultobj;
4491 fail:
4492 return NULL;
4493 }
4494
4495
4496 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4497 PyObject *resultobj;
4498 char *kwnames[] = {
4499 NULL
4500 };
4501
4502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4503 {
4504 PyThreadState* __tstate = wxPyBeginAllowThreads();
4505 wxTrap();
4506
4507 wxPyEndAllowThreads(__tstate);
4508 if (PyErr_Occurred()) SWIG_fail;
4509 }
4510 Py_INCREF(Py_None); resultobj = Py_None;
4511 return resultobj;
4512 fail:
4513 return NULL;
4514 }
4515
4516
4517 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4518 PyObject *resultobj;
4519 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4520 wxString *arg1 = (wxString *) &arg1_defvalue ;
4521 wxString const &arg2_defvalue = wxPyEmptyString ;
4522 wxString *arg2 = (wxString *) &arg2_defvalue ;
4523 wxString const &arg3_defvalue = wxPyEmptyString ;
4524 wxString *arg3 = (wxString *) &arg3_defvalue ;
4525 wxString const &arg4_defvalue = wxPyEmptyString ;
4526 wxString *arg4 = (wxString *) &arg4_defvalue ;
4527 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4528 wxString *arg5 = (wxString *) &arg5_defvalue ;
4529 int arg6 = (int) 0 ;
4530 wxWindow *arg7 = (wxWindow *) NULL ;
4531 int arg8 = (int) -1 ;
4532 int arg9 = (int) -1 ;
4533 wxString result;
4534 bool temp1 = false ;
4535 bool temp2 = false ;
4536 bool temp3 = false ;
4537 bool temp4 = false ;
4538 bool temp5 = false ;
4539 PyObject * obj0 = 0 ;
4540 PyObject * obj1 = 0 ;
4541 PyObject * obj2 = 0 ;
4542 PyObject * obj3 = 0 ;
4543 PyObject * obj4 = 0 ;
4544 PyObject * obj5 = 0 ;
4545 PyObject * obj6 = 0 ;
4546 PyObject * obj7 = 0 ;
4547 PyObject * obj8 = 0 ;
4548 char *kwnames[] = {
4549 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4550 };
4551
4552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4553 if (obj0) {
4554 {
4555 arg1 = wxString_in_helper(obj0);
4556 if (arg1 == NULL) SWIG_fail;
4557 temp1 = true;
4558 }
4559 }
4560 if (obj1) {
4561 {
4562 arg2 = wxString_in_helper(obj1);
4563 if (arg2 == NULL) SWIG_fail;
4564 temp2 = true;
4565 }
4566 }
4567 if (obj2) {
4568 {
4569 arg3 = wxString_in_helper(obj2);
4570 if (arg3 == NULL) SWIG_fail;
4571 temp3 = true;
4572 }
4573 }
4574 if (obj3) {
4575 {
4576 arg4 = wxString_in_helper(obj3);
4577 if (arg4 == NULL) SWIG_fail;
4578 temp4 = true;
4579 }
4580 }
4581 if (obj4) {
4582 {
4583 arg5 = wxString_in_helper(obj4);
4584 if (arg5 == NULL) SWIG_fail;
4585 temp5 = true;
4586 }
4587 }
4588 if (obj5) {
4589 {
4590 arg6 = (int)(SWIG_As_int(obj5));
4591 if (SWIG_arg_fail(6)) SWIG_fail;
4592 }
4593 }
4594 if (obj6) {
4595 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4596 if (SWIG_arg_fail(7)) SWIG_fail;
4597 }
4598 if (obj7) {
4599 {
4600 arg8 = (int)(SWIG_As_int(obj7));
4601 if (SWIG_arg_fail(8)) SWIG_fail;
4602 }
4603 }
4604 if (obj8) {
4605 {
4606 arg9 = (int)(SWIG_As_int(obj8));
4607 if (SWIG_arg_fail(9)) SWIG_fail;
4608 }
4609 }
4610 {
4611 if (!wxPyCheckForApp()) SWIG_fail;
4612 PyThreadState* __tstate = wxPyBeginAllowThreads();
4613 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4614
4615 wxPyEndAllowThreads(__tstate);
4616 if (PyErr_Occurred()) SWIG_fail;
4617 }
4618 {
4619 #if wxUSE_UNICODE
4620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4621 #else
4622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4623 #endif
4624 }
4625 {
4626 if (temp1)
4627 delete arg1;
4628 }
4629 {
4630 if (temp2)
4631 delete arg2;
4632 }
4633 {
4634 if (temp3)
4635 delete arg3;
4636 }
4637 {
4638 if (temp4)
4639 delete arg4;
4640 }
4641 {
4642 if (temp5)
4643 delete arg5;
4644 }
4645 return resultobj;
4646 fail:
4647 {
4648 if (temp1)
4649 delete arg1;
4650 }
4651 {
4652 if (temp2)
4653 delete arg2;
4654 }
4655 {
4656 if (temp3)
4657 delete arg3;
4658 }
4659 {
4660 if (temp4)
4661 delete arg4;
4662 }
4663 {
4664 if (temp5)
4665 delete arg5;
4666 }
4667 return NULL;
4668 }
4669
4670
4671 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj;
4673 wxString *arg1 = 0 ;
4674 wxString *arg2 = 0 ;
4675 wxString const &arg3_defvalue = wxPyEmptyString ;
4676 wxString *arg3 = (wxString *) &arg3_defvalue ;
4677 wxWindow *arg4 = (wxWindow *) NULL ;
4678 wxString result;
4679 bool temp1 = false ;
4680 bool temp2 = false ;
4681 bool temp3 = false ;
4682 PyObject * obj0 = 0 ;
4683 PyObject * obj1 = 0 ;
4684 PyObject * obj2 = 0 ;
4685 PyObject * obj3 = 0 ;
4686 char *kwnames[] = {
4687 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4688 };
4689
4690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4691 {
4692 arg1 = wxString_in_helper(obj0);
4693 if (arg1 == NULL) SWIG_fail;
4694 temp1 = true;
4695 }
4696 {
4697 arg2 = wxString_in_helper(obj1);
4698 if (arg2 == NULL) SWIG_fail;
4699 temp2 = true;
4700 }
4701 if (obj2) {
4702 {
4703 arg3 = wxString_in_helper(obj2);
4704 if (arg3 == NULL) SWIG_fail;
4705 temp3 = true;
4706 }
4707 }
4708 if (obj3) {
4709 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4710 if (SWIG_arg_fail(4)) SWIG_fail;
4711 }
4712 {
4713 if (!wxPyCheckForApp()) SWIG_fail;
4714 PyThreadState* __tstate = wxPyBeginAllowThreads();
4715 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4716
4717 wxPyEndAllowThreads(__tstate);
4718 if (PyErr_Occurred()) SWIG_fail;
4719 }
4720 {
4721 #if wxUSE_UNICODE
4722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4723 #else
4724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4725 #endif
4726 }
4727 {
4728 if (temp1)
4729 delete arg1;
4730 }
4731 {
4732 if (temp2)
4733 delete arg2;
4734 }
4735 {
4736 if (temp3)
4737 delete arg3;
4738 }
4739 return resultobj;
4740 fail:
4741 {
4742 if (temp1)
4743 delete arg1;
4744 }
4745 {
4746 if (temp2)
4747 delete arg2;
4748 }
4749 {
4750 if (temp3)
4751 delete arg3;
4752 }
4753 return NULL;
4754 }
4755
4756
4757 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4758 PyObject *resultobj;
4759 wxString *arg1 = 0 ;
4760 wxString *arg2 = 0 ;
4761 wxString const &arg3_defvalue = wxPyEmptyString ;
4762 wxString *arg3 = (wxString *) &arg3_defvalue ;
4763 wxWindow *arg4 = (wxWindow *) NULL ;
4764 wxString result;
4765 bool temp1 = false ;
4766 bool temp2 = false ;
4767 bool temp3 = false ;
4768 PyObject * obj0 = 0 ;
4769 PyObject * obj1 = 0 ;
4770 PyObject * obj2 = 0 ;
4771 PyObject * obj3 = 0 ;
4772 char *kwnames[] = {
4773 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4774 };
4775
4776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4777 {
4778 arg1 = wxString_in_helper(obj0);
4779 if (arg1 == NULL) SWIG_fail;
4780 temp1 = true;
4781 }
4782 {
4783 arg2 = wxString_in_helper(obj1);
4784 if (arg2 == NULL) SWIG_fail;
4785 temp2 = true;
4786 }
4787 if (obj2) {
4788 {
4789 arg3 = wxString_in_helper(obj2);
4790 if (arg3 == NULL) SWIG_fail;
4791 temp3 = true;
4792 }
4793 }
4794 if (obj3) {
4795 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4796 if (SWIG_arg_fail(4)) SWIG_fail;
4797 }
4798 {
4799 if (!wxPyCheckForApp()) SWIG_fail;
4800 PyThreadState* __tstate = wxPyBeginAllowThreads();
4801 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4802
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 {
4807 #if wxUSE_UNICODE
4808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4809 #else
4810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4811 #endif
4812 }
4813 {
4814 if (temp1)
4815 delete arg1;
4816 }
4817 {
4818 if (temp2)
4819 delete arg2;
4820 }
4821 {
4822 if (temp3)
4823 delete arg3;
4824 }
4825 return resultobj;
4826 fail:
4827 {
4828 if (temp1)
4829 delete arg1;
4830 }
4831 {
4832 if (temp2)
4833 delete arg2;
4834 }
4835 {
4836 if (temp3)
4837 delete arg3;
4838 }
4839 return NULL;
4840 }
4841
4842
4843 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4844 PyObject *resultobj;
4845 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4846 wxString *arg1 = (wxString *) &arg1_defvalue ;
4847 wxString const &arg2_defvalue = wxPyEmptyString ;
4848 wxString *arg2 = (wxString *) &arg2_defvalue ;
4849 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4850 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4851 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4852 wxWindow *arg5 = (wxWindow *) NULL ;
4853 wxString result;
4854 bool temp1 = false ;
4855 bool temp2 = false ;
4856 wxPoint temp4 ;
4857 PyObject * obj0 = 0 ;
4858 PyObject * obj1 = 0 ;
4859 PyObject * obj2 = 0 ;
4860 PyObject * obj3 = 0 ;
4861 PyObject * obj4 = 0 ;
4862 char *kwnames[] = {
4863 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4864 };
4865
4866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4867 if (obj0) {
4868 {
4869 arg1 = wxString_in_helper(obj0);
4870 if (arg1 == NULL) SWIG_fail;
4871 temp1 = true;
4872 }
4873 }
4874 if (obj1) {
4875 {
4876 arg2 = wxString_in_helper(obj1);
4877 if (arg2 == NULL) SWIG_fail;
4878 temp2 = true;
4879 }
4880 }
4881 if (obj2) {
4882 {
4883 arg3 = (long)(SWIG_As_long(obj2));
4884 if (SWIG_arg_fail(3)) SWIG_fail;
4885 }
4886 }
4887 if (obj3) {
4888 {
4889 arg4 = &temp4;
4890 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4891 }
4892 }
4893 if (obj4) {
4894 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4895 if (SWIG_arg_fail(5)) SWIG_fail;
4896 }
4897 {
4898 if (!wxPyCheckForApp()) SWIG_fail;
4899 PyThreadState* __tstate = wxPyBeginAllowThreads();
4900 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4901
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 {
4906 #if wxUSE_UNICODE
4907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4908 #else
4909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4910 #endif
4911 }
4912 {
4913 if (temp1)
4914 delete arg1;
4915 }
4916 {
4917 if (temp2)
4918 delete arg2;
4919 }
4920 return resultobj;
4921 fail:
4922 {
4923 if (temp1)
4924 delete arg1;
4925 }
4926 {
4927 if (temp2)
4928 delete arg2;
4929 }
4930 return NULL;
4931 }
4932
4933
4934 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4935 PyObject *resultobj;
4936 wxString *arg1 = 0 ;
4937 wxString const &arg2_defvalue = wxPyEmptyString ;
4938 wxString *arg2 = (wxString *) &arg2_defvalue ;
4939 wxString const &arg3_defvalue = wxPyEmptyString ;
4940 wxString *arg3 = (wxString *) &arg3_defvalue ;
4941 wxWindow *arg4 = (wxWindow *) NULL ;
4942 int arg5 = (int) -1 ;
4943 int arg6 = (int) -1 ;
4944 bool arg7 = (bool) true ;
4945 wxString result;
4946 bool temp1 = false ;
4947 bool temp2 = false ;
4948 bool temp3 = false ;
4949 PyObject * obj0 = 0 ;
4950 PyObject * obj1 = 0 ;
4951 PyObject * obj2 = 0 ;
4952 PyObject * obj3 = 0 ;
4953 PyObject * obj4 = 0 ;
4954 PyObject * obj5 = 0 ;
4955 PyObject * obj6 = 0 ;
4956 char *kwnames[] = {
4957 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4958 };
4959
4960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4961 {
4962 arg1 = wxString_in_helper(obj0);
4963 if (arg1 == NULL) SWIG_fail;
4964 temp1 = true;
4965 }
4966 if (obj1) {
4967 {
4968 arg2 = wxString_in_helper(obj1);
4969 if (arg2 == NULL) SWIG_fail;
4970 temp2 = true;
4971 }
4972 }
4973 if (obj2) {
4974 {
4975 arg3 = wxString_in_helper(obj2);
4976 if (arg3 == NULL) SWIG_fail;
4977 temp3 = true;
4978 }
4979 }
4980 if (obj3) {
4981 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4982 if (SWIG_arg_fail(4)) SWIG_fail;
4983 }
4984 if (obj4) {
4985 {
4986 arg5 = (int)(SWIG_As_int(obj4));
4987 if (SWIG_arg_fail(5)) SWIG_fail;
4988 }
4989 }
4990 if (obj5) {
4991 {
4992 arg6 = (int)(SWIG_As_int(obj5));
4993 if (SWIG_arg_fail(6)) SWIG_fail;
4994 }
4995 }
4996 if (obj6) {
4997 {
4998 arg7 = (bool)(SWIG_As_bool(obj6));
4999 if (SWIG_arg_fail(7)) SWIG_fail;
5000 }
5001 }
5002 {
5003 if (!wxPyCheckForApp()) SWIG_fail;
5004 PyThreadState* __tstate = wxPyBeginAllowThreads();
5005 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5006
5007 wxPyEndAllowThreads(__tstate);
5008 if (PyErr_Occurred()) SWIG_fail;
5009 }
5010 {
5011 #if wxUSE_UNICODE
5012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5013 #else
5014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5015 #endif
5016 }
5017 {
5018 if (temp1)
5019 delete arg1;
5020 }
5021 {
5022 if (temp2)
5023 delete arg2;
5024 }
5025 {
5026 if (temp3)
5027 delete arg3;
5028 }
5029 return resultobj;
5030 fail:
5031 {
5032 if (temp1)
5033 delete arg1;
5034 }
5035 {
5036 if (temp2)
5037 delete arg2;
5038 }
5039 {
5040 if (temp3)
5041 delete arg3;
5042 }
5043 return NULL;
5044 }
5045
5046
5047 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5048 PyObject *resultobj;
5049 wxString *arg1 = 0 ;
5050 wxString const &arg2_defvalue = wxPyEmptyString ;
5051 wxString *arg2 = (wxString *) &arg2_defvalue ;
5052 wxString const &arg3_defvalue = wxPyEmptyString ;
5053 wxString *arg3 = (wxString *) &arg3_defvalue ;
5054 wxWindow *arg4 = (wxWindow *) NULL ;
5055 wxString result;
5056 bool temp1 = false ;
5057 bool temp2 = false ;
5058 bool temp3 = false ;
5059 PyObject * obj0 = 0 ;
5060 PyObject * obj1 = 0 ;
5061 PyObject * obj2 = 0 ;
5062 PyObject * obj3 = 0 ;
5063 char *kwnames[] = {
5064 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5065 };
5066
5067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5068 {
5069 arg1 = wxString_in_helper(obj0);
5070 if (arg1 == NULL) SWIG_fail;
5071 temp1 = true;
5072 }
5073 if (obj1) {
5074 {
5075 arg2 = wxString_in_helper(obj1);
5076 if (arg2 == NULL) SWIG_fail;
5077 temp2 = true;
5078 }
5079 }
5080 if (obj2) {
5081 {
5082 arg3 = wxString_in_helper(obj2);
5083 if (arg3 == NULL) SWIG_fail;
5084 temp3 = true;
5085 }
5086 }
5087 if (obj3) {
5088 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5089 if (SWIG_arg_fail(4)) SWIG_fail;
5090 }
5091 {
5092 if (!wxPyCheckForApp()) SWIG_fail;
5093 PyThreadState* __tstate = wxPyBeginAllowThreads();
5094 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5095
5096 wxPyEndAllowThreads(__tstate);
5097 if (PyErr_Occurred()) SWIG_fail;
5098 }
5099 {
5100 #if wxUSE_UNICODE
5101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5102 #else
5103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5104 #endif
5105 }
5106 {
5107 if (temp1)
5108 delete arg1;
5109 }
5110 {
5111 if (temp2)
5112 delete arg2;
5113 }
5114 {
5115 if (temp3)
5116 delete arg3;
5117 }
5118 return resultobj;
5119 fail:
5120 {
5121 if (temp1)
5122 delete arg1;
5123 }
5124 {
5125 if (temp2)
5126 delete arg2;
5127 }
5128 {
5129 if (temp3)
5130 delete arg3;
5131 }
5132 return NULL;
5133 }
5134
5135
5136 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5137 PyObject *resultobj;
5138 wxString *arg1 = 0 ;
5139 wxString *arg2 = 0 ;
5140 int arg3 ;
5141 wxString *arg4 = (wxString *) 0 ;
5142 wxWindow *arg5 = (wxWindow *) NULL ;
5143 int arg6 = (int) -1 ;
5144 int arg7 = (int) -1 ;
5145 bool arg8 = (bool) true ;
5146 int arg9 = (int) 150 ;
5147 int arg10 = (int) 200 ;
5148 wxString result;
5149 bool temp1 = false ;
5150 bool temp2 = false ;
5151 PyObject * obj0 = 0 ;
5152 PyObject * obj1 = 0 ;
5153 PyObject * obj2 = 0 ;
5154 PyObject * obj3 = 0 ;
5155 PyObject * obj4 = 0 ;
5156 PyObject * obj5 = 0 ;
5157 PyObject * obj6 = 0 ;
5158 PyObject * obj7 = 0 ;
5159 PyObject * obj8 = 0 ;
5160 char *kwnames[] = {
5161 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5162 };
5163
5164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5165 {
5166 arg1 = wxString_in_helper(obj0);
5167 if (arg1 == NULL) SWIG_fail;
5168 temp1 = true;
5169 }
5170 {
5171 arg2 = wxString_in_helper(obj1);
5172 if (arg2 == NULL) SWIG_fail;
5173 temp2 = true;
5174 }
5175 {
5176 arg3 = PyList_Size(obj2);
5177 arg4 = wxString_LIST_helper(obj2);
5178 if (arg4 == NULL) SWIG_fail;
5179 }
5180 if (obj3) {
5181 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5182 if (SWIG_arg_fail(5)) SWIG_fail;
5183 }
5184 if (obj4) {
5185 {
5186 arg6 = (int)(SWIG_As_int(obj4));
5187 if (SWIG_arg_fail(6)) SWIG_fail;
5188 }
5189 }
5190 if (obj5) {
5191 {
5192 arg7 = (int)(SWIG_As_int(obj5));
5193 if (SWIG_arg_fail(7)) SWIG_fail;
5194 }
5195 }
5196 if (obj6) {
5197 {
5198 arg8 = (bool)(SWIG_As_bool(obj6));
5199 if (SWIG_arg_fail(8)) SWIG_fail;
5200 }
5201 }
5202 if (obj7) {
5203 {
5204 arg9 = (int)(SWIG_As_int(obj7));
5205 if (SWIG_arg_fail(9)) SWIG_fail;
5206 }
5207 }
5208 if (obj8) {
5209 {
5210 arg10 = (int)(SWIG_As_int(obj8));
5211 if (SWIG_arg_fail(10)) SWIG_fail;
5212 }
5213 }
5214 {
5215 if (!wxPyCheckForApp()) SWIG_fail;
5216 PyThreadState* __tstate = wxPyBeginAllowThreads();
5217 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5218
5219 wxPyEndAllowThreads(__tstate);
5220 if (PyErr_Occurred()) SWIG_fail;
5221 }
5222 {
5223 #if wxUSE_UNICODE
5224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5225 #else
5226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5227 #endif
5228 }
5229 {
5230 if (temp1)
5231 delete arg1;
5232 }
5233 {
5234 if (temp2)
5235 delete arg2;
5236 }
5237 {
5238 if (arg4) delete [] arg4;
5239 }
5240 return resultobj;
5241 fail:
5242 {
5243 if (temp1)
5244 delete arg1;
5245 }
5246 {
5247 if (temp2)
5248 delete arg2;
5249 }
5250 {
5251 if (arg4) delete [] arg4;
5252 }
5253 return NULL;
5254 }
5255
5256
5257 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5258 PyObject *resultobj;
5259 wxString *arg1 = 0 ;
5260 wxString *arg2 = 0 ;
5261 int arg3 ;
5262 wxString *arg4 = (wxString *) 0 ;
5263 wxWindow *arg5 = (wxWindow *) NULL ;
5264 int arg6 = (int) -1 ;
5265 int arg7 = (int) -1 ;
5266 bool arg8 = (bool) true ;
5267 int arg9 = (int) 150 ;
5268 int arg10 = (int) 200 ;
5269 int result;
5270 bool temp1 = false ;
5271 bool temp2 = false ;
5272 PyObject * obj0 = 0 ;
5273 PyObject * obj1 = 0 ;
5274 PyObject * obj2 = 0 ;
5275 PyObject * obj3 = 0 ;
5276 PyObject * obj4 = 0 ;
5277 PyObject * obj5 = 0 ;
5278 PyObject * obj6 = 0 ;
5279 PyObject * obj7 = 0 ;
5280 PyObject * obj8 = 0 ;
5281 char *kwnames[] = {
5282 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5283 };
5284
5285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5286 {
5287 arg1 = wxString_in_helper(obj0);
5288 if (arg1 == NULL) SWIG_fail;
5289 temp1 = true;
5290 }
5291 {
5292 arg2 = wxString_in_helper(obj1);
5293 if (arg2 == NULL) SWIG_fail;
5294 temp2 = true;
5295 }
5296 {
5297 arg3 = PyList_Size(obj2);
5298 arg4 = wxString_LIST_helper(obj2);
5299 if (arg4 == NULL) SWIG_fail;
5300 }
5301 if (obj3) {
5302 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5303 if (SWIG_arg_fail(5)) SWIG_fail;
5304 }
5305 if (obj4) {
5306 {
5307 arg6 = (int)(SWIG_As_int(obj4));
5308 if (SWIG_arg_fail(6)) SWIG_fail;
5309 }
5310 }
5311 if (obj5) {
5312 {
5313 arg7 = (int)(SWIG_As_int(obj5));
5314 if (SWIG_arg_fail(7)) SWIG_fail;
5315 }
5316 }
5317 if (obj6) {
5318 {
5319 arg8 = (bool)(SWIG_As_bool(obj6));
5320 if (SWIG_arg_fail(8)) SWIG_fail;
5321 }
5322 }
5323 if (obj7) {
5324 {
5325 arg9 = (int)(SWIG_As_int(obj7));
5326 if (SWIG_arg_fail(9)) SWIG_fail;
5327 }
5328 }
5329 if (obj8) {
5330 {
5331 arg10 = (int)(SWIG_As_int(obj8));
5332 if (SWIG_arg_fail(10)) SWIG_fail;
5333 }
5334 }
5335 {
5336 if (!wxPyCheckForApp()) SWIG_fail;
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5339
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 {
5344 resultobj = SWIG_From_int((int)(result));
5345 }
5346 {
5347 if (temp1)
5348 delete arg1;
5349 }
5350 {
5351 if (temp2)
5352 delete arg2;
5353 }
5354 {
5355 if (arg4) delete [] arg4;
5356 }
5357 return resultobj;
5358 fail:
5359 {
5360 if (temp1)
5361 delete arg1;
5362 }
5363 {
5364 if (temp2)
5365 delete arg2;
5366 }
5367 {
5368 if (arg4) delete [] arg4;
5369 }
5370 return NULL;
5371 }
5372
5373
5374 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5375 PyObject *resultobj;
5376 wxString *arg1 = 0 ;
5377 wxString const &arg2_defvalue = wxPyEmptyString ;
5378 wxString *arg2 = (wxString *) &arg2_defvalue ;
5379 int arg3 = (int) wxOK|wxCENTRE ;
5380 wxWindow *arg4 = (wxWindow *) NULL ;
5381 int arg5 = (int) -1 ;
5382 int arg6 = (int) -1 ;
5383 int result;
5384 bool temp1 = false ;
5385 bool temp2 = false ;
5386 PyObject * obj0 = 0 ;
5387 PyObject * obj1 = 0 ;
5388 PyObject * obj2 = 0 ;
5389 PyObject * obj3 = 0 ;
5390 PyObject * obj4 = 0 ;
5391 PyObject * obj5 = 0 ;
5392 char *kwnames[] = {
5393 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5394 };
5395
5396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5397 {
5398 arg1 = wxString_in_helper(obj0);
5399 if (arg1 == NULL) SWIG_fail;
5400 temp1 = true;
5401 }
5402 if (obj1) {
5403 {
5404 arg2 = wxString_in_helper(obj1);
5405 if (arg2 == NULL) SWIG_fail;
5406 temp2 = true;
5407 }
5408 }
5409 if (obj2) {
5410 {
5411 arg3 = (int)(SWIG_As_int(obj2));
5412 if (SWIG_arg_fail(3)) SWIG_fail;
5413 }
5414 }
5415 if (obj3) {
5416 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5417 if (SWIG_arg_fail(4)) SWIG_fail;
5418 }
5419 if (obj4) {
5420 {
5421 arg5 = (int)(SWIG_As_int(obj4));
5422 if (SWIG_arg_fail(5)) SWIG_fail;
5423 }
5424 }
5425 if (obj5) {
5426 {
5427 arg6 = (int)(SWIG_As_int(obj5));
5428 if (SWIG_arg_fail(6)) SWIG_fail;
5429 }
5430 }
5431 {
5432 if (!wxPyCheckForApp()) SWIG_fail;
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5435
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 {
5440 resultobj = SWIG_From_int((int)(result));
5441 }
5442 {
5443 if (temp1)
5444 delete arg1;
5445 }
5446 {
5447 if (temp2)
5448 delete arg2;
5449 }
5450 return resultobj;
5451 fail:
5452 {
5453 if (temp1)
5454 delete arg1;
5455 }
5456 {
5457 if (temp2)
5458 delete arg2;
5459 }
5460 return NULL;
5461 }
5462
5463
5464 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5465 PyObject *resultobj;
5466 wxString *arg1 = 0 ;
5467 wxString *arg2 = 0 ;
5468 wxString *arg3 = 0 ;
5469 long arg4 ;
5470 long arg5 = (long) 0 ;
5471 long arg6 = (long) 100 ;
5472 wxWindow *arg7 = (wxWindow *) NULL ;
5473 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5474 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5475 long result;
5476 bool temp1 = false ;
5477 bool temp2 = false ;
5478 bool temp3 = false ;
5479 wxPoint temp8 ;
5480 PyObject * obj0 = 0 ;
5481 PyObject * obj1 = 0 ;
5482 PyObject * obj2 = 0 ;
5483 PyObject * obj3 = 0 ;
5484 PyObject * obj4 = 0 ;
5485 PyObject * obj5 = 0 ;
5486 PyObject * obj6 = 0 ;
5487 PyObject * obj7 = 0 ;
5488 char *kwnames[] = {
5489 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5490 };
5491
5492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5493 {
5494 arg1 = wxString_in_helper(obj0);
5495 if (arg1 == NULL) SWIG_fail;
5496 temp1 = true;
5497 }
5498 {
5499 arg2 = wxString_in_helper(obj1);
5500 if (arg2 == NULL) SWIG_fail;
5501 temp2 = true;
5502 }
5503 {
5504 arg3 = wxString_in_helper(obj2);
5505 if (arg3 == NULL) SWIG_fail;
5506 temp3 = true;
5507 }
5508 {
5509 arg4 = (long)(SWIG_As_long(obj3));
5510 if (SWIG_arg_fail(4)) SWIG_fail;
5511 }
5512 if (obj4) {
5513 {
5514 arg5 = (long)(SWIG_As_long(obj4));
5515 if (SWIG_arg_fail(5)) SWIG_fail;
5516 }
5517 }
5518 if (obj5) {
5519 {
5520 arg6 = (long)(SWIG_As_long(obj5));
5521 if (SWIG_arg_fail(6)) SWIG_fail;
5522 }
5523 }
5524 if (obj6) {
5525 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5526 if (SWIG_arg_fail(7)) SWIG_fail;
5527 }
5528 if (obj7) {
5529 {
5530 arg8 = &temp8;
5531 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5532 }
5533 }
5534 {
5535 if (!wxPyCheckForApp()) SWIG_fail;
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5538
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 {
5543 resultobj = SWIG_From_long((long)(result));
5544 }
5545 {
5546 if (temp1)
5547 delete arg1;
5548 }
5549 {
5550 if (temp2)
5551 delete arg2;
5552 }
5553 {
5554 if (temp3)
5555 delete arg3;
5556 }
5557 return resultobj;
5558 fail:
5559 {
5560 if (temp1)
5561 delete arg1;
5562 }
5563 {
5564 if (temp2)
5565 delete arg2;
5566 }
5567 {
5568 if (temp3)
5569 delete arg3;
5570 }
5571 return NULL;
5572 }
5573
5574
5575 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5576 PyObject *resultobj;
5577 bool result;
5578 char *kwnames[] = {
5579 NULL
5580 };
5581
5582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5583 {
5584 if (!wxPyCheckForApp()) SWIG_fail;
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 result = (bool)wxColourDisplay();
5587
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 {
5592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5593 }
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5601 PyObject *resultobj;
5602 int result;
5603 char *kwnames[] = {
5604 NULL
5605 };
5606
5607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5608 {
5609 if (!wxPyCheckForApp()) SWIG_fail;
5610 PyThreadState* __tstate = wxPyBeginAllowThreads();
5611 result = (int)wxDisplayDepth();
5612
5613 wxPyEndAllowThreads(__tstate);
5614 if (PyErr_Occurred()) SWIG_fail;
5615 }
5616 {
5617 resultobj = SWIG_From_int((int)(result));
5618 }
5619 return resultobj;
5620 fail:
5621 return NULL;
5622 }
5623
5624
5625 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5626 PyObject *resultobj;
5627 int result;
5628 char *kwnames[] = {
5629 NULL
5630 };
5631
5632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5633 {
5634 if (!wxPyCheckForApp()) SWIG_fail;
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = (int)wxGetDisplayDepth();
5637
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 {
5642 resultobj = SWIG_From_int((int)(result));
5643 }
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj;
5652 int *arg1 = (int *) 0 ;
5653 int *arg2 = (int *) 0 ;
5654 int temp1 ;
5655 int res1 = 0 ;
5656 int temp2 ;
5657 int res2 = 0 ;
5658 char *kwnames[] = {
5659 NULL
5660 };
5661
5662 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5663 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5665 {
5666 if (!wxPyCheckForApp()) SWIG_fail;
5667 PyThreadState* __tstate = wxPyBeginAllowThreads();
5668 wxDisplaySize(arg1,arg2);
5669
5670 wxPyEndAllowThreads(__tstate);
5671 if (PyErr_Occurred()) SWIG_fail;
5672 }
5673 Py_INCREF(Py_None); resultobj = Py_None;
5674 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5675 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5676 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5677 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5678 return resultobj;
5679 fail:
5680 return NULL;
5681 }
5682
5683
5684 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5685 PyObject *resultobj;
5686 wxSize result;
5687 char *kwnames[] = {
5688 NULL
5689 };
5690
5691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5692 {
5693 if (!wxPyCheckForApp()) SWIG_fail;
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 result = wxGetDisplaySize();
5696
5697 wxPyEndAllowThreads(__tstate);
5698 if (PyErr_Occurred()) SWIG_fail;
5699 }
5700 {
5701 wxSize * resultptr;
5702 resultptr = new wxSize((wxSize &)(result));
5703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5704 }
5705 return resultobj;
5706 fail:
5707 return NULL;
5708 }
5709
5710
5711 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5712 PyObject *resultobj;
5713 int *arg1 = (int *) 0 ;
5714 int *arg2 = (int *) 0 ;
5715 int temp1 ;
5716 int res1 = 0 ;
5717 int temp2 ;
5718 int res2 = 0 ;
5719 char *kwnames[] = {
5720 NULL
5721 };
5722
5723 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5724 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5726 {
5727 if (!wxPyCheckForApp()) SWIG_fail;
5728 PyThreadState* __tstate = wxPyBeginAllowThreads();
5729 wxDisplaySizeMM(arg1,arg2);
5730
5731 wxPyEndAllowThreads(__tstate);
5732 if (PyErr_Occurred()) SWIG_fail;
5733 }
5734 Py_INCREF(Py_None); resultobj = Py_None;
5735 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5736 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5737 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5738 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5739 return resultobj;
5740 fail:
5741 return NULL;
5742 }
5743
5744
5745 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5746 PyObject *resultobj;
5747 wxSize result;
5748 char *kwnames[] = {
5749 NULL
5750 };
5751
5752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5753 {
5754 if (!wxPyCheckForApp()) SWIG_fail;
5755 PyThreadState* __tstate = wxPyBeginAllowThreads();
5756 result = wxGetDisplaySizeMM();
5757
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 {
5762 wxSize * resultptr;
5763 resultptr = new wxSize((wxSize &)(result));
5764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5765 }
5766 return resultobj;
5767 fail:
5768 return NULL;
5769 }
5770
5771
5772 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj;
5774 int *arg1 = (int *) 0 ;
5775 int *arg2 = (int *) 0 ;
5776 int *arg3 = (int *) 0 ;
5777 int *arg4 = (int *) 0 ;
5778 int temp1 ;
5779 int res1 = 0 ;
5780 int temp2 ;
5781 int res2 = 0 ;
5782 int temp3 ;
5783 int res3 = 0 ;
5784 int temp4 ;
5785 int res4 = 0 ;
5786 char *kwnames[] = {
5787 NULL
5788 };
5789
5790 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5791 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5792 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5793 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5795 {
5796 if (!wxPyCheckForApp()) SWIG_fail;
5797 PyThreadState* __tstate = wxPyBeginAllowThreads();
5798 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5799
5800 wxPyEndAllowThreads(__tstate);
5801 if (PyErr_Occurred()) SWIG_fail;
5802 }
5803 Py_INCREF(Py_None); resultobj = Py_None;
5804 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5805 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5806 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5807 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5808 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5809 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5810 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5811 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5812 return resultobj;
5813 fail:
5814 return NULL;
5815 }
5816
5817
5818 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5819 PyObject *resultobj;
5820 wxRect result;
5821 char *kwnames[] = {
5822 NULL
5823 };
5824
5825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5826 {
5827 if (!wxPyCheckForApp()) SWIG_fail;
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 result = wxGetClientDisplayRect();
5830
5831 wxPyEndAllowThreads(__tstate);
5832 if (PyErr_Occurred()) SWIG_fail;
5833 }
5834 {
5835 wxRect * resultptr;
5836 resultptr = new wxRect((wxRect &)(result));
5837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5838 }
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj;
5847 wxCursor *arg1 = 0 ;
5848 PyObject * obj0 = 0 ;
5849 char *kwnames[] = {
5850 (char *) "cursor", NULL
5851 };
5852
5853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5854 {
5855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5856 if (SWIG_arg_fail(1)) SWIG_fail;
5857 if (arg1 == NULL) {
5858 SWIG_null_ref("wxCursor");
5859 }
5860 if (SWIG_arg_fail(1)) SWIG_fail;
5861 }
5862 {
5863 if (!wxPyCheckForApp()) SWIG_fail;
5864 PyThreadState* __tstate = wxPyBeginAllowThreads();
5865 wxSetCursor(*arg1);
5866
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 Py_INCREF(Py_None); resultobj = Py_None;
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5878 PyObject *resultobj;
5879 void *result;
5880 char *kwnames[] = {
5881 NULL
5882 };
5883
5884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5885 {
5886 if (!wxPyCheckForApp()) SWIG_fail;
5887 PyThreadState* __tstate = wxPyBeginAllowThreads();
5888 result = (void *)wxGetXDisplay();
5889
5890 wxPyEndAllowThreads(__tstate);
5891 if (PyErr_Occurred()) SWIG_fail;
5892 }
5893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5894 return resultobj;
5895 fail:
5896 return NULL;
5897 }
5898
5899
5900 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5903 PyObject * obj0 = 0 ;
5904 char *kwnames[] = {
5905 (char *) "cursor", NULL
5906 };
5907
5908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5909 if (obj0) {
5910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5911 if (SWIG_arg_fail(1)) SWIG_fail;
5912 }
5913 {
5914 if (!wxPyCheckForApp()) SWIG_fail;
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 wxBeginBusyCursor(arg1);
5917
5918 wxPyEndAllowThreads(__tstate);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 Py_INCREF(Py_None); resultobj = Py_None;
5922 return resultobj;
5923 fail:
5924 return NULL;
5925 }
5926
5927
5928 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5929 PyObject *resultobj;
5930 wxWindow *result;
5931 char *kwnames[] = {
5932 NULL
5933 };
5934
5935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5936 {
5937 if (!wxPyCheckForApp()) SWIG_fail;
5938 PyThreadState* __tstate = wxPyBeginAllowThreads();
5939 result = (wxWindow *)wxGetActiveWindow();
5940
5941 wxPyEndAllowThreads(__tstate);
5942 if (PyErr_Occurred()) SWIG_fail;
5943 }
5944 {
5945 resultobj = wxPyMake_wxObject(result, 0);
5946 }
5947 return resultobj;
5948 fail:
5949 return NULL;
5950 }
5951
5952
5953 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5954 PyObject *resultobj;
5955 wxPoint *arg1 = 0 ;
5956 wxWindow *result;
5957 wxPoint temp1 ;
5958 PyObject * obj0 = 0 ;
5959 char *kwnames[] = {
5960 (char *) "pt", NULL
5961 };
5962
5963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5964 {
5965 arg1 = &temp1;
5966 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5967 }
5968 {
5969 if (!wxPyCheckForApp()) SWIG_fail;
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5972
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 {
5977 resultobj = wxPyMake_wxObject(result, 0);
5978 }
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5986 PyObject *resultobj;
5987 wxPoint *arg1 = 0 ;
5988 wxWindow *result;
5989 wxPoint temp1 ;
5990 PyObject * obj0 = 0 ;
5991 char *kwnames[] = {
5992 (char *) "pt", NULL
5993 };
5994
5995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5996 {
5997 arg1 = &temp1;
5998 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5999 }
6000 {
6001 if (!wxPyCheckForApp()) SWIG_fail;
6002 PyThreadState* __tstate = wxPyBeginAllowThreads();
6003 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6004
6005 wxPyEndAllowThreads(__tstate);
6006 if (PyErr_Occurred()) SWIG_fail;
6007 }
6008 {
6009 resultobj = wxPyMake_wxObject(result, 0);
6010 }
6011 return resultobj;
6012 fail:
6013 return NULL;
6014 }
6015
6016
6017 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6018 PyObject *resultobj;
6019 wxWindow *arg1 = (wxWindow *) 0 ;
6020 wxWindow *result;
6021 PyObject * obj0 = 0 ;
6022 char *kwnames[] = {
6023 (char *) "win", NULL
6024 };
6025
6026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6028 if (SWIG_arg_fail(1)) SWIG_fail;
6029 {
6030 if (!wxPyCheckForApp()) SWIG_fail;
6031 PyThreadState* __tstate = wxPyBeginAllowThreads();
6032 result = (wxWindow *)wxGetTopLevelParent(arg1);
6033
6034 wxPyEndAllowThreads(__tstate);
6035 if (PyErr_Occurred()) SWIG_fail;
6036 }
6037 {
6038 resultobj = wxPyMake_wxObject(result, 0);
6039 }
6040 return resultobj;
6041 fail:
6042 return NULL;
6043 }
6044
6045
6046 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6047 PyObject *resultobj;
6048 wxString *arg1 = 0 ;
6049 bool result;
6050 bool temp1 = false ;
6051 PyObject * obj0 = 0 ;
6052 char *kwnames[] = {
6053 (char *) "url", NULL
6054 };
6055
6056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6057 {
6058 arg1 = wxString_in_helper(obj0);
6059 if (arg1 == NULL) SWIG_fail;
6060 temp1 = true;
6061 }
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6065
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 {
6070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6071 }
6072 {
6073 if (temp1)
6074 delete arg1;
6075 }
6076 return resultobj;
6077 fail:
6078 {
6079 if (temp1)
6080 delete arg1;
6081 }
6082 return NULL;
6083 }
6084
6085
6086 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6087 PyObject *resultobj;
6088 wxKeyCode arg1 ;
6089 bool result;
6090 PyObject * obj0 = 0 ;
6091 char *kwnames[] = {
6092 (char *) "key", NULL
6093 };
6094
6095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6096 {
6097 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6098 if (SWIG_arg_fail(1)) SWIG_fail;
6099 }
6100 {
6101 if (!wxPyCheckForApp()) SWIG_fail;
6102 PyThreadState* __tstate = wxPyBeginAllowThreads();
6103 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6104
6105 wxPyEndAllowThreads(__tstate);
6106 if (PyErr_Occurred()) SWIG_fail;
6107 }
6108 {
6109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6110 }
6111 return resultobj;
6112 fail:
6113 return NULL;
6114 }
6115
6116
6117 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6118 PyObject *resultobj;
6119 char *kwnames[] = {
6120 NULL
6121 };
6122
6123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6124 {
6125 if (!wxPyCheckForApp()) SWIG_fail;
6126 PyThreadState* __tstate = wxPyBeginAllowThreads();
6127 wxWakeUpMainThread();
6128
6129 wxPyEndAllowThreads(__tstate);
6130 if (PyErr_Occurred()) SWIG_fail;
6131 }
6132 Py_INCREF(Py_None); resultobj = Py_None;
6133 return resultobj;
6134 fail:
6135 return NULL;
6136 }
6137
6138
6139 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6140 PyObject *resultobj;
6141 char *kwnames[] = {
6142 NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6146 {
6147 if (!wxPyCheckForApp()) SWIG_fail;
6148 PyThreadState* __tstate = wxPyBeginAllowThreads();
6149 wxMutexGuiEnter();
6150
6151 wxPyEndAllowThreads(__tstate);
6152 if (PyErr_Occurred()) SWIG_fail;
6153 }
6154 Py_INCREF(Py_None); resultobj = Py_None;
6155 return resultobj;
6156 fail:
6157 return NULL;
6158 }
6159
6160
6161 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6162 PyObject *resultobj;
6163 char *kwnames[] = {
6164 NULL
6165 };
6166
6167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6168 {
6169 if (!wxPyCheckForApp()) SWIG_fail;
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 wxMutexGuiLeave();
6172
6173 wxPyEndAllowThreads(__tstate);
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 Py_INCREF(Py_None); resultobj = Py_None;
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj;
6185 wxMutexGuiLocker *result;
6186 char *kwnames[] = {
6187 NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6191 {
6192 if (!wxPyCheckForApp()) SWIG_fail;
6193 PyThreadState* __tstate = wxPyBeginAllowThreads();
6194 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6195
6196 wxPyEndAllowThreads(__tstate);
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj;
6208 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6209 PyObject * obj0 = 0 ;
6210 char *kwnames[] = {
6211 (char *) "self", NULL
6212 };
6213
6214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6216 if (SWIG_arg_fail(1)) SWIG_fail;
6217 {
6218 PyThreadState* __tstate = wxPyBeginAllowThreads();
6219 delete arg1;
6220
6221 wxPyEndAllowThreads(__tstate);
6222 if (PyErr_Occurred()) SWIG_fail;
6223 }
6224 Py_INCREF(Py_None); resultobj = Py_None;
6225 return resultobj;
6226 fail:
6227 return NULL;
6228 }
6229
6230
6231 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6232 PyObject *obj;
6233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6234 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6235 Py_INCREF(obj);
6236 return Py_BuildValue((char *)"");
6237 }
6238 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6239 PyObject *resultobj;
6240 bool result;
6241 char *kwnames[] = {
6242 NULL
6243 };
6244
6245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6246 {
6247 PyThreadState* __tstate = wxPyBeginAllowThreads();
6248 result = (bool)wxThread_IsMain();
6249
6250 wxPyEndAllowThreads(__tstate);
6251 if (PyErr_Occurred()) SWIG_fail;
6252 }
6253 {
6254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6255 }
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6263 PyObject *resultobj;
6264 wxString *arg1 = 0 ;
6265 wxToolTip *result;
6266 bool temp1 = false ;
6267 PyObject * obj0 = 0 ;
6268 char *kwnames[] = {
6269 (char *) "tip", NULL
6270 };
6271
6272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6273 {
6274 arg1 = wxString_in_helper(obj0);
6275 if (arg1 == NULL) SWIG_fail;
6276 temp1 = true;
6277 }
6278 {
6279 if (!wxPyCheckForApp()) SWIG_fail;
6280 PyThreadState* __tstate = wxPyBeginAllowThreads();
6281 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6282
6283 wxPyEndAllowThreads(__tstate);
6284 if (PyErr_Occurred()) SWIG_fail;
6285 }
6286 {
6287 resultobj = wxPyMake_wxObject(result, 1);
6288 }
6289 {
6290 if (temp1)
6291 delete arg1;
6292 }
6293 return resultobj;
6294 fail:
6295 {
6296 if (temp1)
6297 delete arg1;
6298 }
6299 return NULL;
6300 }
6301
6302
6303 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj;
6305 wxToolTip *arg1 = (wxToolTip *) 0 ;
6306 wxString *arg2 = 0 ;
6307 bool temp2 = false ;
6308 PyObject * obj0 = 0 ;
6309 PyObject * obj1 = 0 ;
6310 char *kwnames[] = {
6311 (char *) "self",(char *) "tip", NULL
6312 };
6313
6314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6316 if (SWIG_arg_fail(1)) SWIG_fail;
6317 {
6318 arg2 = wxString_in_helper(obj1);
6319 if (arg2 == NULL) SWIG_fail;
6320 temp2 = true;
6321 }
6322 {
6323 PyThreadState* __tstate = wxPyBeginAllowThreads();
6324 (arg1)->SetTip((wxString const &)*arg2);
6325
6326 wxPyEndAllowThreads(__tstate);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 Py_INCREF(Py_None); resultobj = Py_None;
6330 {
6331 if (temp2)
6332 delete arg2;
6333 }
6334 return resultobj;
6335 fail:
6336 {
6337 if (temp2)
6338 delete arg2;
6339 }
6340 return NULL;
6341 }
6342
6343
6344 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6345 PyObject *resultobj;
6346 wxToolTip *arg1 = (wxToolTip *) 0 ;
6347 wxString result;
6348 PyObject * obj0 = 0 ;
6349 char *kwnames[] = {
6350 (char *) "self", NULL
6351 };
6352
6353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6355 if (SWIG_arg_fail(1)) SWIG_fail;
6356 {
6357 PyThreadState* __tstate = wxPyBeginAllowThreads();
6358 result = (arg1)->GetTip();
6359
6360 wxPyEndAllowThreads(__tstate);
6361 if (PyErr_Occurred()) SWIG_fail;
6362 }
6363 {
6364 #if wxUSE_UNICODE
6365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6366 #else
6367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6368 #endif
6369 }
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj;
6378 wxToolTip *arg1 = (wxToolTip *) 0 ;
6379 wxWindow *result;
6380 PyObject * obj0 = 0 ;
6381 char *kwnames[] = {
6382 (char *) "self", NULL
6383 };
6384
6385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6387 if (SWIG_arg_fail(1)) SWIG_fail;
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 result = (wxWindow *)(arg1)->GetWindow();
6391
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 {
6396 resultobj = wxPyMake_wxObject(result, 0);
6397 }
6398 return resultobj;
6399 fail:
6400 return NULL;
6401 }
6402
6403
6404 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6405 PyObject *resultobj;
6406 bool arg1 ;
6407 PyObject * obj0 = 0 ;
6408 char *kwnames[] = {
6409 (char *) "flag", NULL
6410 };
6411
6412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6413 {
6414 arg1 = (bool)(SWIG_As_bool(obj0));
6415 if (SWIG_arg_fail(1)) SWIG_fail;
6416 }
6417 {
6418 PyThreadState* __tstate = wxPyBeginAllowThreads();
6419 wxToolTip::Enable(arg1);
6420
6421 wxPyEndAllowThreads(__tstate);
6422 if (PyErr_Occurred()) SWIG_fail;
6423 }
6424 Py_INCREF(Py_None); resultobj = Py_None;
6425 return resultobj;
6426 fail:
6427 return NULL;
6428 }
6429
6430
6431 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6432 PyObject *resultobj;
6433 long arg1 ;
6434 PyObject * obj0 = 0 ;
6435 char *kwnames[] = {
6436 (char *) "milliseconds", NULL
6437 };
6438
6439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6440 {
6441 arg1 = (long)(SWIG_As_long(obj0));
6442 if (SWIG_arg_fail(1)) SWIG_fail;
6443 }
6444 {
6445 PyThreadState* __tstate = wxPyBeginAllowThreads();
6446 wxToolTip::SetDelay(arg1);
6447
6448 wxPyEndAllowThreads(__tstate);
6449 if (PyErr_Occurred()) SWIG_fail;
6450 }
6451 Py_INCREF(Py_None); resultobj = Py_None;
6452 return resultobj;
6453 fail:
6454 return NULL;
6455 }
6456
6457
6458 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6459 PyObject *obj;
6460 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6461 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6462 Py_INCREF(obj);
6463 return Py_BuildValue((char *)"");
6464 }
6465 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj;
6467 wxWindow *arg1 = (wxWindow *) 0 ;
6468 wxSize *arg2 = 0 ;
6469 wxCaret *result;
6470 wxSize temp2 ;
6471 PyObject * obj0 = 0 ;
6472 PyObject * obj1 = 0 ;
6473 char *kwnames[] = {
6474 (char *) "window",(char *) "size", NULL
6475 };
6476
6477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6479 if (SWIG_arg_fail(1)) SWIG_fail;
6480 {
6481 arg2 = &temp2;
6482 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6483 }
6484 {
6485 if (!wxPyCheckForApp()) SWIG_fail;
6486 PyThreadState* __tstate = wxPyBeginAllowThreads();
6487 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6488
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6500 PyObject *resultobj;
6501 wxCaret *arg1 = (wxCaret *) 0 ;
6502 PyObject * obj0 = 0 ;
6503 char *kwnames[] = {
6504 (char *) "self", NULL
6505 };
6506
6507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6509 if (SWIG_arg_fail(1)) SWIG_fail;
6510 {
6511 PyThreadState* __tstate = wxPyBeginAllowThreads();
6512 wxCaret_Destroy(arg1);
6513
6514 wxPyEndAllowThreads(__tstate);
6515 if (PyErr_Occurred()) SWIG_fail;
6516 }
6517 Py_INCREF(Py_None); resultobj = Py_None;
6518 return resultobj;
6519 fail:
6520 return NULL;
6521 }
6522
6523
6524 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6525 PyObject *resultobj;
6526 wxCaret *arg1 = (wxCaret *) 0 ;
6527 bool result;
6528 PyObject * obj0 = 0 ;
6529 char *kwnames[] = {
6530 (char *) "self", NULL
6531 };
6532
6533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6535 if (SWIG_arg_fail(1)) SWIG_fail;
6536 {
6537 PyThreadState* __tstate = wxPyBeginAllowThreads();
6538 result = (bool)(arg1)->IsOk();
6539
6540 wxPyEndAllowThreads(__tstate);
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 {
6544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6545 }
6546 return resultobj;
6547 fail:
6548 return NULL;
6549 }
6550
6551
6552 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6553 PyObject *resultobj;
6554 wxCaret *arg1 = (wxCaret *) 0 ;
6555 bool result;
6556 PyObject * obj0 = 0 ;
6557 char *kwnames[] = {
6558 (char *) "self", NULL
6559 };
6560
6561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6563 if (SWIG_arg_fail(1)) SWIG_fail;
6564 {
6565 PyThreadState* __tstate = wxPyBeginAllowThreads();
6566 result = (bool)(arg1)->IsVisible();
6567
6568 wxPyEndAllowThreads(__tstate);
6569 if (PyErr_Occurred()) SWIG_fail;
6570 }
6571 {
6572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6573 }
6574 return resultobj;
6575 fail:
6576 return NULL;
6577 }
6578
6579
6580 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6581 PyObject *resultobj;
6582 wxCaret *arg1 = (wxCaret *) 0 ;
6583 wxPoint result;
6584 PyObject * obj0 = 0 ;
6585 char *kwnames[] = {
6586 (char *) "self", NULL
6587 };
6588
6589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6591 if (SWIG_arg_fail(1)) SWIG_fail;
6592 {
6593 PyThreadState* __tstate = wxPyBeginAllowThreads();
6594 result = (arg1)->GetPosition();
6595
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 {
6600 wxPoint * resultptr;
6601 resultptr = new wxPoint((wxPoint &)(result));
6602 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6603 }
6604 return resultobj;
6605 fail:
6606 return NULL;
6607 }
6608
6609
6610 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6611 PyObject *resultobj;
6612 wxCaret *arg1 = (wxCaret *) 0 ;
6613 int *arg2 = (int *) 0 ;
6614 int *arg3 = (int *) 0 ;
6615 int temp2 ;
6616 int res2 = 0 ;
6617 int temp3 ;
6618 int res3 = 0 ;
6619 PyObject * obj0 = 0 ;
6620 char *kwnames[] = {
6621 (char *) "self", NULL
6622 };
6623
6624 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6625 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6628 if (SWIG_arg_fail(1)) SWIG_fail;
6629 {
6630 PyThreadState* __tstate = wxPyBeginAllowThreads();
6631 (arg1)->GetPosition(arg2,arg3);
6632
6633 wxPyEndAllowThreads(__tstate);
6634 if (PyErr_Occurred()) SWIG_fail;
6635 }
6636 Py_INCREF(Py_None); resultobj = Py_None;
6637 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6638 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6639 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6640 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6648 PyObject *resultobj;
6649 wxCaret *arg1 = (wxCaret *) 0 ;
6650 wxSize result;
6651 PyObject * obj0 = 0 ;
6652 char *kwnames[] = {
6653 (char *) "self", NULL
6654 };
6655
6656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6658 if (SWIG_arg_fail(1)) SWIG_fail;
6659 {
6660 PyThreadState* __tstate = wxPyBeginAllowThreads();
6661 result = (arg1)->GetSize();
6662
6663 wxPyEndAllowThreads(__tstate);
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 {
6667 wxSize * resultptr;
6668 resultptr = new wxSize((wxSize &)(result));
6669 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6670 }
6671 return resultobj;
6672 fail:
6673 return NULL;
6674 }
6675
6676
6677 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6678 PyObject *resultobj;
6679 wxCaret *arg1 = (wxCaret *) 0 ;
6680 int *arg2 = (int *) 0 ;
6681 int *arg3 = (int *) 0 ;
6682 int temp2 ;
6683 int res2 = 0 ;
6684 int temp3 ;
6685 int res3 = 0 ;
6686 PyObject * obj0 = 0 ;
6687 char *kwnames[] = {
6688 (char *) "self", NULL
6689 };
6690
6691 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6692 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6695 if (SWIG_arg_fail(1)) SWIG_fail;
6696 {
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 (arg1)->GetSize(arg2,arg3);
6699
6700 wxPyEndAllowThreads(__tstate);
6701 if (PyErr_Occurred()) SWIG_fail;
6702 }
6703 Py_INCREF(Py_None); resultobj = Py_None;
6704 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6705 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6706 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6707 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj;
6716 wxCaret *arg1 = (wxCaret *) 0 ;
6717 wxWindow *result;
6718 PyObject * obj0 = 0 ;
6719 char *kwnames[] = {
6720 (char *) "self", NULL
6721 };
6722
6723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6725 if (SWIG_arg_fail(1)) SWIG_fail;
6726 {
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 result = (wxWindow *)(arg1)->GetWindow();
6729
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 {
6734 resultobj = wxPyMake_wxObject(result, 0);
6735 }
6736 return resultobj;
6737 fail:
6738 return NULL;
6739 }
6740
6741
6742 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6743 PyObject *resultobj;
6744 wxCaret *arg1 = (wxCaret *) 0 ;
6745 int arg2 ;
6746 int arg3 ;
6747 PyObject * obj0 = 0 ;
6748 PyObject * obj1 = 0 ;
6749 PyObject * obj2 = 0 ;
6750 char *kwnames[] = {
6751 (char *) "self",(char *) "x",(char *) "y", NULL
6752 };
6753
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6756 if (SWIG_arg_fail(1)) SWIG_fail;
6757 {
6758 arg2 = (int)(SWIG_As_int(obj1));
6759 if (SWIG_arg_fail(2)) SWIG_fail;
6760 }
6761 {
6762 arg3 = (int)(SWIG_As_int(obj2));
6763 if (SWIG_arg_fail(3)) SWIG_fail;
6764 }
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 (arg1)->Move(arg2,arg3);
6768
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 Py_INCREF(Py_None); resultobj = Py_None;
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6780 PyObject *resultobj;
6781 wxCaret *arg1 = (wxCaret *) 0 ;
6782 wxPoint *arg2 = 0 ;
6783 wxPoint temp2 ;
6784 PyObject * obj0 = 0 ;
6785 PyObject * obj1 = 0 ;
6786 char *kwnames[] = {
6787 (char *) "self",(char *) "pt", NULL
6788 };
6789
6790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6792 if (SWIG_arg_fail(1)) SWIG_fail;
6793 {
6794 arg2 = &temp2;
6795 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6796 }
6797 {
6798 PyThreadState* __tstate = wxPyBeginAllowThreads();
6799 (arg1)->Move((wxPoint const &)*arg2);
6800
6801 wxPyEndAllowThreads(__tstate);
6802 if (PyErr_Occurred()) SWIG_fail;
6803 }
6804 Py_INCREF(Py_None); resultobj = Py_None;
6805 return resultobj;
6806 fail:
6807 return NULL;
6808 }
6809
6810
6811 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6812 PyObject *resultobj;
6813 wxCaret *arg1 = (wxCaret *) 0 ;
6814 int arg2 ;
6815 int arg3 ;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 PyObject * obj2 = 0 ;
6819 char *kwnames[] = {
6820 (char *) "self",(char *) "width",(char *) "height", NULL
6821 };
6822
6823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6825 if (SWIG_arg_fail(1)) SWIG_fail;
6826 {
6827 arg2 = (int)(SWIG_As_int(obj1));
6828 if (SWIG_arg_fail(2)) SWIG_fail;
6829 }
6830 {
6831 arg3 = (int)(SWIG_As_int(obj2));
6832 if (SWIG_arg_fail(3)) SWIG_fail;
6833 }
6834 {
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 (arg1)->SetSize(arg2,arg3);
6837
6838 wxPyEndAllowThreads(__tstate);
6839 if (PyErr_Occurred()) SWIG_fail;
6840 }
6841 Py_INCREF(Py_None); resultobj = Py_None;
6842 return resultobj;
6843 fail:
6844 return NULL;
6845 }
6846
6847
6848 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6849 PyObject *resultobj;
6850 wxCaret *arg1 = (wxCaret *) 0 ;
6851 wxSize *arg2 = 0 ;
6852 wxSize temp2 ;
6853 PyObject * obj0 = 0 ;
6854 PyObject * obj1 = 0 ;
6855 char *kwnames[] = {
6856 (char *) "self",(char *) "size", NULL
6857 };
6858
6859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6861 if (SWIG_arg_fail(1)) SWIG_fail;
6862 {
6863 arg2 = &temp2;
6864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6865 }
6866 {
6867 PyThreadState* __tstate = wxPyBeginAllowThreads();
6868 (arg1)->SetSize((wxSize const &)*arg2);
6869
6870 wxPyEndAllowThreads(__tstate);
6871 if (PyErr_Occurred()) SWIG_fail;
6872 }
6873 Py_INCREF(Py_None); resultobj = Py_None;
6874 return resultobj;
6875 fail:
6876 return NULL;
6877 }
6878
6879
6880 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6881 PyObject *resultobj;
6882 wxCaret *arg1 = (wxCaret *) 0 ;
6883 int arg2 = (int) true ;
6884 PyObject * obj0 = 0 ;
6885 PyObject * obj1 = 0 ;
6886 char *kwnames[] = {
6887 (char *) "self",(char *) "show", NULL
6888 };
6889
6890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6892 if (SWIG_arg_fail(1)) SWIG_fail;
6893 if (obj1) {
6894 {
6895 arg2 = (int)(SWIG_As_int(obj1));
6896 if (SWIG_arg_fail(2)) SWIG_fail;
6897 }
6898 }
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 (arg1)->Show(arg2);
6902
6903 wxPyEndAllowThreads(__tstate);
6904 if (PyErr_Occurred()) SWIG_fail;
6905 }
6906 Py_INCREF(Py_None); resultobj = Py_None;
6907 return resultobj;
6908 fail:
6909 return NULL;
6910 }
6911
6912
6913 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6914 PyObject *resultobj;
6915 wxCaret *arg1 = (wxCaret *) 0 ;
6916 PyObject * obj0 = 0 ;
6917 char *kwnames[] = {
6918 (char *) "self", NULL
6919 };
6920
6921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6923 if (SWIG_arg_fail(1)) SWIG_fail;
6924 {
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 (arg1)->Hide();
6927
6928 wxPyEndAllowThreads(__tstate);
6929 if (PyErr_Occurred()) SWIG_fail;
6930 }
6931 Py_INCREF(Py_None); resultobj = Py_None;
6932 return resultobj;
6933 fail:
6934 return NULL;
6935 }
6936
6937
6938 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6939 PyObject *resultobj;
6940 int result;
6941 char *kwnames[] = {
6942 NULL
6943 };
6944
6945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6946 {
6947 PyThreadState* __tstate = wxPyBeginAllowThreads();
6948 result = (int)wxCaret::GetBlinkTime();
6949
6950 wxPyEndAllowThreads(__tstate);
6951 if (PyErr_Occurred()) SWIG_fail;
6952 }
6953 {
6954 resultobj = SWIG_From_int((int)(result));
6955 }
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6963 PyObject *resultobj;
6964 int arg1 ;
6965 PyObject * obj0 = 0 ;
6966 char *kwnames[] = {
6967 (char *) "milliseconds", NULL
6968 };
6969
6970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6971 {
6972 arg1 = (int)(SWIG_As_int(obj0));
6973 if (SWIG_arg_fail(1)) SWIG_fail;
6974 }
6975 {
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 wxCaret::SetBlinkTime(arg1);
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 Py_INCREF(Py_None); resultobj = Py_None;
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6990 PyObject *obj;
6991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6992 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6993 Py_INCREF(obj);
6994 return Py_BuildValue((char *)"");
6995 }
6996 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj;
6998 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6999 wxBusyCursor *result;
7000 PyObject * obj0 = 0 ;
7001 char *kwnames[] = {
7002 (char *) "cursor", NULL
7003 };
7004
7005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7006 if (obj0) {
7007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7008 if (SWIG_arg_fail(1)) SWIG_fail;
7009 }
7010 {
7011 if (!wxPyCheckForApp()) SWIG_fail;
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7014
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj;
7027 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7028 PyObject * obj0 = 0 ;
7029 char *kwnames[] = {
7030 (char *) "self", NULL
7031 };
7032
7033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7035 if (SWIG_arg_fail(1)) SWIG_fail;
7036 {
7037 PyThreadState* __tstate = wxPyBeginAllowThreads();
7038 delete arg1;
7039
7040 wxPyEndAllowThreads(__tstate);
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 Py_INCREF(Py_None); resultobj = Py_None;
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7051 PyObject *obj;
7052 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7053 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7054 Py_INCREF(obj);
7055 return Py_BuildValue((char *)"");
7056 }
7057 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7058 PyObject *resultobj;
7059 wxWindow *arg1 = (wxWindow *) NULL ;
7060 wxWindowDisabler *result;
7061 PyObject * obj0 = 0 ;
7062 char *kwnames[] = {
7063 (char *) "winToSkip", NULL
7064 };
7065
7066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7067 if (obj0) {
7068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7069 if (SWIG_arg_fail(1)) SWIG_fail;
7070 }
7071 {
7072 if (!wxPyCheckForApp()) SWIG_fail;
7073 PyThreadState* __tstate = wxPyBeginAllowThreads();
7074 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7075
7076 wxPyEndAllowThreads(__tstate);
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7080 return resultobj;
7081 fail:
7082 return NULL;
7083 }
7084
7085
7086 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7087 PyObject *resultobj;
7088 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7089 PyObject * obj0 = 0 ;
7090 char *kwnames[] = {
7091 (char *) "self", NULL
7092 };
7093
7094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7096 if (SWIG_arg_fail(1)) SWIG_fail;
7097 {
7098 PyThreadState* __tstate = wxPyBeginAllowThreads();
7099 delete arg1;
7100
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 Py_INCREF(Py_None); resultobj = Py_None;
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7112 PyObject *obj;
7113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7114 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7115 Py_INCREF(obj);
7116 return Py_BuildValue((char *)"");
7117 }
7118 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7119 PyObject *resultobj;
7120 wxString *arg1 = 0 ;
7121 wxBusyInfo *result;
7122 bool temp1 = false ;
7123 PyObject * obj0 = 0 ;
7124 char *kwnames[] = {
7125 (char *) "message", NULL
7126 };
7127
7128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7129 {
7130 arg1 = wxString_in_helper(obj0);
7131 if (arg1 == NULL) SWIG_fail;
7132 temp1 = true;
7133 }
7134 {
7135 if (!wxPyCheckForApp()) SWIG_fail;
7136 PyThreadState* __tstate = wxPyBeginAllowThreads();
7137 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7138
7139 wxPyEndAllowThreads(__tstate);
7140 if (PyErr_Occurred()) SWIG_fail;
7141 }
7142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7143 {
7144 if (temp1)
7145 delete arg1;
7146 }
7147 return resultobj;
7148 fail:
7149 {
7150 if (temp1)
7151 delete arg1;
7152 }
7153 return NULL;
7154 }
7155
7156
7157 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj;
7159 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7160 PyObject * obj0 = 0 ;
7161 char *kwnames[] = {
7162 (char *) "self", NULL
7163 };
7164
7165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7167 if (SWIG_arg_fail(1)) SWIG_fail;
7168 {
7169 PyThreadState* __tstate = wxPyBeginAllowThreads();
7170 delete arg1;
7171
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 Py_INCREF(Py_None); resultobj = Py_None;
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7183 PyObject *obj;
7184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7185 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7186 Py_INCREF(obj);
7187 return Py_BuildValue((char *)"");
7188 }
7189 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7190 PyObject *resultobj;
7191 wxStopWatch *result;
7192 char *kwnames[] = {
7193 NULL
7194 };
7195
7196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7197 {
7198 PyThreadState* __tstate = wxPyBeginAllowThreads();
7199 result = (wxStopWatch *)new wxStopWatch();
7200
7201 wxPyEndAllowThreads(__tstate);
7202 if (PyErr_Occurred()) SWIG_fail;
7203 }
7204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7205 return resultobj;
7206 fail:
7207 return NULL;
7208 }
7209
7210
7211 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7212 PyObject *resultobj;
7213 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7214 long arg2 = (long) 0 ;
7215 PyObject * obj0 = 0 ;
7216 PyObject * obj1 = 0 ;
7217 char *kwnames[] = {
7218 (char *) "self",(char *) "t0", NULL
7219 };
7220
7221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7223 if (SWIG_arg_fail(1)) SWIG_fail;
7224 if (obj1) {
7225 {
7226 arg2 = (long)(SWIG_As_long(obj1));
7227 if (SWIG_arg_fail(2)) SWIG_fail;
7228 }
7229 }
7230 {
7231 PyThreadState* __tstate = wxPyBeginAllowThreads();
7232 (arg1)->Start(arg2);
7233
7234 wxPyEndAllowThreads(__tstate);
7235 if (PyErr_Occurred()) SWIG_fail;
7236 }
7237 Py_INCREF(Py_None); resultobj = Py_None;
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj;
7246 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7247 PyObject * obj0 = 0 ;
7248 char *kwnames[] = {
7249 (char *) "self", NULL
7250 };
7251
7252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7254 if (SWIG_arg_fail(1)) SWIG_fail;
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 (arg1)->Pause();
7258
7259 wxPyEndAllowThreads(__tstate);
7260 if (PyErr_Occurred()) SWIG_fail;
7261 }
7262 Py_INCREF(Py_None); resultobj = Py_None;
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj;
7271 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7272 PyObject * obj0 = 0 ;
7273 char *kwnames[] = {
7274 (char *) "self", NULL
7275 };
7276
7277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7279 if (SWIG_arg_fail(1)) SWIG_fail;
7280 {
7281 PyThreadState* __tstate = wxPyBeginAllowThreads();
7282 (arg1)->Resume();
7283
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 Py_INCREF(Py_None); resultobj = Py_None;
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj;
7296 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7297 long result;
7298 PyObject * obj0 = 0 ;
7299 char *kwnames[] = {
7300 (char *) "self", NULL
7301 };
7302
7303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7305 if (SWIG_arg_fail(1)) SWIG_fail;
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 result = (long)((wxStopWatch const *)arg1)->Time();
7309
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 {
7314 resultobj = SWIG_From_long((long)(result));
7315 }
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7323 PyObject *obj;
7324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7325 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7326 Py_INCREF(obj);
7327 return Py_BuildValue((char *)"");
7328 }
7329 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7330 PyObject *resultobj;
7331 int arg1 = (int) 9 ;
7332 int arg2 = (int) wxID_FILE1 ;
7333 wxFileHistory *result;
7334 PyObject * obj0 = 0 ;
7335 PyObject * obj1 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "maxFiles",(char *) "idBase", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7341 if (obj0) {
7342 {
7343 arg1 = (int)(SWIG_As_int(obj0));
7344 if (SWIG_arg_fail(1)) SWIG_fail;
7345 }
7346 }
7347 if (obj1) {
7348 {
7349 arg2 = (int)(SWIG_As_int(obj1));
7350 if (SWIG_arg_fail(2)) SWIG_fail;
7351 }
7352 }
7353 {
7354 PyThreadState* __tstate = wxPyBeginAllowThreads();
7355 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7356
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj;
7369 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7370 PyObject * obj0 = 0 ;
7371 char *kwnames[] = {
7372 (char *) "self", NULL
7373 };
7374
7375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7377 if (SWIG_arg_fail(1)) SWIG_fail;
7378 {
7379 PyThreadState* __tstate = wxPyBeginAllowThreads();
7380 delete arg1;
7381
7382 wxPyEndAllowThreads(__tstate);
7383 if (PyErr_Occurred()) SWIG_fail;
7384 }
7385 Py_INCREF(Py_None); resultobj = Py_None;
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj;
7394 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7395 wxString *arg2 = 0 ;
7396 bool temp2 = false ;
7397 PyObject * obj0 = 0 ;
7398 PyObject * obj1 = 0 ;
7399 char *kwnames[] = {
7400 (char *) "self",(char *) "file", NULL
7401 };
7402
7403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7405 if (SWIG_arg_fail(1)) SWIG_fail;
7406 {
7407 arg2 = wxString_in_helper(obj1);
7408 if (arg2 == NULL) SWIG_fail;
7409 temp2 = true;
7410 }
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 (arg1)->AddFileToHistory((wxString const &)*arg2);
7414
7415 wxPyEndAllowThreads(__tstate);
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 Py_INCREF(Py_None); resultobj = Py_None;
7419 {
7420 if (temp2)
7421 delete arg2;
7422 }
7423 return resultobj;
7424 fail:
7425 {
7426 if (temp2)
7427 delete arg2;
7428 }
7429 return NULL;
7430 }
7431
7432
7433 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7434 PyObject *resultobj;
7435 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7436 int arg2 ;
7437 PyObject * obj0 = 0 ;
7438 PyObject * obj1 = 0 ;
7439 char *kwnames[] = {
7440 (char *) "self",(char *) "i", NULL
7441 };
7442
7443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7445 if (SWIG_arg_fail(1)) SWIG_fail;
7446 {
7447 arg2 = (int)(SWIG_As_int(obj1));
7448 if (SWIG_arg_fail(2)) SWIG_fail;
7449 }
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 (arg1)->RemoveFileFromHistory(arg2);
7453
7454 wxPyEndAllowThreads(__tstate);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 Py_INCREF(Py_None); resultobj = Py_None;
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7465 PyObject *resultobj;
7466 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7467 int result;
7468 PyObject * obj0 = 0 ;
7469 char *kwnames[] = {
7470 (char *) "self", NULL
7471 };
7472
7473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7475 if (SWIG_arg_fail(1)) SWIG_fail;
7476 {
7477 PyThreadState* __tstate = wxPyBeginAllowThreads();
7478 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7479
7480 wxPyEndAllowThreads(__tstate);
7481 if (PyErr_Occurred()) SWIG_fail;
7482 }
7483 {
7484 resultobj = SWIG_From_int((int)(result));
7485 }
7486 return resultobj;
7487 fail:
7488 return NULL;
7489 }
7490
7491
7492 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7493 PyObject *resultobj;
7494 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7495 wxMenu *arg2 = (wxMenu *) 0 ;
7496 PyObject * obj0 = 0 ;
7497 PyObject * obj1 = 0 ;
7498 char *kwnames[] = {
7499 (char *) "self",(char *) "menu", NULL
7500 };
7501
7502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7504 if (SWIG_arg_fail(1)) SWIG_fail;
7505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7506 if (SWIG_arg_fail(2)) SWIG_fail;
7507 {
7508 PyThreadState* __tstate = wxPyBeginAllowThreads();
7509 (arg1)->UseMenu(arg2);
7510
7511 wxPyEndAllowThreads(__tstate);
7512 if (PyErr_Occurred()) SWIG_fail;
7513 }
7514 Py_INCREF(Py_None); resultobj = Py_None;
7515 return resultobj;
7516 fail:
7517 return NULL;
7518 }
7519
7520
7521 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7522 PyObject *resultobj;
7523 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7524 wxMenu *arg2 = (wxMenu *) 0 ;
7525 PyObject * obj0 = 0 ;
7526 PyObject * obj1 = 0 ;
7527 char *kwnames[] = {
7528 (char *) "self",(char *) "menu", NULL
7529 };
7530
7531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7533 if (SWIG_arg_fail(1)) SWIG_fail;
7534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7535 if (SWIG_arg_fail(2)) SWIG_fail;
7536 {
7537 PyThreadState* __tstate = wxPyBeginAllowThreads();
7538 (arg1)->RemoveMenu(arg2);
7539
7540 wxPyEndAllowThreads(__tstate);
7541 if (PyErr_Occurred()) SWIG_fail;
7542 }
7543 Py_INCREF(Py_None); resultobj = Py_None;
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7551 PyObject *resultobj;
7552 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7553 wxConfigBase *arg2 = 0 ;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 char *kwnames[] = {
7557 (char *) "self",(char *) "config", NULL
7558 };
7559
7560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7562 if (SWIG_arg_fail(1)) SWIG_fail;
7563 {
7564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7565 if (SWIG_arg_fail(2)) SWIG_fail;
7566 if (arg2 == NULL) {
7567 SWIG_null_ref("wxConfigBase");
7568 }
7569 if (SWIG_arg_fail(2)) SWIG_fail;
7570 }
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 (arg1)->Load(*arg2);
7574
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 Py_INCREF(Py_None); resultobj = Py_None;
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj;
7587 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7588 wxConfigBase *arg2 = 0 ;
7589 PyObject * obj0 = 0 ;
7590 PyObject * obj1 = 0 ;
7591 char *kwnames[] = {
7592 (char *) "self",(char *) "config", NULL
7593 };
7594
7595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7597 if (SWIG_arg_fail(1)) SWIG_fail;
7598 {
7599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7600 if (SWIG_arg_fail(2)) SWIG_fail;
7601 if (arg2 == NULL) {
7602 SWIG_null_ref("wxConfigBase");
7603 }
7604 if (SWIG_arg_fail(2)) SWIG_fail;
7605 }
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 (arg1)->Save(*arg2);
7609
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 Py_INCREF(Py_None); resultobj = Py_None;
7614 return resultobj;
7615 fail:
7616 return NULL;
7617 }
7618
7619
7620 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7621 PyObject *resultobj;
7622 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7623 PyObject * obj0 = 0 ;
7624 char *kwnames[] = {
7625 (char *) "self", NULL
7626 };
7627
7628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7630 if (SWIG_arg_fail(1)) SWIG_fail;
7631 {
7632 PyThreadState* __tstate = wxPyBeginAllowThreads();
7633 (arg1)->AddFilesToMenu();
7634
7635 wxPyEndAllowThreads(__tstate);
7636 if (PyErr_Occurred()) SWIG_fail;
7637 }
7638 Py_INCREF(Py_None); resultobj = Py_None;
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7646 PyObject *resultobj;
7647 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7648 wxMenu *arg2 = (wxMenu *) 0 ;
7649 PyObject * obj0 = 0 ;
7650 PyObject * obj1 = 0 ;
7651 char *kwnames[] = {
7652 (char *) "self",(char *) "menu", NULL
7653 };
7654
7655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7657 if (SWIG_arg_fail(1)) SWIG_fail;
7658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7659 if (SWIG_arg_fail(2)) SWIG_fail;
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 (arg1)->AddFilesToMenu(arg2);
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 Py_INCREF(Py_None); resultobj = Py_None;
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj;
7676 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7677 int arg2 ;
7678 wxString result;
7679 PyObject * obj0 = 0 ;
7680 PyObject * obj1 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self",(char *) "i", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 arg2 = (int)(SWIG_As_int(obj1));
7690 if (SWIG_arg_fail(2)) SWIG_fail;
7691 }
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7695
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 {
7700 #if wxUSE_UNICODE
7701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7702 #else
7703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7704 #endif
7705 }
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj;
7714 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7715 int result;
7716 PyObject * obj0 = 0 ;
7717 char *kwnames[] = {
7718 (char *) "self", NULL
7719 };
7720
7721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7723 if (SWIG_arg_fail(1)) SWIG_fail;
7724 {
7725 PyThreadState* __tstate = wxPyBeginAllowThreads();
7726 result = (int)((wxFileHistory const *)arg1)->GetCount();
7727
7728 wxPyEndAllowThreads(__tstate);
7729 if (PyErr_Occurred()) SWIG_fail;
7730 }
7731 {
7732 resultobj = SWIG_From_int((int)(result));
7733 }
7734 return resultobj;
7735 fail:
7736 return NULL;
7737 }
7738
7739
7740 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7741 PyObject *obj;
7742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7743 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7744 Py_INCREF(obj);
7745 return Py_BuildValue((char *)"");
7746 }
7747 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7748 PyObject *resultobj;
7749 wxString *arg1 = 0 ;
7750 wxString const &arg2_defvalue = wxPyEmptyString ;
7751 wxString *arg2 = (wxString *) &arg2_defvalue ;
7752 wxSingleInstanceChecker *result;
7753 bool temp1 = false ;
7754 bool temp2 = false ;
7755 PyObject * obj0 = 0 ;
7756 PyObject * obj1 = 0 ;
7757 char *kwnames[] = {
7758 (char *) "name",(char *) "path", NULL
7759 };
7760
7761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7762 {
7763 arg1 = wxString_in_helper(obj0);
7764 if (arg1 == NULL) SWIG_fail;
7765 temp1 = true;
7766 }
7767 if (obj1) {
7768 {
7769 arg2 = wxString_in_helper(obj1);
7770 if (arg2 == NULL) SWIG_fail;
7771 temp2 = true;
7772 }
7773 }
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7777
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7782 {
7783 if (temp1)
7784 delete arg1;
7785 }
7786 {
7787 if (temp2)
7788 delete arg2;
7789 }
7790 return resultobj;
7791 fail:
7792 {
7793 if (temp1)
7794 delete arg1;
7795 }
7796 {
7797 if (temp2)
7798 delete arg2;
7799 }
7800 return NULL;
7801 }
7802
7803
7804 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7805 PyObject *resultobj;
7806 wxSingleInstanceChecker *result;
7807 char *kwnames[] = {
7808 NULL
7809 };
7810
7811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7812 {
7813 PyThreadState* __tstate = wxPyBeginAllowThreads();
7814 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7815
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7820 return resultobj;
7821 fail:
7822 return NULL;
7823 }
7824
7825
7826 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7827 PyObject *resultobj;
7828 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7829 PyObject * obj0 = 0 ;
7830 char *kwnames[] = {
7831 (char *) "self", NULL
7832 };
7833
7834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7836 if (SWIG_arg_fail(1)) SWIG_fail;
7837 {
7838 PyThreadState* __tstate = wxPyBeginAllowThreads();
7839 delete arg1;
7840
7841 wxPyEndAllowThreads(__tstate);
7842 if (PyErr_Occurred()) SWIG_fail;
7843 }
7844 Py_INCREF(Py_None); resultobj = Py_None;
7845 return resultobj;
7846 fail:
7847 return NULL;
7848 }
7849
7850
7851 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7852 PyObject *resultobj;
7853 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7854 wxString *arg2 = 0 ;
7855 wxString const &arg3_defvalue = wxPyEmptyString ;
7856 wxString *arg3 = (wxString *) &arg3_defvalue ;
7857 bool result;
7858 bool temp2 = false ;
7859 bool temp3 = false ;
7860 PyObject * obj0 = 0 ;
7861 PyObject * obj1 = 0 ;
7862 PyObject * obj2 = 0 ;
7863 char *kwnames[] = {
7864 (char *) "self",(char *) "name",(char *) "path", NULL
7865 };
7866
7867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7869 if (SWIG_arg_fail(1)) SWIG_fail;
7870 {
7871 arg2 = wxString_in_helper(obj1);
7872 if (arg2 == NULL) SWIG_fail;
7873 temp2 = true;
7874 }
7875 if (obj2) {
7876 {
7877 arg3 = wxString_in_helper(obj2);
7878 if (arg3 == NULL) SWIG_fail;
7879 temp3 = true;
7880 }
7881 }
7882 {
7883 PyThreadState* __tstate = wxPyBeginAllowThreads();
7884 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7885
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 {
7890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7891 }
7892 {
7893 if (temp2)
7894 delete arg2;
7895 }
7896 {
7897 if (temp3)
7898 delete arg3;
7899 }
7900 return resultobj;
7901 fail:
7902 {
7903 if (temp2)
7904 delete arg2;
7905 }
7906 {
7907 if (temp3)
7908 delete arg3;
7909 }
7910 return NULL;
7911 }
7912
7913
7914 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7915 PyObject *resultobj;
7916 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7917 bool result;
7918 PyObject * obj0 = 0 ;
7919 char *kwnames[] = {
7920 (char *) "self", NULL
7921 };
7922
7923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7925 if (SWIG_arg_fail(1)) SWIG_fail;
7926 {
7927 PyThreadState* __tstate = wxPyBeginAllowThreads();
7928 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7929
7930 wxPyEndAllowThreads(__tstate);
7931 if (PyErr_Occurred()) SWIG_fail;
7932 }
7933 {
7934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7935 }
7936 return resultobj;
7937 fail:
7938 return NULL;
7939 }
7940
7941
7942 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7943 PyObject *obj;
7944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7945 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7946 Py_INCREF(obj);
7947 return Py_BuildValue((char *)"");
7948 }
7949 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7950 PyObject *resultobj;
7951 wxWindow *arg1 = (wxWindow *) 0 ;
7952 wxDC *arg2 = 0 ;
7953 bool result;
7954 PyObject * obj0 = 0 ;
7955 PyObject * obj1 = 0 ;
7956 char *kwnames[] = {
7957 (char *) "window",(char *) "dc", NULL
7958 };
7959
7960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7962 if (SWIG_arg_fail(1)) SWIG_fail;
7963 {
7964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7965 if (SWIG_arg_fail(2)) SWIG_fail;
7966 if (arg2 == NULL) {
7967 SWIG_null_ref("wxDC");
7968 }
7969 if (SWIG_arg_fail(2)) SWIG_fail;
7970 }
7971 {
7972 PyThreadState* __tstate = wxPyBeginAllowThreads();
7973 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7974
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 {
7979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7980 }
7981 return resultobj;
7982 fail:
7983 return NULL;
7984 }
7985
7986
7987 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7988 PyObject *resultobj;
7989 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7990 PyObject * obj0 = 0 ;
7991 char *kwnames[] = {
7992 (char *) "self", NULL
7993 };
7994
7995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7997 if (SWIG_arg_fail(1)) SWIG_fail;
7998 {
7999 PyThreadState* __tstate = wxPyBeginAllowThreads();
8000 delete arg1;
8001
8002 wxPyEndAllowThreads(__tstate);
8003 if (PyErr_Occurred()) SWIG_fail;
8004 }
8005 Py_INCREF(Py_None); resultobj = Py_None;
8006 return resultobj;
8007 fail:
8008 return NULL;
8009 }
8010
8011
8012 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8013 PyObject *resultobj;
8014 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8015 wxString result;
8016 PyObject * obj0 = 0 ;
8017 char *kwnames[] = {
8018 (char *) "self", NULL
8019 };
8020
8021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8023 if (SWIG_arg_fail(1)) SWIG_fail;
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = (arg1)->GetTip();
8027
8028 wxPyEndAllowThreads(__tstate);
8029 if (PyErr_Occurred()) SWIG_fail;
8030 }
8031 {
8032 #if wxUSE_UNICODE
8033 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8034 #else
8035 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8036 #endif
8037 }
8038 return resultobj;
8039 fail:
8040 return NULL;
8041 }
8042
8043
8044 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8045 PyObject *resultobj;
8046 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8047 size_t result;
8048 PyObject * obj0 = 0 ;
8049 char *kwnames[] = {
8050 (char *) "self", NULL
8051 };
8052
8053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8055 if (SWIG_arg_fail(1)) SWIG_fail;
8056 {
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 result = (size_t)(arg1)->GetCurrentTip();
8059
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 {
8064 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8065 }
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8073 PyObject *resultobj;
8074 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8075 wxString *arg2 = 0 ;
8076 wxString result;
8077 bool temp2 = false ;
8078 PyObject * obj0 = 0 ;
8079 PyObject * obj1 = 0 ;
8080 char *kwnames[] = {
8081 (char *) "self",(char *) "tip", NULL
8082 };
8083
8084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8086 if (SWIG_arg_fail(1)) SWIG_fail;
8087 {
8088 arg2 = wxString_in_helper(obj1);
8089 if (arg2 == NULL) SWIG_fail;
8090 temp2 = true;
8091 }
8092 {
8093 PyThreadState* __tstate = wxPyBeginAllowThreads();
8094 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8095
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 {
8100 #if wxUSE_UNICODE
8101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8102 #else
8103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8104 #endif
8105 }
8106 {
8107 if (temp2)
8108 delete arg2;
8109 }
8110 return resultobj;
8111 fail:
8112 {
8113 if (temp2)
8114 delete arg2;
8115 }
8116 return NULL;
8117 }
8118
8119
8120 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8121 PyObject *obj;
8122 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8123 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8124 Py_INCREF(obj);
8125 return Py_BuildValue((char *)"");
8126 }
8127 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8128 PyObject *resultobj;
8129 size_t arg1 ;
8130 wxPyTipProvider *result;
8131 PyObject * obj0 = 0 ;
8132 char *kwnames[] = {
8133 (char *) "currentTip", NULL
8134 };
8135
8136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8137 {
8138 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8139 if (SWIG_arg_fail(1)) SWIG_fail;
8140 }
8141 {
8142 PyThreadState* __tstate = wxPyBeginAllowThreads();
8143 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8144
8145 wxPyEndAllowThreads(__tstate);
8146 if (PyErr_Occurred()) SWIG_fail;
8147 }
8148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8149 return resultobj;
8150 fail:
8151 return NULL;
8152 }
8153
8154
8155 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8156 PyObject *resultobj;
8157 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8158 PyObject *arg2 = (PyObject *) 0 ;
8159 PyObject *arg3 = (PyObject *) 0 ;
8160 PyObject * obj0 = 0 ;
8161 PyObject * obj1 = 0 ;
8162 PyObject * obj2 = 0 ;
8163 char *kwnames[] = {
8164 (char *) "self",(char *) "self",(char *) "_class", NULL
8165 };
8166
8167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8169 if (SWIG_arg_fail(1)) SWIG_fail;
8170 arg2 = obj1;
8171 arg3 = obj2;
8172 {
8173 PyThreadState* __tstate = wxPyBeginAllowThreads();
8174 (arg1)->_setCallbackInfo(arg2,arg3);
8175
8176 wxPyEndAllowThreads(__tstate);
8177 if (PyErr_Occurred()) SWIG_fail;
8178 }
8179 Py_INCREF(Py_None); resultobj = Py_None;
8180 return resultobj;
8181 fail:
8182 return NULL;
8183 }
8184
8185
8186 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8187 PyObject *obj;
8188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8189 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8190 Py_INCREF(obj);
8191 return Py_BuildValue((char *)"");
8192 }
8193 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8194 PyObject *resultobj;
8195 wxWindow *arg1 = (wxWindow *) 0 ;
8196 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8197 bool arg3 = (bool) true ;
8198 bool result;
8199 PyObject * obj0 = 0 ;
8200 PyObject * obj1 = 0 ;
8201 PyObject * obj2 = 0 ;
8202 char *kwnames[] = {
8203 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8204 };
8205
8206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8208 if (SWIG_arg_fail(1)) SWIG_fail;
8209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8210 if (SWIG_arg_fail(2)) SWIG_fail;
8211 if (obj2) {
8212 {
8213 arg3 = (bool)(SWIG_As_bool(obj2));
8214 if (SWIG_arg_fail(3)) SWIG_fail;
8215 }
8216 }
8217 {
8218 if (!wxPyCheckForApp()) SWIG_fail;
8219 PyThreadState* __tstate = wxPyBeginAllowThreads();
8220 result = (bool)wxShowTip(arg1,arg2,arg3);
8221
8222 wxPyEndAllowThreads(__tstate);
8223 if (PyErr_Occurred()) SWIG_fail;
8224 }
8225 {
8226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8227 }
8228 return resultobj;
8229 fail:
8230 return NULL;
8231 }
8232
8233
8234 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8235 PyObject *resultobj;
8236 wxString *arg1 = 0 ;
8237 size_t arg2 ;
8238 wxTipProvider *result;
8239 bool temp1 = false ;
8240 PyObject * obj0 = 0 ;
8241 PyObject * obj1 = 0 ;
8242 char *kwnames[] = {
8243 (char *) "filename",(char *) "currentTip", NULL
8244 };
8245
8246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8247 {
8248 arg1 = wxString_in_helper(obj0);
8249 if (arg1 == NULL) SWIG_fail;
8250 temp1 = true;
8251 }
8252 {
8253 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8254 if (SWIG_arg_fail(2)) SWIG_fail;
8255 }
8256 {
8257 if (!wxPyCheckForApp()) SWIG_fail;
8258 PyThreadState* __tstate = wxPyBeginAllowThreads();
8259 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8260
8261 wxPyEndAllowThreads(__tstate);
8262 if (PyErr_Occurred()) SWIG_fail;
8263 }
8264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8265 {
8266 if (temp1)
8267 delete arg1;
8268 }
8269 return resultobj;
8270 fail:
8271 {
8272 if (temp1)
8273 delete arg1;
8274 }
8275 return NULL;
8276 }
8277
8278
8279 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8280 PyObject *resultobj;
8281 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8282 int arg2 = (int) -1 ;
8283 wxPyTimer *result;
8284 PyObject * obj0 = 0 ;
8285 PyObject * obj1 = 0 ;
8286 char *kwnames[] = {
8287 (char *) "owner",(char *) "id", NULL
8288 };
8289
8290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8291 if (obj0) {
8292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8293 if (SWIG_arg_fail(1)) SWIG_fail;
8294 }
8295 if (obj1) {
8296 {
8297 arg2 = (int)(SWIG_As_int(obj1));
8298 if (SWIG_arg_fail(2)) SWIG_fail;
8299 }
8300 }
8301 {
8302 if (!wxPyCheckForApp()) SWIG_fail;
8303 PyThreadState* __tstate = wxPyBeginAllowThreads();
8304 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8305
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8317 PyObject *resultobj;
8318 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8319 PyObject * obj0 = 0 ;
8320 char *kwnames[] = {
8321 (char *) "self", NULL
8322 };
8323
8324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8326 if (SWIG_arg_fail(1)) SWIG_fail;
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 delete arg1;
8330
8331 wxPyEndAllowThreads(__tstate);
8332 if (PyErr_Occurred()) SWIG_fail;
8333 }
8334 Py_INCREF(Py_None); resultobj = Py_None;
8335 return resultobj;
8336 fail:
8337 return NULL;
8338 }
8339
8340
8341 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8342 PyObject *resultobj;
8343 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8344 PyObject *arg2 = (PyObject *) 0 ;
8345 PyObject *arg3 = (PyObject *) 0 ;
8346 int arg4 = (int) 1 ;
8347 PyObject * obj0 = 0 ;
8348 PyObject * obj1 = 0 ;
8349 PyObject * obj2 = 0 ;
8350 PyObject * obj3 = 0 ;
8351 char *kwnames[] = {
8352 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8353 };
8354
8355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8357 if (SWIG_arg_fail(1)) SWIG_fail;
8358 arg2 = obj1;
8359 arg3 = obj2;
8360 if (obj3) {
8361 {
8362 arg4 = (int)(SWIG_As_int(obj3));
8363 if (SWIG_arg_fail(4)) SWIG_fail;
8364 }
8365 }
8366 {
8367 PyThreadState* __tstate = wxPyBeginAllowThreads();
8368 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8369
8370 wxPyEndAllowThreads(__tstate);
8371 if (PyErr_Occurred()) SWIG_fail;
8372 }
8373 Py_INCREF(Py_None); resultobj = Py_None;
8374 return resultobj;
8375 fail:
8376 return NULL;
8377 }
8378
8379
8380 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8381 PyObject *resultobj;
8382 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8383 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8384 int arg3 = (int) -1 ;
8385 PyObject * obj0 = 0 ;
8386 PyObject * obj1 = 0 ;
8387 PyObject * obj2 = 0 ;
8388 char *kwnames[] = {
8389 (char *) "self",(char *) "owner",(char *) "id", NULL
8390 };
8391
8392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8394 if (SWIG_arg_fail(1)) SWIG_fail;
8395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8396 if (SWIG_arg_fail(2)) SWIG_fail;
8397 if (obj2) {
8398 {
8399 arg3 = (int)(SWIG_As_int(obj2));
8400 if (SWIG_arg_fail(3)) SWIG_fail;
8401 }
8402 }
8403 {
8404 PyThreadState* __tstate = wxPyBeginAllowThreads();
8405 (arg1)->SetOwner(arg2,arg3);
8406
8407 wxPyEndAllowThreads(__tstate);
8408 if (PyErr_Occurred()) SWIG_fail;
8409 }
8410 Py_INCREF(Py_None); resultobj = Py_None;
8411 return resultobj;
8412 fail:
8413 return NULL;
8414 }
8415
8416
8417 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8418 PyObject *resultobj;
8419 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8420 wxEvtHandler *result;
8421 PyObject * obj0 = 0 ;
8422 char *kwnames[] = {
8423 (char *) "self", NULL
8424 };
8425
8426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8428 if (SWIG_arg_fail(1)) SWIG_fail;
8429 {
8430 PyThreadState* __tstate = wxPyBeginAllowThreads();
8431 result = (wxEvtHandler *)(arg1)->GetOwner();
8432
8433 wxPyEndAllowThreads(__tstate);
8434 if (PyErr_Occurred()) SWIG_fail;
8435 }
8436 {
8437 resultobj = wxPyMake_wxObject(result, 0);
8438 }
8439 return resultobj;
8440 fail:
8441 return NULL;
8442 }
8443
8444
8445 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8446 PyObject *resultobj;
8447 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8448 int arg2 = (int) -1 ;
8449 bool arg3 = (bool) false ;
8450 bool result;
8451 PyObject * obj0 = 0 ;
8452 PyObject * obj1 = 0 ;
8453 PyObject * obj2 = 0 ;
8454 char *kwnames[] = {
8455 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8456 };
8457
8458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8460 if (SWIG_arg_fail(1)) SWIG_fail;
8461 if (obj1) {
8462 {
8463 arg2 = (int)(SWIG_As_int(obj1));
8464 if (SWIG_arg_fail(2)) SWIG_fail;
8465 }
8466 }
8467 if (obj2) {
8468 {
8469 arg3 = (bool)(SWIG_As_bool(obj2));
8470 if (SWIG_arg_fail(3)) SWIG_fail;
8471 }
8472 }
8473 {
8474 PyThreadState* __tstate = wxPyBeginAllowThreads();
8475 result = (bool)(arg1)->Start(arg2,arg3);
8476
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 {
8481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8482 }
8483 return resultobj;
8484 fail:
8485 return NULL;
8486 }
8487
8488
8489 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8490 PyObject *resultobj;
8491 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8492 PyObject * obj0 = 0 ;
8493 char *kwnames[] = {
8494 (char *) "self", NULL
8495 };
8496
8497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8499 if (SWIG_arg_fail(1)) SWIG_fail;
8500 {
8501 PyThreadState* __tstate = wxPyBeginAllowThreads();
8502 (arg1)->Stop();
8503
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 Py_INCREF(Py_None); resultobj = Py_None;
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8515 PyObject *resultobj;
8516 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8517 bool result;
8518 PyObject * obj0 = 0 ;
8519 char *kwnames[] = {
8520 (char *) "self", NULL
8521 };
8522
8523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8525 if (SWIG_arg_fail(1)) SWIG_fail;
8526 {
8527 PyThreadState* __tstate = wxPyBeginAllowThreads();
8528 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8529
8530 wxPyEndAllowThreads(__tstate);
8531 if (PyErr_Occurred()) SWIG_fail;
8532 }
8533 {
8534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8535 }
8536 return resultobj;
8537 fail:
8538 return NULL;
8539 }
8540
8541
8542 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8543 PyObject *resultobj;
8544 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8545 int result;
8546 PyObject * obj0 = 0 ;
8547 char *kwnames[] = {
8548 (char *) "self", NULL
8549 };
8550
8551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8553 if (SWIG_arg_fail(1)) SWIG_fail;
8554 {
8555 PyThreadState* __tstate = wxPyBeginAllowThreads();
8556 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8557
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 {
8562 resultobj = SWIG_From_int((int)(result));
8563 }
8564 return resultobj;
8565 fail:
8566 return NULL;
8567 }
8568
8569
8570 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8571 PyObject *resultobj;
8572 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8573 bool result;
8574 PyObject * obj0 = 0 ;
8575 char *kwnames[] = {
8576 (char *) "self", NULL
8577 };
8578
8579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8581 if (SWIG_arg_fail(1)) SWIG_fail;
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8585
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 {
8590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8591 }
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj;
8600 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8601 int result;
8602 PyObject * obj0 = 0 ;
8603 char *kwnames[] = {
8604 (char *) "self", NULL
8605 };
8606
8607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8609 if (SWIG_arg_fail(1)) SWIG_fail;
8610 {
8611 PyThreadState* __tstate = wxPyBeginAllowThreads();
8612 result = (int)((wxPyTimer const *)arg1)->GetId();
8613
8614 wxPyEndAllowThreads(__tstate);
8615 if (PyErr_Occurred()) SWIG_fail;
8616 }
8617 {
8618 resultobj = SWIG_From_int((int)(result));
8619 }
8620 return resultobj;
8621 fail:
8622 return NULL;
8623 }
8624
8625
8626 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8627 PyObject *obj;
8628 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8629 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8630 Py_INCREF(obj);
8631 return Py_BuildValue((char *)"");
8632 }
8633 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8634 PyObject *resultobj;
8635 int arg1 = (int) 0 ;
8636 int arg2 = (int) 0 ;
8637 wxTimerEvent *result;
8638 PyObject * obj0 = 0 ;
8639 PyObject * obj1 = 0 ;
8640 char *kwnames[] = {
8641 (char *) "timerid",(char *) "interval", NULL
8642 };
8643
8644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8645 if (obj0) {
8646 {
8647 arg1 = (int)(SWIG_As_int(obj0));
8648 if (SWIG_arg_fail(1)) SWIG_fail;
8649 }
8650 }
8651 if (obj1) {
8652 {
8653 arg2 = (int)(SWIG_As_int(obj1));
8654 if (SWIG_arg_fail(2)) SWIG_fail;
8655 }
8656 }
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8660
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8665 return resultobj;
8666 fail:
8667 return NULL;
8668 }
8669
8670
8671 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8672 PyObject *resultobj;
8673 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8674 int result;
8675 PyObject * obj0 = 0 ;
8676 char *kwnames[] = {
8677 (char *) "self", NULL
8678 };
8679
8680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8682 if (SWIG_arg_fail(1)) SWIG_fail;
8683 {
8684 PyThreadState* __tstate = wxPyBeginAllowThreads();
8685 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8686
8687 wxPyEndAllowThreads(__tstate);
8688 if (PyErr_Occurred()) SWIG_fail;
8689 }
8690 {
8691 resultobj = SWIG_From_int((int)(result));
8692 }
8693 return resultobj;
8694 fail:
8695 return NULL;
8696 }
8697
8698
8699 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8700 PyObject *obj;
8701 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8702 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8703 Py_INCREF(obj);
8704 return Py_BuildValue((char *)"");
8705 }
8706 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8707 PyObject *resultobj;
8708 wxTimer *arg1 = 0 ;
8709 wxTimerRunner *result;
8710 PyObject * obj0 = 0 ;
8711
8712 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8713 {
8714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8715 if (SWIG_arg_fail(1)) SWIG_fail;
8716 if (arg1 == NULL) {
8717 SWIG_null_ref("wxTimer");
8718 }
8719 if (SWIG_arg_fail(1)) SWIG_fail;
8720 }
8721 {
8722 if (!wxPyCheckForApp()) SWIG_fail;
8723 PyThreadState* __tstate = wxPyBeginAllowThreads();
8724 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8725
8726 wxPyEndAllowThreads(__tstate);
8727 if (PyErr_Occurred()) SWIG_fail;
8728 }
8729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8737 PyObject *resultobj;
8738 wxTimer *arg1 = 0 ;
8739 int arg2 ;
8740 bool arg3 = (bool) false ;
8741 wxTimerRunner *result;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 PyObject * obj2 = 0 ;
8745
8746 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8747 {
8748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8749 if (SWIG_arg_fail(1)) SWIG_fail;
8750 if (arg1 == NULL) {
8751 SWIG_null_ref("wxTimer");
8752 }
8753 if (SWIG_arg_fail(1)) SWIG_fail;
8754 }
8755 {
8756 arg2 = (int)(SWIG_As_int(obj1));
8757 if (SWIG_arg_fail(2)) SWIG_fail;
8758 }
8759 if (obj2) {
8760 {
8761 arg3 = (bool)(SWIG_As_bool(obj2));
8762 if (SWIG_arg_fail(3)) SWIG_fail;
8763 }
8764 }
8765 {
8766 if (!wxPyCheckForApp()) SWIG_fail;
8767 PyThreadState* __tstate = wxPyBeginAllowThreads();
8768 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8769
8770 wxPyEndAllowThreads(__tstate);
8771 if (PyErr_Occurred()) SWIG_fail;
8772 }
8773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8774 return resultobj;
8775 fail:
8776 return NULL;
8777 }
8778
8779
8780 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8781 int argc;
8782 PyObject *argv[4];
8783 int ii;
8784
8785 argc = PyObject_Length(args);
8786 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8787 argv[ii] = PyTuple_GetItem(args,ii);
8788 }
8789 if (argc == 1) {
8790 int _v;
8791 {
8792 void *ptr = 0;
8793 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8794 _v = 0;
8795 PyErr_Clear();
8796 } else {
8797 _v = (ptr != 0);
8798 }
8799 }
8800 if (_v) {
8801 return _wrap_new_TimerRunner__SWIG_0(self,args);
8802 }
8803 }
8804 if ((argc >= 2) && (argc <= 3)) {
8805 int _v;
8806 {
8807 void *ptr = 0;
8808 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8809 _v = 0;
8810 PyErr_Clear();
8811 } else {
8812 _v = (ptr != 0);
8813 }
8814 }
8815 if (_v) {
8816 _v = SWIG_Check_int(argv[1]);
8817 if (_v) {
8818 if (argc <= 2) {
8819 return _wrap_new_TimerRunner__SWIG_1(self,args);
8820 }
8821 _v = SWIG_Check_bool(argv[2]);
8822 if (_v) {
8823 return _wrap_new_TimerRunner__SWIG_1(self,args);
8824 }
8825 }
8826 }
8827 }
8828
8829 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8830 return NULL;
8831 }
8832
8833
8834 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8835 PyObject *resultobj;
8836 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8837 PyObject * obj0 = 0 ;
8838 char *kwnames[] = {
8839 (char *) "self", NULL
8840 };
8841
8842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8844 if (SWIG_arg_fail(1)) SWIG_fail;
8845 {
8846 PyThreadState* __tstate = wxPyBeginAllowThreads();
8847 delete arg1;
8848
8849 wxPyEndAllowThreads(__tstate);
8850 if (PyErr_Occurred()) SWIG_fail;
8851 }
8852 Py_INCREF(Py_None); resultobj = Py_None;
8853 return resultobj;
8854 fail:
8855 return NULL;
8856 }
8857
8858
8859 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8860 PyObject *resultobj;
8861 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8862 int arg2 ;
8863 bool arg3 = (bool) false ;
8864 PyObject * obj0 = 0 ;
8865 PyObject * obj1 = 0 ;
8866 PyObject * obj2 = 0 ;
8867 char *kwnames[] = {
8868 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8869 };
8870
8871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8873 if (SWIG_arg_fail(1)) SWIG_fail;
8874 {
8875 arg2 = (int)(SWIG_As_int(obj1));
8876 if (SWIG_arg_fail(2)) SWIG_fail;
8877 }
8878 if (obj2) {
8879 {
8880 arg3 = (bool)(SWIG_As_bool(obj2));
8881 if (SWIG_arg_fail(3)) SWIG_fail;
8882 }
8883 }
8884 {
8885 PyThreadState* __tstate = wxPyBeginAllowThreads();
8886 (arg1)->Start(arg2,arg3);
8887
8888 wxPyEndAllowThreads(__tstate);
8889 if (PyErr_Occurred()) SWIG_fail;
8890 }
8891 Py_INCREF(Py_None); resultobj = Py_None;
8892 return resultobj;
8893 fail:
8894 return NULL;
8895 }
8896
8897
8898 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8899 PyObject *obj;
8900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8901 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8902 Py_INCREF(obj);
8903 return Py_BuildValue((char *)"");
8904 }
8905 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj;
8907 wxLog *result;
8908 char *kwnames[] = {
8909 NULL
8910 };
8911
8912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8913 {
8914 PyThreadState* __tstate = wxPyBeginAllowThreads();
8915 result = (wxLog *)new wxLog();
8916
8917 wxPyEndAllowThreads(__tstate);
8918 if (PyErr_Occurred()) SWIG_fail;
8919 }
8920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8921 return resultobj;
8922 fail:
8923 return NULL;
8924 }
8925
8926
8927 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8928 PyObject *resultobj;
8929 bool result;
8930 char *kwnames[] = {
8931 NULL
8932 };
8933
8934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 result = (bool)wxLog::IsEnabled();
8938
8939 wxPyEndAllowThreads(__tstate);
8940 if (PyErr_Occurred()) SWIG_fail;
8941 }
8942 {
8943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8944 }
8945 return resultobj;
8946 fail:
8947 return NULL;
8948 }
8949
8950
8951 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8952 PyObject *resultobj;
8953 bool arg1 = (bool) true ;
8954 bool result;
8955 PyObject * obj0 = 0 ;
8956 char *kwnames[] = {
8957 (char *) "doIt", NULL
8958 };
8959
8960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8961 if (obj0) {
8962 {
8963 arg1 = (bool)(SWIG_As_bool(obj0));
8964 if (SWIG_arg_fail(1)) SWIG_fail;
8965 }
8966 }
8967 {
8968 PyThreadState* __tstate = wxPyBeginAllowThreads();
8969 result = (bool)wxLog::EnableLogging(arg1);
8970
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 {
8975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8976 }
8977 return resultobj;
8978 fail:
8979 return NULL;
8980 }
8981
8982
8983 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8984 PyObject *resultobj;
8985 wxLogLevel arg1 ;
8986 wxChar *arg2 = (wxChar *) 0 ;
8987 time_t arg3 ;
8988 PyObject * obj0 = 0 ;
8989 PyObject * obj1 = 0 ;
8990 PyObject * obj2 = 0 ;
8991 char *kwnames[] = {
8992 (char *) "level",(char *) "szString",(char *) "t", NULL
8993 };
8994
8995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8996 {
8997 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8998 if (SWIG_arg_fail(1)) SWIG_fail;
8999 }
9000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9001 if (SWIG_arg_fail(2)) SWIG_fail;
9002 {
9003 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
9004 if (SWIG_arg_fail(3)) SWIG_fail;
9005 }
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9009
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 Py_INCREF(Py_None); resultobj = Py_None;
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9021 PyObject *resultobj;
9022 wxLog *arg1 = (wxLog *) 0 ;
9023 PyObject * obj0 = 0 ;
9024 char *kwnames[] = {
9025 (char *) "self", NULL
9026 };
9027
9028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9030 if (SWIG_arg_fail(1)) SWIG_fail;
9031 {
9032 PyThreadState* __tstate = wxPyBeginAllowThreads();
9033 (arg1)->Flush();
9034
9035 wxPyEndAllowThreads(__tstate);
9036 if (PyErr_Occurred()) SWIG_fail;
9037 }
9038 Py_INCREF(Py_None); resultobj = Py_None;
9039 return resultobj;
9040 fail:
9041 return NULL;
9042 }
9043
9044
9045 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj;
9047 char *kwnames[] = {
9048 NULL
9049 };
9050
9051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9052 {
9053 PyThreadState* __tstate = wxPyBeginAllowThreads();
9054 wxLog::FlushActive();
9055
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 Py_INCREF(Py_None); resultobj = Py_None;
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9067 PyObject *resultobj;
9068 wxLog *result;
9069 char *kwnames[] = {
9070 NULL
9071 };
9072
9073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 result = (wxLog *)wxLog::GetActiveTarget();
9077
9078 wxPyEndAllowThreads(__tstate);
9079 if (PyErr_Occurred()) SWIG_fail;
9080 }
9081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9082 return resultobj;
9083 fail:
9084 return NULL;
9085 }
9086
9087
9088 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9089 PyObject *resultobj;
9090 wxLog *arg1 = (wxLog *) 0 ;
9091 wxLog *result;
9092 PyObject * obj0 = 0 ;
9093 char *kwnames[] = {
9094 (char *) "pLogger", NULL
9095 };
9096
9097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9099 if (SWIG_arg_fail(1)) SWIG_fail;
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9103
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9115 PyObject *resultobj;
9116 char *kwnames[] = {
9117 NULL
9118 };
9119
9120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9121 {
9122 PyThreadState* __tstate = wxPyBeginAllowThreads();
9123 wxLog::Suspend();
9124
9125 wxPyEndAllowThreads(__tstate);
9126 if (PyErr_Occurred()) SWIG_fail;
9127 }
9128 Py_INCREF(Py_None); resultobj = Py_None;
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj;
9137 char *kwnames[] = {
9138 NULL
9139 };
9140
9141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9142 {
9143 PyThreadState* __tstate = wxPyBeginAllowThreads();
9144 wxLog::Resume();
9145
9146 wxPyEndAllowThreads(__tstate);
9147 if (PyErr_Occurred()) SWIG_fail;
9148 }
9149 Py_INCREF(Py_None); resultobj = Py_None;
9150 return resultobj;
9151 fail:
9152 return NULL;
9153 }
9154
9155
9156 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9157 PyObject *resultobj;
9158 bool arg1 = (bool) true ;
9159 PyObject * obj0 = 0 ;
9160 char *kwnames[] = {
9161 (char *) "bVerbose", NULL
9162 };
9163
9164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9165 if (obj0) {
9166 {
9167 arg1 = (bool)(SWIG_As_bool(obj0));
9168 if (SWIG_arg_fail(1)) SWIG_fail;
9169 }
9170 }
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 wxLog::SetVerbose(arg1);
9174
9175 wxPyEndAllowThreads(__tstate);
9176 if (PyErr_Occurred()) SWIG_fail;
9177 }
9178 Py_INCREF(Py_None); resultobj = Py_None;
9179 return resultobj;
9180 fail:
9181 return NULL;
9182 }
9183
9184
9185 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj;
9187 wxLogLevel arg1 ;
9188 PyObject * obj0 = 0 ;
9189 char *kwnames[] = {
9190 (char *) "logLevel", NULL
9191 };
9192
9193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9194 {
9195 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9196 if (SWIG_arg_fail(1)) SWIG_fail;
9197 }
9198 {
9199 PyThreadState* __tstate = wxPyBeginAllowThreads();
9200 wxLog::SetLogLevel(arg1);
9201
9202 wxPyEndAllowThreads(__tstate);
9203 if (PyErr_Occurred()) SWIG_fail;
9204 }
9205 Py_INCREF(Py_None); resultobj = Py_None;
9206 return resultobj;
9207 fail:
9208 return NULL;
9209 }
9210
9211
9212 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9213 PyObject *resultobj;
9214 char *kwnames[] = {
9215 NULL
9216 };
9217
9218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 wxLog::DontCreateOnDemand();
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 Py_INCREF(Py_None); resultobj = Py_None;
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9234 PyObject *resultobj;
9235 wxTraceMask arg1 ;
9236 PyObject * obj0 = 0 ;
9237 char *kwnames[] = {
9238 (char *) "ulMask", NULL
9239 };
9240
9241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9242 {
9243 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9244 if (SWIG_arg_fail(1)) SWIG_fail;
9245 }
9246 {
9247 PyThreadState* __tstate = wxPyBeginAllowThreads();
9248 wxLog::SetTraceMask(arg1);
9249
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 Py_INCREF(Py_None); resultobj = Py_None;
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj;
9262 wxString *arg1 = 0 ;
9263 bool temp1 = false ;
9264 PyObject * obj0 = 0 ;
9265 char *kwnames[] = {
9266 (char *) "str", NULL
9267 };
9268
9269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9270 {
9271 arg1 = wxString_in_helper(obj0);
9272 if (arg1 == NULL) SWIG_fail;
9273 temp1 = true;
9274 }
9275 {
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 wxLog::AddTraceMask((wxString const &)*arg1);
9278
9279 wxPyEndAllowThreads(__tstate);
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 Py_INCREF(Py_None); resultobj = Py_None;
9283 {
9284 if (temp1)
9285 delete arg1;
9286 }
9287 return resultobj;
9288 fail:
9289 {
9290 if (temp1)
9291 delete arg1;
9292 }
9293 return NULL;
9294 }
9295
9296
9297 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9298 PyObject *resultobj;
9299 wxString *arg1 = 0 ;
9300 bool temp1 = false ;
9301 PyObject * obj0 = 0 ;
9302 char *kwnames[] = {
9303 (char *) "str", NULL
9304 };
9305
9306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9307 {
9308 arg1 = wxString_in_helper(obj0);
9309 if (arg1 == NULL) SWIG_fail;
9310 temp1 = true;
9311 }
9312 {
9313 PyThreadState* __tstate = wxPyBeginAllowThreads();
9314 wxLog::RemoveTraceMask((wxString const &)*arg1);
9315
9316 wxPyEndAllowThreads(__tstate);
9317 if (PyErr_Occurred()) SWIG_fail;
9318 }
9319 Py_INCREF(Py_None); resultobj = Py_None;
9320 {
9321 if (temp1)
9322 delete arg1;
9323 }
9324 return resultobj;
9325 fail:
9326 {
9327 if (temp1)
9328 delete arg1;
9329 }
9330 return NULL;
9331 }
9332
9333
9334 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9335 PyObject *resultobj;
9336 char *kwnames[] = {
9337 NULL
9338 };
9339
9340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9341 {
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 wxLog::ClearTraceMasks();
9344
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 Py_INCREF(Py_None); resultobj = Py_None;
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9356 PyObject *resultobj;
9357 wxArrayString *result;
9358 char *kwnames[] = {
9359 NULL
9360 };
9361
9362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9363 {
9364 PyThreadState* __tstate = wxPyBeginAllowThreads();
9365 {
9366 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9367 result = (wxArrayString *) &_result_ref;
9368 }
9369
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 {
9374 resultobj = wxArrayString2PyList_helper(*result);
9375 }
9376 return resultobj;
9377 fail:
9378 return NULL;
9379 }
9380
9381
9382 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9383 PyObject *resultobj;
9384 wxChar *arg1 = (wxChar *) 0 ;
9385 PyObject * obj0 = 0 ;
9386 char *kwnames[] = {
9387 (char *) "ts", NULL
9388 };
9389
9390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9392 if (SWIG_arg_fail(1)) SWIG_fail;
9393 {
9394 PyThreadState* __tstate = wxPyBeginAllowThreads();
9395 wxLog::SetTimestamp((wxChar const *)arg1);
9396
9397 wxPyEndAllowThreads(__tstate);
9398 if (PyErr_Occurred()) SWIG_fail;
9399 }
9400 Py_INCREF(Py_None); resultobj = Py_None;
9401 return resultobj;
9402 fail:
9403 return NULL;
9404 }
9405
9406
9407 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9408 PyObject *resultobj;
9409 bool result;
9410 char *kwnames[] = {
9411 NULL
9412 };
9413
9414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (bool)wxLog::GetVerbose();
9418
9419 wxPyEndAllowThreads(__tstate);
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 {
9423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9424 }
9425 return resultobj;
9426 fail:
9427 return NULL;
9428 }
9429
9430
9431 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9432 PyObject *resultobj;
9433 wxTraceMask result;
9434 char *kwnames[] = {
9435 NULL
9436 };
9437
9438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9439 {
9440 PyThreadState* __tstate = wxPyBeginAllowThreads();
9441 result = (wxTraceMask)wxLog::GetTraceMask();
9442
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 {
9447 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9448 }
9449 return resultobj;
9450 fail:
9451 return NULL;
9452 }
9453
9454
9455 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9456 PyObject *resultobj;
9457 wxChar *arg1 = (wxChar *) 0 ;
9458 bool result;
9459 PyObject * obj0 = 0 ;
9460 char *kwnames[] = {
9461 (char *) "mask", NULL
9462 };
9463
9464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9466 if (SWIG_arg_fail(1)) SWIG_fail;
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9470
9471 wxPyEndAllowThreads(__tstate);
9472 if (PyErr_Occurred()) SWIG_fail;
9473 }
9474 {
9475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9476 }
9477 return resultobj;
9478 fail:
9479 return NULL;
9480 }
9481
9482
9483 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9484 PyObject *resultobj;
9485 wxLogLevel result;
9486 char *kwnames[] = {
9487 NULL
9488 };
9489
9490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9491 {
9492 PyThreadState* __tstate = wxPyBeginAllowThreads();
9493 result = (wxLogLevel)wxLog::GetLogLevel();
9494
9495 wxPyEndAllowThreads(__tstate);
9496 if (PyErr_Occurred()) SWIG_fail;
9497 }
9498 {
9499 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9500 }
9501 return resultobj;
9502 fail:
9503 return NULL;
9504 }
9505
9506
9507 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9508 PyObject *resultobj;
9509 wxChar *result;
9510 char *kwnames[] = {
9511 NULL
9512 };
9513
9514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9515 {
9516 PyThreadState* __tstate = wxPyBeginAllowThreads();
9517 result = (wxChar *)wxLog::GetTimestamp();
9518
9519 wxPyEndAllowThreads(__tstate);
9520 if (PyErr_Occurred()) SWIG_fail;
9521 }
9522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9523 return resultobj;
9524 fail:
9525 return NULL;
9526 }
9527
9528
9529 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj;
9531 wxString result;
9532 char *kwnames[] = {
9533 NULL
9534 };
9535
9536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 result = Log_TimeStamp();
9540
9541 wxPyEndAllowThreads(__tstate);
9542 if (PyErr_Occurred()) SWIG_fail;
9543 }
9544 {
9545 #if wxUSE_UNICODE
9546 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9547 #else
9548 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9549 #endif
9550 }
9551 return resultobj;
9552 fail:
9553 return NULL;
9554 }
9555
9556
9557 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9558 PyObject *resultobj;
9559 wxLog *arg1 = (wxLog *) 0 ;
9560 PyObject * obj0 = 0 ;
9561 char *kwnames[] = {
9562 (char *) "self", NULL
9563 };
9564
9565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9567 if (SWIG_arg_fail(1)) SWIG_fail;
9568 {
9569 PyThreadState* __tstate = wxPyBeginAllowThreads();
9570 wxLog_Destroy(arg1);
9571
9572 wxPyEndAllowThreads(__tstate);
9573 if (PyErr_Occurred()) SWIG_fail;
9574 }
9575 Py_INCREF(Py_None); resultobj = Py_None;
9576 return resultobj;
9577 fail:
9578 return NULL;
9579 }
9580
9581
9582 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9583 PyObject *obj;
9584 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9585 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9586 Py_INCREF(obj);
9587 return Py_BuildValue((char *)"");
9588 }
9589 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9590 PyObject *resultobj;
9591 wxLogStderr *result;
9592 char *kwnames[] = {
9593 NULL
9594 };
9595
9596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 result = (wxLogStderr *)new wxLogStderr();
9600
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9612 PyObject *obj;
9613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9614 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9615 Py_INCREF(obj);
9616 return Py_BuildValue((char *)"");
9617 }
9618 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9619 PyObject *resultobj;
9620 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9621 wxLogTextCtrl *result;
9622 PyObject * obj0 = 0 ;
9623 char *kwnames[] = {
9624 (char *) "pTextCtrl", NULL
9625 };
9626
9627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9629 if (SWIG_arg_fail(1)) SWIG_fail;
9630 {
9631 PyThreadState* __tstate = wxPyBeginAllowThreads();
9632 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9633
9634 wxPyEndAllowThreads(__tstate);
9635 if (PyErr_Occurred()) SWIG_fail;
9636 }
9637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9638 return resultobj;
9639 fail:
9640 return NULL;
9641 }
9642
9643
9644 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9645 PyObject *obj;
9646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9647 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9648 Py_INCREF(obj);
9649 return Py_BuildValue((char *)"");
9650 }
9651 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9652 PyObject *resultobj;
9653 wxLogGui *result;
9654 char *kwnames[] = {
9655 NULL
9656 };
9657
9658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9659 {
9660 PyThreadState* __tstate = wxPyBeginAllowThreads();
9661 result = (wxLogGui *)new wxLogGui();
9662
9663 wxPyEndAllowThreads(__tstate);
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9674 PyObject *obj;
9675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9676 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9677 Py_INCREF(obj);
9678 return Py_BuildValue((char *)"");
9679 }
9680 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9681 PyObject *resultobj;
9682 wxFrame *arg1 = (wxFrame *) 0 ;
9683 wxString *arg2 = 0 ;
9684 bool arg3 = (bool) true ;
9685 bool arg4 = (bool) true ;
9686 wxLogWindow *result;
9687 bool temp2 = false ;
9688 PyObject * obj0 = 0 ;
9689 PyObject * obj1 = 0 ;
9690 PyObject * obj2 = 0 ;
9691 PyObject * obj3 = 0 ;
9692 char *kwnames[] = {
9693 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9694 };
9695
9696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9698 if (SWIG_arg_fail(1)) SWIG_fail;
9699 {
9700 arg2 = wxString_in_helper(obj1);
9701 if (arg2 == NULL) SWIG_fail;
9702 temp2 = true;
9703 }
9704 if (obj2) {
9705 {
9706 arg3 = (bool)(SWIG_As_bool(obj2));
9707 if (SWIG_arg_fail(3)) SWIG_fail;
9708 }
9709 }
9710 if (obj3) {
9711 {
9712 arg4 = (bool)(SWIG_As_bool(obj3));
9713 if (SWIG_arg_fail(4)) SWIG_fail;
9714 }
9715 }
9716 {
9717 PyThreadState* __tstate = wxPyBeginAllowThreads();
9718 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9719
9720 wxPyEndAllowThreads(__tstate);
9721 if (PyErr_Occurred()) SWIG_fail;
9722 }
9723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9724 {
9725 if (temp2)
9726 delete arg2;
9727 }
9728 return resultobj;
9729 fail:
9730 {
9731 if (temp2)
9732 delete arg2;
9733 }
9734 return NULL;
9735 }
9736
9737
9738 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9739 PyObject *resultobj;
9740 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9741 bool arg2 = (bool) true ;
9742 PyObject * obj0 = 0 ;
9743 PyObject * obj1 = 0 ;
9744 char *kwnames[] = {
9745 (char *) "self",(char *) "bShow", NULL
9746 };
9747
9748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9750 if (SWIG_arg_fail(1)) SWIG_fail;
9751 if (obj1) {
9752 {
9753 arg2 = (bool)(SWIG_As_bool(obj1));
9754 if (SWIG_arg_fail(2)) SWIG_fail;
9755 }
9756 }
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 (arg1)->Show(arg2);
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 Py_INCREF(Py_None); resultobj = Py_None;
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9772 PyObject *resultobj;
9773 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9774 wxFrame *result;
9775 PyObject * obj0 = 0 ;
9776 char *kwnames[] = {
9777 (char *) "self", NULL
9778 };
9779
9780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9782 if (SWIG_arg_fail(1)) SWIG_fail;
9783 {
9784 PyThreadState* __tstate = wxPyBeginAllowThreads();
9785 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9786
9787 wxPyEndAllowThreads(__tstate);
9788 if (PyErr_Occurred()) SWIG_fail;
9789 }
9790 {
9791 resultobj = wxPyMake_wxObject(result, 0);
9792 }
9793 return resultobj;
9794 fail:
9795 return NULL;
9796 }
9797
9798
9799 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9800 PyObject *resultobj;
9801 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9802 wxLog *result;
9803 PyObject * obj0 = 0 ;
9804 char *kwnames[] = {
9805 (char *) "self", NULL
9806 };
9807
9808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9810 if (SWIG_arg_fail(1)) SWIG_fail;
9811 {
9812 PyThreadState* __tstate = wxPyBeginAllowThreads();
9813 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9814
9815 wxPyEndAllowThreads(__tstate);
9816 if (PyErr_Occurred()) SWIG_fail;
9817 }
9818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9819 return resultobj;
9820 fail:
9821 return NULL;
9822 }
9823
9824
9825 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9826 PyObject *resultobj;
9827 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9828 bool result;
9829 PyObject * obj0 = 0 ;
9830 char *kwnames[] = {
9831 (char *) "self", NULL
9832 };
9833
9834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9836 if (SWIG_arg_fail(1)) SWIG_fail;
9837 {
9838 PyThreadState* __tstate = wxPyBeginAllowThreads();
9839 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9840
9841 wxPyEndAllowThreads(__tstate);
9842 if (PyErr_Occurred()) SWIG_fail;
9843 }
9844 {
9845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9846 }
9847 return resultobj;
9848 fail:
9849 return NULL;
9850 }
9851
9852
9853 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9854 PyObject *resultobj;
9855 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9856 bool arg2 ;
9857 PyObject * obj0 = 0 ;
9858 PyObject * obj1 = 0 ;
9859 char *kwnames[] = {
9860 (char *) "self",(char *) "bDoPass", NULL
9861 };
9862
9863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9865 if (SWIG_arg_fail(1)) SWIG_fail;
9866 {
9867 arg2 = (bool)(SWIG_As_bool(obj1));
9868 if (SWIG_arg_fail(2)) SWIG_fail;
9869 }
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 (arg1)->PassMessages(arg2);
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 Py_INCREF(Py_None); resultobj = Py_None;
9878 return resultobj;
9879 fail:
9880 return NULL;
9881 }
9882
9883
9884 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9885 PyObject *obj;
9886 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9887 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9888 Py_INCREF(obj);
9889 return Py_BuildValue((char *)"");
9890 }
9891 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9892 PyObject *resultobj;
9893 wxLog *arg1 = (wxLog *) 0 ;
9894 wxLogChain *result;
9895 PyObject * obj0 = 0 ;
9896 char *kwnames[] = {
9897 (char *) "logger", NULL
9898 };
9899
9900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9902 if (SWIG_arg_fail(1)) SWIG_fail;
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 result = (wxLogChain *)new wxLogChain(arg1);
9906
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9918 PyObject *resultobj;
9919 wxLogChain *arg1 = (wxLogChain *) 0 ;
9920 wxLog *arg2 = (wxLog *) 0 ;
9921 PyObject * obj0 = 0 ;
9922 PyObject * obj1 = 0 ;
9923 char *kwnames[] = {
9924 (char *) "self",(char *) "logger", NULL
9925 };
9926
9927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9929 if (SWIG_arg_fail(1)) SWIG_fail;
9930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9931 if (SWIG_arg_fail(2)) SWIG_fail;
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 (arg1)->SetLog(arg2);
9935
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 Py_INCREF(Py_None); resultobj = Py_None;
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9947 PyObject *resultobj;
9948 wxLogChain *arg1 = (wxLogChain *) 0 ;
9949 bool arg2 ;
9950 PyObject * obj0 = 0 ;
9951 PyObject * obj1 = 0 ;
9952 char *kwnames[] = {
9953 (char *) "self",(char *) "bDoPass", NULL
9954 };
9955
9956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9958 if (SWIG_arg_fail(1)) SWIG_fail;
9959 {
9960 arg2 = (bool)(SWIG_As_bool(obj1));
9961 if (SWIG_arg_fail(2)) SWIG_fail;
9962 }
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 (arg1)->PassMessages(arg2);
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 Py_INCREF(Py_None); resultobj = Py_None;
9971 return resultobj;
9972 fail:
9973 return NULL;
9974 }
9975
9976
9977 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9978 PyObject *resultobj;
9979 wxLogChain *arg1 = (wxLogChain *) 0 ;
9980 bool result;
9981 PyObject * obj0 = 0 ;
9982 char *kwnames[] = {
9983 (char *) "self", NULL
9984 };
9985
9986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9988 if (SWIG_arg_fail(1)) SWIG_fail;
9989 {
9990 PyThreadState* __tstate = wxPyBeginAllowThreads();
9991 result = (bool)(arg1)->IsPassingMessages();
9992
9993 wxPyEndAllowThreads(__tstate);
9994 if (PyErr_Occurred()) SWIG_fail;
9995 }
9996 {
9997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9998 }
9999 return resultobj;
10000 fail:
10001 return NULL;
10002 }
10003
10004
10005 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10006 PyObject *resultobj;
10007 wxLogChain *arg1 = (wxLogChain *) 0 ;
10008 wxLog *result;
10009 PyObject * obj0 = 0 ;
10010 char *kwnames[] = {
10011 (char *) "self", NULL
10012 };
10013
10014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10016 if (SWIG_arg_fail(1)) SWIG_fail;
10017 {
10018 PyThreadState* __tstate = wxPyBeginAllowThreads();
10019 result = (wxLog *)(arg1)->GetOldLog();
10020
10021 wxPyEndAllowThreads(__tstate);
10022 if (PyErr_Occurred()) SWIG_fail;
10023 }
10024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10025 return resultobj;
10026 fail:
10027 return NULL;
10028 }
10029
10030
10031 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10032 PyObject *obj;
10033 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10034 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10035 Py_INCREF(obj);
10036 return Py_BuildValue((char *)"");
10037 }
10038 static PyObject *_wrap_new_LogBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10039 PyObject *resultobj;
10040 wxLogBuffer *result;
10041 char *kwnames[] = {
10042 NULL
10043 };
10044
10045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogBuffer",kwnames)) goto fail;
10046 {
10047 PyThreadState* __tstate = wxPyBeginAllowThreads();
10048 result = (wxLogBuffer *)new wxLogBuffer();
10049
10050 wxPyEndAllowThreads(__tstate);
10051 if (PyErr_Occurred()) SWIG_fail;
10052 }
10053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogBuffer, 1);
10054 return resultobj;
10055 fail:
10056 return NULL;
10057 }
10058
10059
10060 static PyObject *_wrap_LogBuffer_GetBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10061 PyObject *resultobj;
10062 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10063 wxString *result;
10064 PyObject * obj0 = 0 ;
10065 char *kwnames[] = {
10066 (char *) "self", NULL
10067 };
10068
10069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_GetBuffer",kwnames,&obj0)) goto fail;
10070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10071 if (SWIG_arg_fail(1)) SWIG_fail;
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 {
10075 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
10076 result = (wxString *) &_result_ref;
10077 }
10078
10079 wxPyEndAllowThreads(__tstate);
10080 if (PyErr_Occurred()) SWIG_fail;
10081 }
10082 {
10083 #if wxUSE_UNICODE
10084 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10085 #else
10086 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10087 #endif
10088 }
10089 return resultobj;
10090 fail:
10091 return NULL;
10092 }
10093
10094
10095 static PyObject *_wrap_LogBuffer_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj;
10097 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10098 PyObject * obj0 = 0 ;
10099 char *kwnames[] = {
10100 (char *) "self", NULL
10101 };
10102
10103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_Flush",kwnames,&obj0)) goto fail;
10104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10105 if (SWIG_arg_fail(1)) SWIG_fail;
10106 {
10107 PyThreadState* __tstate = wxPyBeginAllowThreads();
10108 (arg1)->Flush();
10109
10110 wxPyEndAllowThreads(__tstate);
10111 if (PyErr_Occurred()) SWIG_fail;
10112 }
10113 Py_INCREF(Py_None); resultobj = Py_None;
10114 return resultobj;
10115 fail:
10116 return NULL;
10117 }
10118
10119
10120 static PyObject * LogBuffer_swigregister(PyObject *, PyObject *args) {
10121 PyObject *obj;
10122 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10123 SWIG_TypeClientData(SWIGTYPE_p_wxLogBuffer, obj);
10124 Py_INCREF(obj);
10125 return Py_BuildValue((char *)"");
10126 }
10127 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10128 PyObject *resultobj;
10129 unsigned long result;
10130 char *kwnames[] = {
10131 NULL
10132 };
10133
10134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10135 {
10136 PyThreadState* __tstate = wxPyBeginAllowThreads();
10137 result = (unsigned long)wxSysErrorCode();
10138
10139 wxPyEndAllowThreads(__tstate);
10140 if (PyErr_Occurred()) SWIG_fail;
10141 }
10142 {
10143 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10144 }
10145 return resultobj;
10146 fail:
10147 return NULL;
10148 }
10149
10150
10151 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj;
10153 unsigned long arg1 = (unsigned long) 0 ;
10154 wxString result;
10155 PyObject * obj0 = 0 ;
10156 char *kwnames[] = {
10157 (char *) "nErrCode", NULL
10158 };
10159
10160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10161 if (obj0) {
10162 {
10163 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10164 if (SWIG_arg_fail(1)) SWIG_fail;
10165 }
10166 }
10167 {
10168 PyThreadState* __tstate = wxPyBeginAllowThreads();
10169 result = wxSysErrorMsg(arg1);
10170
10171 wxPyEndAllowThreads(__tstate);
10172 if (PyErr_Occurred()) SWIG_fail;
10173 }
10174 {
10175 #if wxUSE_UNICODE
10176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10177 #else
10178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10179 #endif
10180 }
10181 return resultobj;
10182 fail:
10183 return NULL;
10184 }
10185
10186
10187 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10188 PyObject *resultobj;
10189 wxString *arg1 = 0 ;
10190 bool temp1 = false ;
10191 PyObject * obj0 = 0 ;
10192 char *kwnames[] = {
10193 (char *) "msg", NULL
10194 };
10195
10196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10197 {
10198 arg1 = wxString_in_helper(obj0);
10199 if (arg1 == NULL) SWIG_fail;
10200 temp1 = true;
10201 }
10202 {
10203 PyThreadState* __tstate = wxPyBeginAllowThreads();
10204 wxPyLogFatalError((wxString const &)*arg1);
10205
10206 wxPyEndAllowThreads(__tstate);
10207 if (PyErr_Occurred()) SWIG_fail;
10208 }
10209 Py_INCREF(Py_None); resultobj = Py_None;
10210 {
10211 if (temp1)
10212 delete arg1;
10213 }
10214 return resultobj;
10215 fail:
10216 {
10217 if (temp1)
10218 delete arg1;
10219 }
10220 return NULL;
10221 }
10222
10223
10224 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10225 PyObject *resultobj;
10226 wxString *arg1 = 0 ;
10227 bool temp1 = false ;
10228 PyObject * obj0 = 0 ;
10229 char *kwnames[] = {
10230 (char *) "msg", NULL
10231 };
10232
10233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10234 {
10235 arg1 = wxString_in_helper(obj0);
10236 if (arg1 == NULL) SWIG_fail;
10237 temp1 = true;
10238 }
10239 {
10240 PyThreadState* __tstate = wxPyBeginAllowThreads();
10241 wxPyLogError((wxString const &)*arg1);
10242
10243 wxPyEndAllowThreads(__tstate);
10244 if (PyErr_Occurred()) SWIG_fail;
10245 }
10246 Py_INCREF(Py_None); resultobj = Py_None;
10247 {
10248 if (temp1)
10249 delete arg1;
10250 }
10251 return resultobj;
10252 fail:
10253 {
10254 if (temp1)
10255 delete arg1;
10256 }
10257 return NULL;
10258 }
10259
10260
10261 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10262 PyObject *resultobj;
10263 wxString *arg1 = 0 ;
10264 bool temp1 = false ;
10265 PyObject * obj0 = 0 ;
10266 char *kwnames[] = {
10267 (char *) "msg", NULL
10268 };
10269
10270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10271 {
10272 arg1 = wxString_in_helper(obj0);
10273 if (arg1 == NULL) SWIG_fail;
10274 temp1 = true;
10275 }
10276 {
10277 PyThreadState* __tstate = wxPyBeginAllowThreads();
10278 wxPyLogWarning((wxString const &)*arg1);
10279
10280 wxPyEndAllowThreads(__tstate);
10281 if (PyErr_Occurred()) SWIG_fail;
10282 }
10283 Py_INCREF(Py_None); resultobj = Py_None;
10284 {
10285 if (temp1)
10286 delete arg1;
10287 }
10288 return resultobj;
10289 fail:
10290 {
10291 if (temp1)
10292 delete arg1;
10293 }
10294 return NULL;
10295 }
10296
10297
10298 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10299 PyObject *resultobj;
10300 wxString *arg1 = 0 ;
10301 bool temp1 = false ;
10302 PyObject * obj0 = 0 ;
10303 char *kwnames[] = {
10304 (char *) "msg", NULL
10305 };
10306
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10308 {
10309 arg1 = wxString_in_helper(obj0);
10310 if (arg1 == NULL) SWIG_fail;
10311 temp1 = true;
10312 }
10313 {
10314 PyThreadState* __tstate = wxPyBeginAllowThreads();
10315 wxPyLogMessage((wxString const &)*arg1);
10316
10317 wxPyEndAllowThreads(__tstate);
10318 if (PyErr_Occurred()) SWIG_fail;
10319 }
10320 Py_INCREF(Py_None); resultobj = Py_None;
10321 {
10322 if (temp1)
10323 delete arg1;
10324 }
10325 return resultobj;
10326 fail:
10327 {
10328 if (temp1)
10329 delete arg1;
10330 }
10331 return NULL;
10332 }
10333
10334
10335 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10336 PyObject *resultobj;
10337 wxString *arg1 = 0 ;
10338 bool temp1 = false ;
10339 PyObject * obj0 = 0 ;
10340 char *kwnames[] = {
10341 (char *) "msg", NULL
10342 };
10343
10344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10345 {
10346 arg1 = wxString_in_helper(obj0);
10347 if (arg1 == NULL) SWIG_fail;
10348 temp1 = true;
10349 }
10350 {
10351 PyThreadState* __tstate = wxPyBeginAllowThreads();
10352 wxPyLogInfo((wxString const &)*arg1);
10353
10354 wxPyEndAllowThreads(__tstate);
10355 if (PyErr_Occurred()) SWIG_fail;
10356 }
10357 Py_INCREF(Py_None); resultobj = Py_None;
10358 {
10359 if (temp1)
10360 delete arg1;
10361 }
10362 return resultobj;
10363 fail:
10364 {
10365 if (temp1)
10366 delete arg1;
10367 }
10368 return NULL;
10369 }
10370
10371
10372 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10373 PyObject *resultobj;
10374 wxString *arg1 = 0 ;
10375 bool temp1 = false ;
10376 PyObject * obj0 = 0 ;
10377 char *kwnames[] = {
10378 (char *) "msg", NULL
10379 };
10380
10381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10382 {
10383 arg1 = wxString_in_helper(obj0);
10384 if (arg1 == NULL) SWIG_fail;
10385 temp1 = true;
10386 }
10387 {
10388 PyThreadState* __tstate = wxPyBeginAllowThreads();
10389 wxPyLogDebug((wxString const &)*arg1);
10390
10391 wxPyEndAllowThreads(__tstate);
10392 if (PyErr_Occurred()) SWIG_fail;
10393 }
10394 Py_INCREF(Py_None); resultobj = Py_None;
10395 {
10396 if (temp1)
10397 delete arg1;
10398 }
10399 return resultobj;
10400 fail:
10401 {
10402 if (temp1)
10403 delete arg1;
10404 }
10405 return NULL;
10406 }
10407
10408
10409 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10410 PyObject *resultobj;
10411 wxString *arg1 = 0 ;
10412 bool temp1 = false ;
10413 PyObject * obj0 = 0 ;
10414 char *kwnames[] = {
10415 (char *) "msg", NULL
10416 };
10417
10418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10419 {
10420 arg1 = wxString_in_helper(obj0);
10421 if (arg1 == NULL) SWIG_fail;
10422 temp1 = true;
10423 }
10424 {
10425 PyThreadState* __tstate = wxPyBeginAllowThreads();
10426 wxPyLogVerbose((wxString const &)*arg1);
10427
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 Py_INCREF(Py_None); resultobj = Py_None;
10432 {
10433 if (temp1)
10434 delete arg1;
10435 }
10436 return resultobj;
10437 fail:
10438 {
10439 if (temp1)
10440 delete arg1;
10441 }
10442 return NULL;
10443 }
10444
10445
10446 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10447 PyObject *resultobj;
10448 wxString *arg1 = 0 ;
10449 bool temp1 = false ;
10450 PyObject * obj0 = 0 ;
10451 char *kwnames[] = {
10452 (char *) "msg", NULL
10453 };
10454
10455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10456 {
10457 arg1 = wxString_in_helper(obj0);
10458 if (arg1 == NULL) SWIG_fail;
10459 temp1 = true;
10460 }
10461 {
10462 PyThreadState* __tstate = wxPyBeginAllowThreads();
10463 wxPyLogStatus((wxString const &)*arg1);
10464
10465 wxPyEndAllowThreads(__tstate);
10466 if (PyErr_Occurred()) SWIG_fail;
10467 }
10468 Py_INCREF(Py_None); resultobj = Py_None;
10469 {
10470 if (temp1)
10471 delete arg1;
10472 }
10473 return resultobj;
10474 fail:
10475 {
10476 if (temp1)
10477 delete arg1;
10478 }
10479 return NULL;
10480 }
10481
10482
10483 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10484 PyObject *resultobj;
10485 wxFrame *arg1 = (wxFrame *) 0 ;
10486 wxString *arg2 = 0 ;
10487 bool temp2 = false ;
10488 PyObject * obj0 = 0 ;
10489 PyObject * obj1 = 0 ;
10490 char *kwnames[] = {
10491 (char *) "pFrame",(char *) "msg", NULL
10492 };
10493
10494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10496 if (SWIG_arg_fail(1)) SWIG_fail;
10497 {
10498 arg2 = wxString_in_helper(obj1);
10499 if (arg2 == NULL) SWIG_fail;
10500 temp2 = true;
10501 }
10502 {
10503 PyThreadState* __tstate = wxPyBeginAllowThreads();
10504 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10505
10506 wxPyEndAllowThreads(__tstate);
10507 if (PyErr_Occurred()) SWIG_fail;
10508 }
10509 Py_INCREF(Py_None); resultobj = Py_None;
10510 {
10511 if (temp2)
10512 delete arg2;
10513 }
10514 return resultobj;
10515 fail:
10516 {
10517 if (temp2)
10518 delete arg2;
10519 }
10520 return NULL;
10521 }
10522
10523
10524 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10525 PyObject *resultobj;
10526 wxString *arg1 = 0 ;
10527 bool temp1 = false ;
10528 PyObject * obj0 = 0 ;
10529 char *kwnames[] = {
10530 (char *) "msg", NULL
10531 };
10532
10533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10534 {
10535 arg1 = wxString_in_helper(obj0);
10536 if (arg1 == NULL) SWIG_fail;
10537 temp1 = true;
10538 }
10539 {
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 wxPyLogSysError((wxString const &)*arg1);
10542
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 Py_INCREF(Py_None); resultobj = Py_None;
10547 {
10548 if (temp1)
10549 delete arg1;
10550 }
10551 return resultobj;
10552 fail:
10553 {
10554 if (temp1)
10555 delete arg1;
10556 }
10557 return NULL;
10558 }
10559
10560
10561 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10562 PyObject *resultobj;
10563 unsigned long arg1 ;
10564 wxString *arg2 = 0 ;
10565 bool temp2 = false ;
10566 PyObject * obj0 = 0 ;
10567 PyObject * obj1 = 0 ;
10568 char *kwnames[] = {
10569 (char *) "level",(char *) "msg", NULL
10570 };
10571
10572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10573 {
10574 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10575 if (SWIG_arg_fail(1)) SWIG_fail;
10576 }
10577 {
10578 arg2 = wxString_in_helper(obj1);
10579 if (arg2 == NULL) SWIG_fail;
10580 temp2 = true;
10581 }
10582 {
10583 PyThreadState* __tstate = wxPyBeginAllowThreads();
10584 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10585
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 Py_INCREF(Py_None); resultobj = Py_None;
10590 {
10591 if (temp2)
10592 delete arg2;
10593 }
10594 return resultobj;
10595 fail:
10596 {
10597 if (temp2)
10598 delete arg2;
10599 }
10600 return NULL;
10601 }
10602
10603
10604 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10605 PyObject *resultobj;
10606 unsigned long arg1 ;
10607 wxString *arg2 = 0 ;
10608 bool temp2 = false ;
10609 PyObject * obj0 = 0 ;
10610 PyObject * obj1 = 0 ;
10611
10612 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10613 {
10614 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10615 if (SWIG_arg_fail(1)) SWIG_fail;
10616 }
10617 {
10618 arg2 = wxString_in_helper(obj1);
10619 if (arg2 == NULL) SWIG_fail;
10620 temp2 = true;
10621 }
10622 {
10623 PyThreadState* __tstate = wxPyBeginAllowThreads();
10624 wxPyLogTrace(arg1,(wxString const &)*arg2);
10625
10626 wxPyEndAllowThreads(__tstate);
10627 if (PyErr_Occurred()) SWIG_fail;
10628 }
10629 Py_INCREF(Py_None); resultobj = Py_None;
10630 {
10631 if (temp2)
10632 delete arg2;
10633 }
10634 return resultobj;
10635 fail:
10636 {
10637 if (temp2)
10638 delete arg2;
10639 }
10640 return NULL;
10641 }
10642
10643
10644 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
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
10653 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10654 {
10655 arg1 = wxString_in_helper(obj0);
10656 if (arg1 == NULL) SWIG_fail;
10657 temp1 = true;
10658 }
10659 {
10660 arg2 = wxString_in_helper(obj1);
10661 if (arg2 == NULL) SWIG_fail;
10662 temp2 = true;
10663 }
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10667
10668 wxPyEndAllowThreads(__tstate);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 Py_INCREF(Py_None); resultobj = Py_None;
10672 {
10673 if (temp1)
10674 delete arg1;
10675 }
10676 {
10677 if (temp2)
10678 delete arg2;
10679 }
10680 return resultobj;
10681 fail:
10682 {
10683 if (temp1)
10684 delete arg1;
10685 }
10686 {
10687 if (temp2)
10688 delete arg2;
10689 }
10690 return NULL;
10691 }
10692
10693
10694 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10695 int argc;
10696 PyObject *argv[3];
10697 int ii;
10698
10699 argc = PyObject_Length(args);
10700 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10701 argv[ii] = PyTuple_GetItem(args,ii);
10702 }
10703 if (argc == 2) {
10704 int _v;
10705 {
10706 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10707 }
10708 if (_v) {
10709 {
10710 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10711 }
10712 if (_v) {
10713 return _wrap_LogTrace__SWIG_1(self,args);
10714 }
10715 }
10716 }
10717 if (argc == 2) {
10718 int _v;
10719 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10720 if (_v) {
10721 {
10722 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10723 }
10724 if (_v) {
10725 return _wrap_LogTrace__SWIG_0(self,args);
10726 }
10727 }
10728 }
10729
10730 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10731 return NULL;
10732 }
10733
10734
10735 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10736 PyObject *resultobj;
10737 wxString *arg1 = 0 ;
10738 wxString *arg2 = 0 ;
10739 bool temp1 = false ;
10740 bool temp2 = false ;
10741 PyObject * obj0 = 0 ;
10742 PyObject * obj1 = 0 ;
10743 char *kwnames[] = {
10744 (char *) "title",(char *) "text", NULL
10745 };
10746
10747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10748 {
10749 arg1 = wxString_in_helper(obj0);
10750 if (arg1 == NULL) SWIG_fail;
10751 temp1 = true;
10752 }
10753 {
10754 arg2 = wxString_in_helper(obj1);
10755 if (arg2 == NULL) SWIG_fail;
10756 temp2 = true;
10757 }
10758 {
10759 PyThreadState* __tstate = wxPyBeginAllowThreads();
10760 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10761
10762 wxPyEndAllowThreads(__tstate);
10763 if (PyErr_Occurred()) SWIG_fail;
10764 }
10765 Py_INCREF(Py_None); resultobj = Py_None;
10766 {
10767 if (temp1)
10768 delete arg1;
10769 }
10770 {
10771 if (temp2)
10772 delete arg2;
10773 }
10774 return resultobj;
10775 fail:
10776 {
10777 if (temp1)
10778 delete arg1;
10779 }
10780 {
10781 if (temp2)
10782 delete arg2;
10783 }
10784 return NULL;
10785 }
10786
10787
10788 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10789 PyObject *resultobj;
10790 wxLogNull *result;
10791 char *kwnames[] = {
10792 NULL
10793 };
10794
10795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10796 {
10797 PyThreadState* __tstate = wxPyBeginAllowThreads();
10798 result = (wxLogNull *)new wxLogNull();
10799
10800 wxPyEndAllowThreads(__tstate);
10801 if (PyErr_Occurred()) SWIG_fail;
10802 }
10803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10804 return resultobj;
10805 fail:
10806 return NULL;
10807 }
10808
10809
10810 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10811 PyObject *resultobj;
10812 wxLogNull *arg1 = (wxLogNull *) 0 ;
10813 PyObject * obj0 = 0 ;
10814 char *kwnames[] = {
10815 (char *) "self", NULL
10816 };
10817
10818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10820 if (SWIG_arg_fail(1)) SWIG_fail;
10821 {
10822 PyThreadState* __tstate = wxPyBeginAllowThreads();
10823 delete arg1;
10824
10825 wxPyEndAllowThreads(__tstate);
10826 if (PyErr_Occurred()) SWIG_fail;
10827 }
10828 Py_INCREF(Py_None); resultobj = Py_None;
10829 return resultobj;
10830 fail:
10831 return NULL;
10832 }
10833
10834
10835 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10836 PyObject *obj;
10837 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10838 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10839 Py_INCREF(obj);
10840 return Py_BuildValue((char *)"");
10841 }
10842 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10843 PyObject *resultobj;
10844 wxPyLog *result;
10845 char *kwnames[] = {
10846 NULL
10847 };
10848
10849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10850 {
10851 PyThreadState* __tstate = wxPyBeginAllowThreads();
10852 result = (wxPyLog *)new wxPyLog();
10853
10854 wxPyEndAllowThreads(__tstate);
10855 if (PyErr_Occurred()) SWIG_fail;
10856 }
10857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj;
10866 wxPyLog *arg1 = (wxPyLog *) 0 ;
10867 PyObject *arg2 = (PyObject *) 0 ;
10868 PyObject *arg3 = (PyObject *) 0 ;
10869 PyObject * obj0 = 0 ;
10870 PyObject * obj1 = 0 ;
10871 PyObject * obj2 = 0 ;
10872 char *kwnames[] = {
10873 (char *) "self",(char *) "self",(char *) "_class", NULL
10874 };
10875
10876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10878 if (SWIG_arg_fail(1)) SWIG_fail;
10879 arg2 = obj1;
10880 arg3 = obj2;
10881 {
10882 PyThreadState* __tstate = wxPyBeginAllowThreads();
10883 (arg1)->_setCallbackInfo(arg2,arg3);
10884
10885 wxPyEndAllowThreads(__tstate);
10886 if (PyErr_Occurred()) SWIG_fail;
10887 }
10888 Py_INCREF(Py_None); resultobj = Py_None;
10889 return resultobj;
10890 fail:
10891 return NULL;
10892 }
10893
10894
10895 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10896 PyObject *obj;
10897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10898 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10899 Py_INCREF(obj);
10900 return Py_BuildValue((char *)"");
10901 }
10902 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10903 PyObject *resultobj;
10904 int arg1 ;
10905 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10906 int arg3 = (int) wxKILL_NOCHILDREN ;
10907 wxKillError result;
10908 PyObject * obj0 = 0 ;
10909 PyObject * obj1 = 0 ;
10910 PyObject * obj2 = 0 ;
10911 char *kwnames[] = {
10912 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10913 };
10914
10915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10916 {
10917 arg1 = (int)(SWIG_As_int(obj0));
10918 if (SWIG_arg_fail(1)) SWIG_fail;
10919 }
10920 if (obj1) {
10921 {
10922 arg2 = (wxSignal)(SWIG_As_int(obj1));
10923 if (SWIG_arg_fail(2)) SWIG_fail;
10924 }
10925 }
10926 if (obj2) {
10927 {
10928 arg3 = (int)(SWIG_As_int(obj2));
10929 if (SWIG_arg_fail(3)) SWIG_fail;
10930 }
10931 }
10932 {
10933 PyThreadState* __tstate = wxPyBeginAllowThreads();
10934 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10935
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 resultobj = SWIG_From_int((result));
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj;
10948 int arg1 ;
10949 bool result;
10950 PyObject * obj0 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "pid", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10956 {
10957 arg1 = (int)(SWIG_As_int(obj0));
10958 if (SWIG_arg_fail(1)) SWIG_fail;
10959 }
10960 {
10961 PyThreadState* __tstate = wxPyBeginAllowThreads();
10962 result = (bool)wxPyProcess::Exists(arg1);
10963
10964 wxPyEndAllowThreads(__tstate);
10965 if (PyErr_Occurred()) SWIG_fail;
10966 }
10967 {
10968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10969 }
10970 return resultobj;
10971 fail:
10972 return NULL;
10973 }
10974
10975
10976 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10977 PyObject *resultobj;
10978 wxString *arg1 = 0 ;
10979 int arg2 = (int) wxEXEC_ASYNC ;
10980 wxPyProcess *result;
10981 bool temp1 = false ;
10982 PyObject * obj0 = 0 ;
10983 PyObject * obj1 = 0 ;
10984 char *kwnames[] = {
10985 (char *) "cmd",(char *) "flags", NULL
10986 };
10987
10988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10989 {
10990 arg1 = wxString_in_helper(obj0);
10991 if (arg1 == NULL) SWIG_fail;
10992 temp1 = true;
10993 }
10994 if (obj1) {
10995 {
10996 arg2 = (int)(SWIG_As_int(obj1));
10997 if (SWIG_arg_fail(2)) SWIG_fail;
10998 }
10999 }
11000 {
11001 PyThreadState* __tstate = wxPyBeginAllowThreads();
11002 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
11003
11004 wxPyEndAllowThreads(__tstate);
11005 if (PyErr_Occurred()) SWIG_fail;
11006 }
11007 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
11008 {
11009 if (temp1)
11010 delete arg1;
11011 }
11012 return resultobj;
11013 fail:
11014 {
11015 if (temp1)
11016 delete arg1;
11017 }
11018 return NULL;
11019 }
11020
11021
11022 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
11023 PyObject *resultobj;
11024 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11025 int arg2 = (int) -1 ;
11026 wxPyProcess *result;
11027 PyObject * obj0 = 0 ;
11028 PyObject * obj1 = 0 ;
11029 char *kwnames[] = {
11030 (char *) "parent",(char *) "id", NULL
11031 };
11032
11033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
11034 if (obj0) {
11035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
11036 if (SWIG_arg_fail(1)) SWIG_fail;
11037 }
11038 if (obj1) {
11039 {
11040 arg2 = (int)(SWIG_As_int(obj1));
11041 if (SWIG_arg_fail(2)) SWIG_fail;
11042 }
11043 }
11044 {
11045 PyThreadState* __tstate = wxPyBeginAllowThreads();
11046 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
11047
11048 wxPyEndAllowThreads(__tstate);
11049 if (PyErr_Occurred()) SWIG_fail;
11050 }
11051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
11052 return resultobj;
11053 fail:
11054 return NULL;
11055 }
11056
11057
11058 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11059 PyObject *resultobj;
11060 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11061 PyObject *arg2 = (PyObject *) 0 ;
11062 PyObject *arg3 = (PyObject *) 0 ;
11063 PyObject * obj0 = 0 ;
11064 PyObject * obj1 = 0 ;
11065 PyObject * obj2 = 0 ;
11066 char *kwnames[] = {
11067 (char *) "self",(char *) "self",(char *) "_class", NULL
11068 };
11069
11070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11072 if (SWIG_arg_fail(1)) SWIG_fail;
11073 arg2 = obj1;
11074 arg3 = obj2;
11075 {
11076 PyThreadState* __tstate = wxPyBeginAllowThreads();
11077 (arg1)->_setCallbackInfo(arg2,arg3);
11078
11079 wxPyEndAllowThreads(__tstate);
11080 if (PyErr_Occurred()) SWIG_fail;
11081 }
11082 Py_INCREF(Py_None); resultobj = Py_None;
11083 return resultobj;
11084 fail:
11085 return NULL;
11086 }
11087
11088
11089 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11090 PyObject *resultobj;
11091 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11092 int arg2 ;
11093 int arg3 ;
11094 PyObject * obj0 = 0 ;
11095 PyObject * obj1 = 0 ;
11096 PyObject * obj2 = 0 ;
11097 char *kwnames[] = {
11098 (char *) "self",(char *) "pid",(char *) "status", NULL
11099 };
11100
11101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11103 if (SWIG_arg_fail(1)) SWIG_fail;
11104 {
11105 arg2 = (int)(SWIG_As_int(obj1));
11106 if (SWIG_arg_fail(2)) SWIG_fail;
11107 }
11108 {
11109 arg3 = (int)(SWIG_As_int(obj2));
11110 if (SWIG_arg_fail(3)) SWIG_fail;
11111 }
11112 {
11113 PyThreadState* __tstate = wxPyBeginAllowThreads();
11114 (arg1)->base_OnTerminate(arg2,arg3);
11115
11116 wxPyEndAllowThreads(__tstate);
11117 if (PyErr_Occurred()) SWIG_fail;
11118 }
11119 Py_INCREF(Py_None); resultobj = Py_None;
11120 return resultobj;
11121 fail:
11122 return NULL;
11123 }
11124
11125
11126 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11127 PyObject *resultobj;
11128 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11129 PyObject * obj0 = 0 ;
11130 char *kwnames[] = {
11131 (char *) "self", NULL
11132 };
11133
11134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11136 if (SWIG_arg_fail(1)) SWIG_fail;
11137 {
11138 PyThreadState* __tstate = wxPyBeginAllowThreads();
11139 (arg1)->Redirect();
11140
11141 wxPyEndAllowThreads(__tstate);
11142 if (PyErr_Occurred()) SWIG_fail;
11143 }
11144 Py_INCREF(Py_None); resultobj = Py_None;
11145 return resultobj;
11146 fail:
11147 return NULL;
11148 }
11149
11150
11151 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11152 PyObject *resultobj;
11153 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11154 bool result;
11155 PyObject * obj0 = 0 ;
11156 char *kwnames[] = {
11157 (char *) "self", NULL
11158 };
11159
11160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11162 if (SWIG_arg_fail(1)) SWIG_fail;
11163 {
11164 PyThreadState* __tstate = wxPyBeginAllowThreads();
11165 result = (bool)(arg1)->IsRedirected();
11166
11167 wxPyEndAllowThreads(__tstate);
11168 if (PyErr_Occurred()) SWIG_fail;
11169 }
11170 {
11171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11172 }
11173 return resultobj;
11174 fail:
11175 return NULL;
11176 }
11177
11178
11179 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11180 PyObject *resultobj;
11181 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11182 PyObject * obj0 = 0 ;
11183 char *kwnames[] = {
11184 (char *) "self", NULL
11185 };
11186
11187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11189 if (SWIG_arg_fail(1)) SWIG_fail;
11190 {
11191 PyThreadState* __tstate = wxPyBeginAllowThreads();
11192 (arg1)->Detach();
11193
11194 wxPyEndAllowThreads(__tstate);
11195 if (PyErr_Occurred()) SWIG_fail;
11196 }
11197 Py_INCREF(Py_None); resultobj = Py_None;
11198 return resultobj;
11199 fail:
11200 return NULL;
11201 }
11202
11203
11204 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11205 PyObject *resultobj;
11206 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11207 wxInputStream *result;
11208 PyObject * obj0 = 0 ;
11209 char *kwnames[] = {
11210 (char *) "self", NULL
11211 };
11212
11213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",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 result = (wxInputStream *)(arg1)->GetInputStream();
11219
11220 wxPyEndAllowThreads(__tstate);
11221 if (PyErr_Occurred()) SWIG_fail;
11222 }
11223 {
11224 wxPyInputStream * _ptr = NULL;
11225
11226 if (result) {
11227 _ptr = new wxPyInputStream(result);
11228 }
11229 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11230 }
11231 return resultobj;
11232 fail:
11233 return NULL;
11234 }
11235
11236
11237 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11238 PyObject *resultobj;
11239 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11240 wxInputStream *result;
11241 PyObject * obj0 = 0 ;
11242 char *kwnames[] = {
11243 (char *) "self", NULL
11244 };
11245
11246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11248 if (SWIG_arg_fail(1)) SWIG_fail;
11249 {
11250 PyThreadState* __tstate = wxPyBeginAllowThreads();
11251 result = (wxInputStream *)(arg1)->GetErrorStream();
11252
11253 wxPyEndAllowThreads(__tstate);
11254 if (PyErr_Occurred()) SWIG_fail;
11255 }
11256 {
11257 wxPyInputStream * _ptr = NULL;
11258
11259 if (result) {
11260 _ptr = new wxPyInputStream(result);
11261 }
11262 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11263 }
11264 return resultobj;
11265 fail:
11266 return NULL;
11267 }
11268
11269
11270 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11271 PyObject *resultobj;
11272 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11273 wxOutputStream *result;
11274 PyObject * obj0 = 0 ;
11275 char *kwnames[] = {
11276 (char *) "self", NULL
11277 };
11278
11279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11281 if (SWIG_arg_fail(1)) SWIG_fail;
11282 {
11283 PyThreadState* __tstate = wxPyBeginAllowThreads();
11284 result = (wxOutputStream *)(arg1)->GetOutputStream();
11285
11286 wxPyEndAllowThreads(__tstate);
11287 if (PyErr_Occurred()) SWIG_fail;
11288 }
11289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11290 return resultobj;
11291 fail:
11292 return NULL;
11293 }
11294
11295
11296 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11297 PyObject *resultobj;
11298 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11299 PyObject * obj0 = 0 ;
11300 char *kwnames[] = {
11301 (char *) "self", NULL
11302 };
11303
11304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11306 if (SWIG_arg_fail(1)) SWIG_fail;
11307 {
11308 PyThreadState* __tstate = wxPyBeginAllowThreads();
11309 (arg1)->CloseOutput();
11310
11311 wxPyEndAllowThreads(__tstate);
11312 if (PyErr_Occurred()) SWIG_fail;
11313 }
11314 Py_INCREF(Py_None); resultobj = Py_None;
11315 return resultobj;
11316 fail:
11317 return NULL;
11318 }
11319
11320
11321 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11322 PyObject *resultobj;
11323 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11324 bool result;
11325 PyObject * obj0 = 0 ;
11326 char *kwnames[] = {
11327 (char *) "self", NULL
11328 };
11329
11330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11332 if (SWIG_arg_fail(1)) SWIG_fail;
11333 {
11334 PyThreadState* __tstate = wxPyBeginAllowThreads();
11335 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11336
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 {
11341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11342 }
11343 return resultobj;
11344 fail:
11345 return NULL;
11346 }
11347
11348
11349 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11350 PyObject *resultobj;
11351 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11352 bool result;
11353 PyObject * obj0 = 0 ;
11354 char *kwnames[] = {
11355 (char *) "self", NULL
11356 };
11357
11358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11360 if (SWIG_arg_fail(1)) SWIG_fail;
11361 {
11362 PyThreadState* __tstate = wxPyBeginAllowThreads();
11363 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11364
11365 wxPyEndAllowThreads(__tstate);
11366 if (PyErr_Occurred()) SWIG_fail;
11367 }
11368 {
11369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11370 }
11371 return resultobj;
11372 fail:
11373 return NULL;
11374 }
11375
11376
11377 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj;
11379 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11380 bool result;
11381 PyObject * obj0 = 0 ;
11382 char *kwnames[] = {
11383 (char *) "self", NULL
11384 };
11385
11386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11388 if (SWIG_arg_fail(1)) SWIG_fail;
11389 {
11390 PyThreadState* __tstate = wxPyBeginAllowThreads();
11391 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11392
11393 wxPyEndAllowThreads(__tstate);
11394 if (PyErr_Occurred()) SWIG_fail;
11395 }
11396 {
11397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11398 }
11399 return resultobj;
11400 fail:
11401 return NULL;
11402 }
11403
11404
11405 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11406 PyObject *obj;
11407 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11408 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11409 Py_INCREF(obj);
11410 return Py_BuildValue((char *)"");
11411 }
11412 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11413 PyObject *resultobj;
11414 int arg1 = (int) 0 ;
11415 int arg2 = (int) 0 ;
11416 int arg3 = (int) 0 ;
11417 wxProcessEvent *result;
11418 PyObject * obj0 = 0 ;
11419 PyObject * obj1 = 0 ;
11420 PyObject * obj2 = 0 ;
11421 char *kwnames[] = {
11422 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11423 };
11424
11425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11426 if (obj0) {
11427 {
11428 arg1 = (int)(SWIG_As_int(obj0));
11429 if (SWIG_arg_fail(1)) SWIG_fail;
11430 }
11431 }
11432 if (obj1) {
11433 {
11434 arg2 = (int)(SWIG_As_int(obj1));
11435 if (SWIG_arg_fail(2)) SWIG_fail;
11436 }
11437 }
11438 if (obj2) {
11439 {
11440 arg3 = (int)(SWIG_As_int(obj2));
11441 if (SWIG_arg_fail(3)) SWIG_fail;
11442 }
11443 }
11444 {
11445 PyThreadState* __tstate = wxPyBeginAllowThreads();
11446 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11447
11448 wxPyEndAllowThreads(__tstate);
11449 if (PyErr_Occurred()) SWIG_fail;
11450 }
11451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11452 return resultobj;
11453 fail:
11454 return NULL;
11455 }
11456
11457
11458 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11459 PyObject *resultobj;
11460 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11461 int result;
11462 PyObject * obj0 = 0 ;
11463 char *kwnames[] = {
11464 (char *) "self", NULL
11465 };
11466
11467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11469 if (SWIG_arg_fail(1)) SWIG_fail;
11470 {
11471 PyThreadState* __tstate = wxPyBeginAllowThreads();
11472 result = (int)(arg1)->GetPid();
11473
11474 wxPyEndAllowThreads(__tstate);
11475 if (PyErr_Occurred()) SWIG_fail;
11476 }
11477 {
11478 resultobj = SWIG_From_int((int)(result));
11479 }
11480 return resultobj;
11481 fail:
11482 return NULL;
11483 }
11484
11485
11486 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11487 PyObject *resultobj;
11488 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11489 int result;
11490 PyObject * obj0 = 0 ;
11491 char *kwnames[] = {
11492 (char *) "self", NULL
11493 };
11494
11495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11497 if (SWIG_arg_fail(1)) SWIG_fail;
11498 {
11499 PyThreadState* __tstate = wxPyBeginAllowThreads();
11500 result = (int)(arg1)->GetExitCode();
11501
11502 wxPyEndAllowThreads(__tstate);
11503 if (PyErr_Occurred()) SWIG_fail;
11504 }
11505 {
11506 resultobj = SWIG_From_int((int)(result));
11507 }
11508 return resultobj;
11509 fail:
11510 return NULL;
11511 }
11512
11513
11514 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11515 PyObject *resultobj;
11516 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11517 int arg2 ;
11518 PyObject * obj0 = 0 ;
11519 PyObject * obj1 = 0 ;
11520 char *kwnames[] = {
11521 (char *) "self",(char *) "m_pid", NULL
11522 };
11523
11524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11526 if (SWIG_arg_fail(1)) SWIG_fail;
11527 {
11528 arg2 = (int)(SWIG_As_int(obj1));
11529 if (SWIG_arg_fail(2)) SWIG_fail;
11530 }
11531 if (arg1) (arg1)->m_pid = arg2;
11532
11533 Py_INCREF(Py_None); resultobj = Py_None;
11534 return resultobj;
11535 fail:
11536 return NULL;
11537 }
11538
11539
11540 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11541 PyObject *resultobj;
11542 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11543 int result;
11544 PyObject * obj0 = 0 ;
11545 char *kwnames[] = {
11546 (char *) "self", NULL
11547 };
11548
11549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11551 if (SWIG_arg_fail(1)) SWIG_fail;
11552 result = (int) ((arg1)->m_pid);
11553
11554 {
11555 resultobj = SWIG_From_int((int)(result));
11556 }
11557 return resultobj;
11558 fail:
11559 return NULL;
11560 }
11561
11562
11563 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11564 PyObject *resultobj;
11565 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11566 int arg2 ;
11567 PyObject * obj0 = 0 ;
11568 PyObject * obj1 = 0 ;
11569 char *kwnames[] = {
11570 (char *) "self",(char *) "m_exitcode", NULL
11571 };
11572
11573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11575 if (SWIG_arg_fail(1)) SWIG_fail;
11576 {
11577 arg2 = (int)(SWIG_As_int(obj1));
11578 if (SWIG_arg_fail(2)) SWIG_fail;
11579 }
11580 if (arg1) (arg1)->m_exitcode = arg2;
11581
11582 Py_INCREF(Py_None); resultobj = Py_None;
11583 return resultobj;
11584 fail:
11585 return NULL;
11586 }
11587
11588
11589 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11590 PyObject *resultobj;
11591 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11592 int result;
11593 PyObject * obj0 = 0 ;
11594 char *kwnames[] = {
11595 (char *) "self", NULL
11596 };
11597
11598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11600 if (SWIG_arg_fail(1)) SWIG_fail;
11601 result = (int) ((arg1)->m_exitcode);
11602
11603 {
11604 resultobj = SWIG_From_int((int)(result));
11605 }
11606 return resultobj;
11607 fail:
11608 return NULL;
11609 }
11610
11611
11612 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11613 PyObject *obj;
11614 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11615 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11616 Py_INCREF(obj);
11617 return Py_BuildValue((char *)"");
11618 }
11619 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11620 PyObject *resultobj;
11621 wxString *arg1 = 0 ;
11622 int arg2 = (int) wxEXEC_ASYNC ;
11623 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11624 long result;
11625 bool temp1 = false ;
11626 PyObject * obj0 = 0 ;
11627 PyObject * obj1 = 0 ;
11628 PyObject * obj2 = 0 ;
11629 char *kwnames[] = {
11630 (char *) "command",(char *) "flags",(char *) "process", NULL
11631 };
11632
11633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11634 {
11635 arg1 = wxString_in_helper(obj0);
11636 if (arg1 == NULL) SWIG_fail;
11637 temp1 = true;
11638 }
11639 if (obj1) {
11640 {
11641 arg2 = (int)(SWIG_As_int(obj1));
11642 if (SWIG_arg_fail(2)) SWIG_fail;
11643 }
11644 }
11645 if (obj2) {
11646 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11647 if (SWIG_arg_fail(3)) SWIG_fail;
11648 }
11649 {
11650 if (!wxPyCheckForApp()) SWIG_fail;
11651 PyThreadState* __tstate = wxPyBeginAllowThreads();
11652 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11653
11654 wxPyEndAllowThreads(__tstate);
11655 if (PyErr_Occurred()) SWIG_fail;
11656 }
11657 {
11658 resultobj = SWIG_From_long((long)(result));
11659 }
11660 {
11661 if (temp1)
11662 delete arg1;
11663 }
11664 return resultobj;
11665 fail:
11666 {
11667 if (temp1)
11668 delete arg1;
11669 }
11670 return NULL;
11671 }
11672
11673
11674 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11675 PyObject *resultobj;
11676 long arg1 ;
11677 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11678 wxKillError *arg3 = (wxKillError *) 0 ;
11679 int arg4 = (int) wxKILL_NOCHILDREN ;
11680 int result;
11681 wxKillError temp3 ;
11682 PyObject * obj0 = 0 ;
11683 PyObject * obj1 = 0 ;
11684 PyObject * obj2 = 0 ;
11685 char *kwnames[] = {
11686 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11687 };
11688
11689 {
11690 arg3 = &temp3;
11691 }
11692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11693 {
11694 arg1 = (long)(SWIG_As_long(obj0));
11695 if (SWIG_arg_fail(1)) SWIG_fail;
11696 }
11697 if (obj1) {
11698 {
11699 arg2 = (wxSignal)(SWIG_As_int(obj1));
11700 if (SWIG_arg_fail(2)) SWIG_fail;
11701 }
11702 }
11703 if (obj2) {
11704 {
11705 arg4 = (int)(SWIG_As_int(obj2));
11706 if (SWIG_arg_fail(4)) SWIG_fail;
11707 }
11708 }
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11712
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 {
11717 resultobj = SWIG_From_int((int)(result));
11718 }
11719 {
11720 PyObject* o;
11721 o = PyInt_FromLong((long) (*arg3));
11722 resultobj = t_output_helper(resultobj, o);
11723 }
11724 return resultobj;
11725 fail:
11726 return NULL;
11727 }
11728
11729
11730 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11731 PyObject *resultobj;
11732 int arg1 = (int) wxJOYSTICK1 ;
11733 wxJoystick *result;
11734 PyObject * obj0 = 0 ;
11735 char *kwnames[] = {
11736 (char *) "joystick", NULL
11737 };
11738
11739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11740 if (obj0) {
11741 {
11742 arg1 = (int)(SWIG_As_int(obj0));
11743 if (SWIG_arg_fail(1)) SWIG_fail;
11744 }
11745 }
11746 {
11747 if (!wxPyCheckForApp()) SWIG_fail;
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 result = (wxJoystick *)new wxJoystick(arg1);
11750
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11755 return resultobj;
11756 fail:
11757 return NULL;
11758 }
11759
11760
11761 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11762 PyObject *resultobj;
11763 wxJoystick *arg1 = (wxJoystick *) 0 ;
11764 PyObject * obj0 = 0 ;
11765 char *kwnames[] = {
11766 (char *) "self", NULL
11767 };
11768
11769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11771 if (SWIG_arg_fail(1)) SWIG_fail;
11772 {
11773 PyThreadState* __tstate = wxPyBeginAllowThreads();
11774 delete arg1;
11775
11776 wxPyEndAllowThreads(__tstate);
11777 if (PyErr_Occurred()) SWIG_fail;
11778 }
11779 Py_INCREF(Py_None); resultobj = Py_None;
11780 return resultobj;
11781 fail:
11782 return NULL;
11783 }
11784
11785
11786 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11787 PyObject *resultobj;
11788 wxJoystick *arg1 = (wxJoystick *) 0 ;
11789 wxPoint result;
11790 PyObject * obj0 = 0 ;
11791 char *kwnames[] = {
11792 (char *) "self", NULL
11793 };
11794
11795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11797 if (SWIG_arg_fail(1)) SWIG_fail;
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 result = (arg1)->GetPosition();
11801
11802 wxPyEndAllowThreads(__tstate);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 {
11806 wxPoint * resultptr;
11807 resultptr = new wxPoint((wxPoint &)(result));
11808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11809 }
11810 return resultobj;
11811 fail:
11812 return NULL;
11813 }
11814
11815
11816 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11817 PyObject *resultobj;
11818 wxJoystick *arg1 = (wxJoystick *) 0 ;
11819 int result;
11820 PyObject * obj0 = 0 ;
11821 char *kwnames[] = {
11822 (char *) "self", NULL
11823 };
11824
11825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11827 if (SWIG_arg_fail(1)) SWIG_fail;
11828 {
11829 PyThreadState* __tstate = wxPyBeginAllowThreads();
11830 result = (int)(arg1)->GetZPosition();
11831
11832 wxPyEndAllowThreads(__tstate);
11833 if (PyErr_Occurred()) SWIG_fail;
11834 }
11835 {
11836 resultobj = SWIG_From_int((int)(result));
11837 }
11838 return resultobj;
11839 fail:
11840 return NULL;
11841 }
11842
11843
11844 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11845 PyObject *resultobj;
11846 wxJoystick *arg1 = (wxJoystick *) 0 ;
11847 int result;
11848 PyObject * obj0 = 0 ;
11849 char *kwnames[] = {
11850 (char *) "self", NULL
11851 };
11852
11853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11855 if (SWIG_arg_fail(1)) SWIG_fail;
11856 {
11857 PyThreadState* __tstate = wxPyBeginAllowThreads();
11858 result = (int)(arg1)->GetButtonState();
11859
11860 wxPyEndAllowThreads(__tstate);
11861 if (PyErr_Occurred()) SWIG_fail;
11862 }
11863 {
11864 resultobj = SWIG_From_int((int)(result));
11865 }
11866 return resultobj;
11867 fail:
11868 return NULL;
11869 }
11870
11871
11872 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11873 PyObject *resultobj;
11874 wxJoystick *arg1 = (wxJoystick *) 0 ;
11875 int result;
11876 PyObject * obj0 = 0 ;
11877 char *kwnames[] = {
11878 (char *) "self", NULL
11879 };
11880
11881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11883 if (SWIG_arg_fail(1)) SWIG_fail;
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 result = (int)(arg1)->GetPOVPosition();
11887
11888 wxPyEndAllowThreads(__tstate);
11889 if (PyErr_Occurred()) SWIG_fail;
11890 }
11891 {
11892 resultobj = SWIG_From_int((int)(result));
11893 }
11894 return resultobj;
11895 fail:
11896 return NULL;
11897 }
11898
11899
11900 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11901 PyObject *resultobj;
11902 wxJoystick *arg1 = (wxJoystick *) 0 ;
11903 int result;
11904 PyObject * obj0 = 0 ;
11905 char *kwnames[] = {
11906 (char *) "self", NULL
11907 };
11908
11909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11911 if (SWIG_arg_fail(1)) SWIG_fail;
11912 {
11913 PyThreadState* __tstate = wxPyBeginAllowThreads();
11914 result = (int)(arg1)->GetPOVCTSPosition();
11915
11916 wxPyEndAllowThreads(__tstate);
11917 if (PyErr_Occurred()) SWIG_fail;
11918 }
11919 {
11920 resultobj = SWIG_From_int((int)(result));
11921 }
11922 return resultobj;
11923 fail:
11924 return NULL;
11925 }
11926
11927
11928 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11929 PyObject *resultobj;
11930 wxJoystick *arg1 = (wxJoystick *) 0 ;
11931 int result;
11932 PyObject * obj0 = 0 ;
11933 char *kwnames[] = {
11934 (char *) "self", NULL
11935 };
11936
11937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11939 if (SWIG_arg_fail(1)) SWIG_fail;
11940 {
11941 PyThreadState* __tstate = wxPyBeginAllowThreads();
11942 result = (int)(arg1)->GetRudderPosition();
11943
11944 wxPyEndAllowThreads(__tstate);
11945 if (PyErr_Occurred()) SWIG_fail;
11946 }
11947 {
11948 resultobj = SWIG_From_int((int)(result));
11949 }
11950 return resultobj;
11951 fail:
11952 return NULL;
11953 }
11954
11955
11956 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11957 PyObject *resultobj;
11958 wxJoystick *arg1 = (wxJoystick *) 0 ;
11959 int result;
11960 PyObject * obj0 = 0 ;
11961 char *kwnames[] = {
11962 (char *) "self", NULL
11963 };
11964
11965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11967 if (SWIG_arg_fail(1)) SWIG_fail;
11968 {
11969 PyThreadState* __tstate = wxPyBeginAllowThreads();
11970 result = (int)(arg1)->GetUPosition();
11971
11972 wxPyEndAllowThreads(__tstate);
11973 if (PyErr_Occurred()) SWIG_fail;
11974 }
11975 {
11976 resultobj = SWIG_From_int((int)(result));
11977 }
11978 return resultobj;
11979 fail:
11980 return NULL;
11981 }
11982
11983
11984 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11985 PyObject *resultobj;
11986 wxJoystick *arg1 = (wxJoystick *) 0 ;
11987 int result;
11988 PyObject * obj0 = 0 ;
11989 char *kwnames[] = {
11990 (char *) "self", NULL
11991 };
11992
11993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11995 if (SWIG_arg_fail(1)) SWIG_fail;
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 result = (int)(arg1)->GetVPosition();
11999
12000 wxPyEndAllowThreads(__tstate);
12001 if (PyErr_Occurred()) SWIG_fail;
12002 }
12003 {
12004 resultobj = SWIG_From_int((int)(result));
12005 }
12006 return resultobj;
12007 fail:
12008 return NULL;
12009 }
12010
12011
12012 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12013 PyObject *resultobj;
12014 wxJoystick *arg1 = (wxJoystick *) 0 ;
12015 int result;
12016 PyObject * obj0 = 0 ;
12017 char *kwnames[] = {
12018 (char *) "self", NULL
12019 };
12020
12021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
12022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12023 if (SWIG_arg_fail(1)) SWIG_fail;
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 result = (int)(arg1)->GetMovementThreshold();
12027
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 {
12032 resultobj = SWIG_From_int((int)(result));
12033 }
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj;
12042 wxJoystick *arg1 = (wxJoystick *) 0 ;
12043 int arg2 ;
12044 PyObject * obj0 = 0 ;
12045 PyObject * obj1 = 0 ;
12046 char *kwnames[] = {
12047 (char *) "self",(char *) "threshold", NULL
12048 };
12049
12050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
12051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12052 if (SWIG_arg_fail(1)) SWIG_fail;
12053 {
12054 arg2 = (int)(SWIG_As_int(obj1));
12055 if (SWIG_arg_fail(2)) SWIG_fail;
12056 }
12057 {
12058 PyThreadState* __tstate = wxPyBeginAllowThreads();
12059 (arg1)->SetMovementThreshold(arg2);
12060
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 Py_INCREF(Py_None); resultobj = Py_None;
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12072 PyObject *resultobj;
12073 wxJoystick *arg1 = (wxJoystick *) 0 ;
12074 bool result;
12075 PyObject * obj0 = 0 ;
12076 char *kwnames[] = {
12077 (char *) "self", NULL
12078 };
12079
12080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
12081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12082 if (SWIG_arg_fail(1)) SWIG_fail;
12083 {
12084 PyThreadState* __tstate = wxPyBeginAllowThreads();
12085 result = (bool)(arg1)->IsOk();
12086
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 {
12091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12092 }
12093 return resultobj;
12094 fail:
12095 return NULL;
12096 }
12097
12098
12099 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12100 PyObject *resultobj;
12101 wxJoystick *arg1 = (wxJoystick *) 0 ;
12102 int result;
12103 PyObject * obj0 = 0 ;
12104 char *kwnames[] = {
12105 (char *) "self", NULL
12106 };
12107
12108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12110 if (SWIG_arg_fail(1)) SWIG_fail;
12111 {
12112 PyThreadState* __tstate = wxPyBeginAllowThreads();
12113 result = (int)(arg1)->GetNumberJoysticks();
12114
12115 wxPyEndAllowThreads(__tstate);
12116 if (PyErr_Occurred()) SWIG_fail;
12117 }
12118 {
12119 resultobj = SWIG_From_int((int)(result));
12120 }
12121 return resultobj;
12122 fail:
12123 return NULL;
12124 }
12125
12126
12127 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12128 PyObject *resultobj;
12129 wxJoystick *arg1 = (wxJoystick *) 0 ;
12130 int result;
12131 PyObject * obj0 = 0 ;
12132 char *kwnames[] = {
12133 (char *) "self", NULL
12134 };
12135
12136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12138 if (SWIG_arg_fail(1)) SWIG_fail;
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 result = (int)(arg1)->GetManufacturerId();
12142
12143 wxPyEndAllowThreads(__tstate);
12144 if (PyErr_Occurred()) SWIG_fail;
12145 }
12146 {
12147 resultobj = SWIG_From_int((int)(result));
12148 }
12149 return resultobj;
12150 fail:
12151 return NULL;
12152 }
12153
12154
12155 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12156 PyObject *resultobj;
12157 wxJoystick *arg1 = (wxJoystick *) 0 ;
12158 int result;
12159 PyObject * obj0 = 0 ;
12160 char *kwnames[] = {
12161 (char *) "self", NULL
12162 };
12163
12164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12166 if (SWIG_arg_fail(1)) SWIG_fail;
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 result = (int)(arg1)->GetProductId();
12170
12171 wxPyEndAllowThreads(__tstate);
12172 if (PyErr_Occurred()) SWIG_fail;
12173 }
12174 {
12175 resultobj = SWIG_From_int((int)(result));
12176 }
12177 return resultobj;
12178 fail:
12179 return NULL;
12180 }
12181
12182
12183 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12184 PyObject *resultobj;
12185 wxJoystick *arg1 = (wxJoystick *) 0 ;
12186 wxString result;
12187 PyObject * obj0 = 0 ;
12188 char *kwnames[] = {
12189 (char *) "self", NULL
12190 };
12191
12192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12194 if (SWIG_arg_fail(1)) SWIG_fail;
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 result = (arg1)->GetProductName();
12198
12199 wxPyEndAllowThreads(__tstate);
12200 if (PyErr_Occurred()) SWIG_fail;
12201 }
12202 {
12203 #if wxUSE_UNICODE
12204 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12205 #else
12206 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12207 #endif
12208 }
12209 return resultobj;
12210 fail:
12211 return NULL;
12212 }
12213
12214
12215 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12216 PyObject *resultobj;
12217 wxJoystick *arg1 = (wxJoystick *) 0 ;
12218 int result;
12219 PyObject * obj0 = 0 ;
12220 char *kwnames[] = {
12221 (char *) "self", NULL
12222 };
12223
12224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12226 if (SWIG_arg_fail(1)) SWIG_fail;
12227 {
12228 PyThreadState* __tstate = wxPyBeginAllowThreads();
12229 result = (int)(arg1)->GetXMin();
12230
12231 wxPyEndAllowThreads(__tstate);
12232 if (PyErr_Occurred()) SWIG_fail;
12233 }
12234 {
12235 resultobj = SWIG_From_int((int)(result));
12236 }
12237 return resultobj;
12238 fail:
12239 return NULL;
12240 }
12241
12242
12243 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12244 PyObject *resultobj;
12245 wxJoystick *arg1 = (wxJoystick *) 0 ;
12246 int result;
12247 PyObject * obj0 = 0 ;
12248 char *kwnames[] = {
12249 (char *) "self", NULL
12250 };
12251
12252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12254 if (SWIG_arg_fail(1)) SWIG_fail;
12255 {
12256 PyThreadState* __tstate = wxPyBeginAllowThreads();
12257 result = (int)(arg1)->GetYMin();
12258
12259 wxPyEndAllowThreads(__tstate);
12260 if (PyErr_Occurred()) SWIG_fail;
12261 }
12262 {
12263 resultobj = SWIG_From_int((int)(result));
12264 }
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj;
12273 wxJoystick *arg1 = (wxJoystick *) 0 ;
12274 int result;
12275 PyObject * obj0 = 0 ;
12276 char *kwnames[] = {
12277 (char *) "self", NULL
12278 };
12279
12280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12282 if (SWIG_arg_fail(1)) SWIG_fail;
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 result = (int)(arg1)->GetZMin();
12286
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 {
12291 resultobj = SWIG_From_int((int)(result));
12292 }
12293 return resultobj;
12294 fail:
12295 return NULL;
12296 }
12297
12298
12299 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12300 PyObject *resultobj;
12301 wxJoystick *arg1 = (wxJoystick *) 0 ;
12302 int result;
12303 PyObject * obj0 = 0 ;
12304 char *kwnames[] = {
12305 (char *) "self", NULL
12306 };
12307
12308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12310 if (SWIG_arg_fail(1)) SWIG_fail;
12311 {
12312 PyThreadState* __tstate = wxPyBeginAllowThreads();
12313 result = (int)(arg1)->GetXMax();
12314
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 {
12319 resultobj = SWIG_From_int((int)(result));
12320 }
12321 return resultobj;
12322 fail:
12323 return NULL;
12324 }
12325
12326
12327 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12328 PyObject *resultobj;
12329 wxJoystick *arg1 = (wxJoystick *) 0 ;
12330 int result;
12331 PyObject * obj0 = 0 ;
12332 char *kwnames[] = {
12333 (char *) "self", NULL
12334 };
12335
12336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12338 if (SWIG_arg_fail(1)) SWIG_fail;
12339 {
12340 PyThreadState* __tstate = wxPyBeginAllowThreads();
12341 result = (int)(arg1)->GetYMax();
12342
12343 wxPyEndAllowThreads(__tstate);
12344 if (PyErr_Occurred()) SWIG_fail;
12345 }
12346 {
12347 resultobj = SWIG_From_int((int)(result));
12348 }
12349 return resultobj;
12350 fail:
12351 return NULL;
12352 }
12353
12354
12355 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12356 PyObject *resultobj;
12357 wxJoystick *arg1 = (wxJoystick *) 0 ;
12358 int result;
12359 PyObject * obj0 = 0 ;
12360 char *kwnames[] = {
12361 (char *) "self", NULL
12362 };
12363
12364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12366 if (SWIG_arg_fail(1)) SWIG_fail;
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 result = (int)(arg1)->GetZMax();
12370
12371 wxPyEndAllowThreads(__tstate);
12372 if (PyErr_Occurred()) SWIG_fail;
12373 }
12374 {
12375 resultobj = SWIG_From_int((int)(result));
12376 }
12377 return resultobj;
12378 fail:
12379 return NULL;
12380 }
12381
12382
12383 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12384 PyObject *resultobj;
12385 wxJoystick *arg1 = (wxJoystick *) 0 ;
12386 int result;
12387 PyObject * obj0 = 0 ;
12388 char *kwnames[] = {
12389 (char *) "self", NULL
12390 };
12391
12392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12394 if (SWIG_arg_fail(1)) SWIG_fail;
12395 {
12396 PyThreadState* __tstate = wxPyBeginAllowThreads();
12397 result = (int)(arg1)->GetNumberButtons();
12398
12399 wxPyEndAllowThreads(__tstate);
12400 if (PyErr_Occurred()) SWIG_fail;
12401 }
12402 {
12403 resultobj = SWIG_From_int((int)(result));
12404 }
12405 return resultobj;
12406 fail:
12407 return NULL;
12408 }
12409
12410
12411 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12412 PyObject *resultobj;
12413 wxJoystick *arg1 = (wxJoystick *) 0 ;
12414 int result;
12415 PyObject * obj0 = 0 ;
12416 char *kwnames[] = {
12417 (char *) "self", NULL
12418 };
12419
12420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12422 if (SWIG_arg_fail(1)) SWIG_fail;
12423 {
12424 PyThreadState* __tstate = wxPyBeginAllowThreads();
12425 result = (int)(arg1)->GetNumberAxes();
12426
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 {
12431 resultobj = SWIG_From_int((int)(result));
12432 }
12433 return resultobj;
12434 fail:
12435 return NULL;
12436 }
12437
12438
12439 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12440 PyObject *resultobj;
12441 wxJoystick *arg1 = (wxJoystick *) 0 ;
12442 int result;
12443 PyObject * obj0 = 0 ;
12444 char *kwnames[] = {
12445 (char *) "self", NULL
12446 };
12447
12448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12450 if (SWIG_arg_fail(1)) SWIG_fail;
12451 {
12452 PyThreadState* __tstate = wxPyBeginAllowThreads();
12453 result = (int)(arg1)->GetMaxButtons();
12454
12455 wxPyEndAllowThreads(__tstate);
12456 if (PyErr_Occurred()) SWIG_fail;
12457 }
12458 {
12459 resultobj = SWIG_From_int((int)(result));
12460 }
12461 return resultobj;
12462 fail:
12463 return NULL;
12464 }
12465
12466
12467 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12468 PyObject *resultobj;
12469 wxJoystick *arg1 = (wxJoystick *) 0 ;
12470 int result;
12471 PyObject * obj0 = 0 ;
12472 char *kwnames[] = {
12473 (char *) "self", NULL
12474 };
12475
12476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12478 if (SWIG_arg_fail(1)) SWIG_fail;
12479 {
12480 PyThreadState* __tstate = wxPyBeginAllowThreads();
12481 result = (int)(arg1)->GetMaxAxes();
12482
12483 wxPyEndAllowThreads(__tstate);
12484 if (PyErr_Occurred()) SWIG_fail;
12485 }
12486 {
12487 resultobj = SWIG_From_int((int)(result));
12488 }
12489 return resultobj;
12490 fail:
12491 return NULL;
12492 }
12493
12494
12495 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12496 PyObject *resultobj;
12497 wxJoystick *arg1 = (wxJoystick *) 0 ;
12498 int result;
12499 PyObject * obj0 = 0 ;
12500 char *kwnames[] = {
12501 (char *) "self", NULL
12502 };
12503
12504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12506 if (SWIG_arg_fail(1)) SWIG_fail;
12507 {
12508 PyThreadState* __tstate = wxPyBeginAllowThreads();
12509 result = (int)(arg1)->GetPollingMin();
12510
12511 wxPyEndAllowThreads(__tstate);
12512 if (PyErr_Occurred()) SWIG_fail;
12513 }
12514 {
12515 resultobj = SWIG_From_int((int)(result));
12516 }
12517 return resultobj;
12518 fail:
12519 return NULL;
12520 }
12521
12522
12523 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12524 PyObject *resultobj;
12525 wxJoystick *arg1 = (wxJoystick *) 0 ;
12526 int result;
12527 PyObject * obj0 = 0 ;
12528 char *kwnames[] = {
12529 (char *) "self", NULL
12530 };
12531
12532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12534 if (SWIG_arg_fail(1)) SWIG_fail;
12535 {
12536 PyThreadState* __tstate = wxPyBeginAllowThreads();
12537 result = (int)(arg1)->GetPollingMax();
12538
12539 wxPyEndAllowThreads(__tstate);
12540 if (PyErr_Occurred()) SWIG_fail;
12541 }
12542 {
12543 resultobj = SWIG_From_int((int)(result));
12544 }
12545 return resultobj;
12546 fail:
12547 return NULL;
12548 }
12549
12550
12551 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12552 PyObject *resultobj;
12553 wxJoystick *arg1 = (wxJoystick *) 0 ;
12554 int result;
12555 PyObject * obj0 = 0 ;
12556 char *kwnames[] = {
12557 (char *) "self", NULL
12558 };
12559
12560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12562 if (SWIG_arg_fail(1)) SWIG_fail;
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 result = (int)(arg1)->GetRudderMin();
12566
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 {
12571 resultobj = SWIG_From_int((int)(result));
12572 }
12573 return resultobj;
12574 fail:
12575 return NULL;
12576 }
12577
12578
12579 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12580 PyObject *resultobj;
12581 wxJoystick *arg1 = (wxJoystick *) 0 ;
12582 int result;
12583 PyObject * obj0 = 0 ;
12584 char *kwnames[] = {
12585 (char *) "self", NULL
12586 };
12587
12588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12590 if (SWIG_arg_fail(1)) SWIG_fail;
12591 {
12592 PyThreadState* __tstate = wxPyBeginAllowThreads();
12593 result = (int)(arg1)->GetRudderMax();
12594
12595 wxPyEndAllowThreads(__tstate);
12596 if (PyErr_Occurred()) SWIG_fail;
12597 }
12598 {
12599 resultobj = SWIG_From_int((int)(result));
12600 }
12601 return resultobj;
12602 fail:
12603 return NULL;
12604 }
12605
12606
12607 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12608 PyObject *resultobj;
12609 wxJoystick *arg1 = (wxJoystick *) 0 ;
12610 int result;
12611 PyObject * obj0 = 0 ;
12612 char *kwnames[] = {
12613 (char *) "self", NULL
12614 };
12615
12616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12618 if (SWIG_arg_fail(1)) SWIG_fail;
12619 {
12620 PyThreadState* __tstate = wxPyBeginAllowThreads();
12621 result = (int)(arg1)->GetUMin();
12622
12623 wxPyEndAllowThreads(__tstate);
12624 if (PyErr_Occurred()) SWIG_fail;
12625 }
12626 {
12627 resultobj = SWIG_From_int((int)(result));
12628 }
12629 return resultobj;
12630 fail:
12631 return NULL;
12632 }
12633
12634
12635 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12636 PyObject *resultobj;
12637 wxJoystick *arg1 = (wxJoystick *) 0 ;
12638 int result;
12639 PyObject * obj0 = 0 ;
12640 char *kwnames[] = {
12641 (char *) "self", NULL
12642 };
12643
12644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12646 if (SWIG_arg_fail(1)) SWIG_fail;
12647 {
12648 PyThreadState* __tstate = wxPyBeginAllowThreads();
12649 result = (int)(arg1)->GetUMax();
12650
12651 wxPyEndAllowThreads(__tstate);
12652 if (PyErr_Occurred()) SWIG_fail;
12653 }
12654 {
12655 resultobj = SWIG_From_int((int)(result));
12656 }
12657 return resultobj;
12658 fail:
12659 return NULL;
12660 }
12661
12662
12663 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12664 PyObject *resultobj;
12665 wxJoystick *arg1 = (wxJoystick *) 0 ;
12666 int result;
12667 PyObject * obj0 = 0 ;
12668 char *kwnames[] = {
12669 (char *) "self", NULL
12670 };
12671
12672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12674 if (SWIG_arg_fail(1)) SWIG_fail;
12675 {
12676 PyThreadState* __tstate = wxPyBeginAllowThreads();
12677 result = (int)(arg1)->GetVMin();
12678
12679 wxPyEndAllowThreads(__tstate);
12680 if (PyErr_Occurred()) SWIG_fail;
12681 }
12682 {
12683 resultobj = SWIG_From_int((int)(result));
12684 }
12685 return resultobj;
12686 fail:
12687 return NULL;
12688 }
12689
12690
12691 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12692 PyObject *resultobj;
12693 wxJoystick *arg1 = (wxJoystick *) 0 ;
12694 int result;
12695 PyObject * obj0 = 0 ;
12696 char *kwnames[] = {
12697 (char *) "self", NULL
12698 };
12699
12700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12702 if (SWIG_arg_fail(1)) SWIG_fail;
12703 {
12704 PyThreadState* __tstate = wxPyBeginAllowThreads();
12705 result = (int)(arg1)->GetVMax();
12706
12707 wxPyEndAllowThreads(__tstate);
12708 if (PyErr_Occurred()) SWIG_fail;
12709 }
12710 {
12711 resultobj = SWIG_From_int((int)(result));
12712 }
12713 return resultobj;
12714 fail:
12715 return NULL;
12716 }
12717
12718
12719 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12720 PyObject *resultobj;
12721 wxJoystick *arg1 = (wxJoystick *) 0 ;
12722 bool result;
12723 PyObject * obj0 = 0 ;
12724 char *kwnames[] = {
12725 (char *) "self", NULL
12726 };
12727
12728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12730 if (SWIG_arg_fail(1)) SWIG_fail;
12731 {
12732 PyThreadState* __tstate = wxPyBeginAllowThreads();
12733 result = (bool)(arg1)->HasRudder();
12734
12735 wxPyEndAllowThreads(__tstate);
12736 if (PyErr_Occurred()) SWIG_fail;
12737 }
12738 {
12739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12740 }
12741 return resultobj;
12742 fail:
12743 return NULL;
12744 }
12745
12746
12747 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12748 PyObject *resultobj;
12749 wxJoystick *arg1 = (wxJoystick *) 0 ;
12750 bool result;
12751 PyObject * obj0 = 0 ;
12752 char *kwnames[] = {
12753 (char *) "self", NULL
12754 };
12755
12756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12758 if (SWIG_arg_fail(1)) SWIG_fail;
12759 {
12760 PyThreadState* __tstate = wxPyBeginAllowThreads();
12761 result = (bool)(arg1)->HasZ();
12762
12763 wxPyEndAllowThreads(__tstate);
12764 if (PyErr_Occurred()) SWIG_fail;
12765 }
12766 {
12767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12768 }
12769 return resultobj;
12770 fail:
12771 return NULL;
12772 }
12773
12774
12775 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12776 PyObject *resultobj;
12777 wxJoystick *arg1 = (wxJoystick *) 0 ;
12778 bool result;
12779 PyObject * obj0 = 0 ;
12780 char *kwnames[] = {
12781 (char *) "self", NULL
12782 };
12783
12784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12786 if (SWIG_arg_fail(1)) SWIG_fail;
12787 {
12788 PyThreadState* __tstate = wxPyBeginAllowThreads();
12789 result = (bool)(arg1)->HasU();
12790
12791 wxPyEndAllowThreads(__tstate);
12792 if (PyErr_Occurred()) SWIG_fail;
12793 }
12794 {
12795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12796 }
12797 return resultobj;
12798 fail:
12799 return NULL;
12800 }
12801
12802
12803 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12804 PyObject *resultobj;
12805 wxJoystick *arg1 = (wxJoystick *) 0 ;
12806 bool result;
12807 PyObject * obj0 = 0 ;
12808 char *kwnames[] = {
12809 (char *) "self", NULL
12810 };
12811
12812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12814 if (SWIG_arg_fail(1)) SWIG_fail;
12815 {
12816 PyThreadState* __tstate = wxPyBeginAllowThreads();
12817 result = (bool)(arg1)->HasV();
12818
12819 wxPyEndAllowThreads(__tstate);
12820 if (PyErr_Occurred()) SWIG_fail;
12821 }
12822 {
12823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12824 }
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12832 PyObject *resultobj;
12833 wxJoystick *arg1 = (wxJoystick *) 0 ;
12834 bool result;
12835 PyObject * obj0 = 0 ;
12836 char *kwnames[] = {
12837 (char *) "self", NULL
12838 };
12839
12840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12842 if (SWIG_arg_fail(1)) SWIG_fail;
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = (bool)(arg1)->HasPOV();
12846
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 {
12851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12852 }
12853 return resultobj;
12854 fail:
12855 return NULL;
12856 }
12857
12858
12859 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12860 PyObject *resultobj;
12861 wxJoystick *arg1 = (wxJoystick *) 0 ;
12862 bool result;
12863 PyObject * obj0 = 0 ;
12864 char *kwnames[] = {
12865 (char *) "self", NULL
12866 };
12867
12868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12870 if (SWIG_arg_fail(1)) SWIG_fail;
12871 {
12872 PyThreadState* __tstate = wxPyBeginAllowThreads();
12873 result = (bool)(arg1)->HasPOV4Dir();
12874
12875 wxPyEndAllowThreads(__tstate);
12876 if (PyErr_Occurred()) SWIG_fail;
12877 }
12878 {
12879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12880 }
12881 return resultobj;
12882 fail:
12883 return NULL;
12884 }
12885
12886
12887 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12888 PyObject *resultobj;
12889 wxJoystick *arg1 = (wxJoystick *) 0 ;
12890 bool result;
12891 PyObject * obj0 = 0 ;
12892 char *kwnames[] = {
12893 (char *) "self", NULL
12894 };
12895
12896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12898 if (SWIG_arg_fail(1)) SWIG_fail;
12899 {
12900 PyThreadState* __tstate = wxPyBeginAllowThreads();
12901 result = (bool)(arg1)->HasPOVCTS();
12902
12903 wxPyEndAllowThreads(__tstate);
12904 if (PyErr_Occurred()) SWIG_fail;
12905 }
12906 {
12907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12908 }
12909 return resultobj;
12910 fail:
12911 return NULL;
12912 }
12913
12914
12915 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12916 PyObject *resultobj;
12917 wxJoystick *arg1 = (wxJoystick *) 0 ;
12918 wxWindow *arg2 = (wxWindow *) 0 ;
12919 int arg3 = (int) 0 ;
12920 bool result;
12921 PyObject * obj0 = 0 ;
12922 PyObject * obj1 = 0 ;
12923 PyObject * obj2 = 0 ;
12924 char *kwnames[] = {
12925 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12926 };
12927
12928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12930 if (SWIG_arg_fail(1)) SWIG_fail;
12931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12932 if (SWIG_arg_fail(2)) SWIG_fail;
12933 if (obj2) {
12934 {
12935 arg3 = (int)(SWIG_As_int(obj2));
12936 if (SWIG_arg_fail(3)) SWIG_fail;
12937 }
12938 }
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (bool)(arg1)->SetCapture(arg2,arg3);
12942
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 {
12947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12948 }
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12956 PyObject *resultobj;
12957 wxJoystick *arg1 = (wxJoystick *) 0 ;
12958 bool result;
12959 PyObject * obj0 = 0 ;
12960 char *kwnames[] = {
12961 (char *) "self", NULL
12962 };
12963
12964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12966 if (SWIG_arg_fail(1)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (bool)(arg1)->ReleaseCapture();
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 {
12975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12976 }
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12984 PyObject *obj;
12985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12986 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12987 Py_INCREF(obj);
12988 return Py_BuildValue((char *)"");
12989 }
12990 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12991 PyObject *resultobj;
12992 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12993 int arg2 = (int) 0 ;
12994 int arg3 = (int) wxJOYSTICK1 ;
12995 int arg4 = (int) 0 ;
12996 wxJoystickEvent *result;
12997 PyObject * obj0 = 0 ;
12998 PyObject * obj1 = 0 ;
12999 PyObject * obj2 = 0 ;
13000 PyObject * obj3 = 0 ;
13001 char *kwnames[] = {
13002 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
13003 };
13004
13005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13006 if (obj0) {
13007 {
13008 arg1 = (wxEventType)(SWIG_As_int(obj0));
13009 if (SWIG_arg_fail(1)) SWIG_fail;
13010 }
13011 }
13012 if (obj1) {
13013 {
13014 arg2 = (int)(SWIG_As_int(obj1));
13015 if (SWIG_arg_fail(2)) SWIG_fail;
13016 }
13017 }
13018 if (obj2) {
13019 {
13020 arg3 = (int)(SWIG_As_int(obj2));
13021 if (SWIG_arg_fail(3)) SWIG_fail;
13022 }
13023 }
13024 if (obj3) {
13025 {
13026 arg4 = (int)(SWIG_As_int(obj3));
13027 if (SWIG_arg_fail(4)) SWIG_fail;
13028 }
13029 }
13030 {
13031 PyThreadState* __tstate = wxPyBeginAllowThreads();
13032 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
13033
13034 wxPyEndAllowThreads(__tstate);
13035 if (PyErr_Occurred()) SWIG_fail;
13036 }
13037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
13038 return resultobj;
13039 fail:
13040 return NULL;
13041 }
13042
13043
13044 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13045 PyObject *resultobj;
13046 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13047 wxPoint result;
13048 PyObject * obj0 = 0 ;
13049 char *kwnames[] = {
13050 (char *) "self", NULL
13051 };
13052
13053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
13054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13055 if (SWIG_arg_fail(1)) SWIG_fail;
13056 {
13057 PyThreadState* __tstate = wxPyBeginAllowThreads();
13058 result = ((wxJoystickEvent const *)arg1)->GetPosition();
13059
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 {
13064 wxPoint * resultptr;
13065 resultptr = new wxPoint((wxPoint &)(result));
13066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
13067 }
13068 return resultobj;
13069 fail:
13070 return NULL;
13071 }
13072
13073
13074 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13075 PyObject *resultobj;
13076 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13077 int result;
13078 PyObject * obj0 = 0 ;
13079 char *kwnames[] = {
13080 (char *) "self", NULL
13081 };
13082
13083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13085 if (SWIG_arg_fail(1)) SWIG_fail;
13086 {
13087 PyThreadState* __tstate = wxPyBeginAllowThreads();
13088 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13089
13090 wxPyEndAllowThreads(__tstate);
13091 if (PyErr_Occurred()) SWIG_fail;
13092 }
13093 {
13094 resultobj = SWIG_From_int((int)(result));
13095 }
13096 return resultobj;
13097 fail:
13098 return NULL;
13099 }
13100
13101
13102 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13103 PyObject *resultobj;
13104 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13105 int result;
13106 PyObject * obj0 = 0 ;
13107 char *kwnames[] = {
13108 (char *) "self", NULL
13109 };
13110
13111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13113 if (SWIG_arg_fail(1)) SWIG_fail;
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13117
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 {
13122 resultobj = SWIG_From_int((int)(result));
13123 }
13124 return resultobj;
13125 fail:
13126 return NULL;
13127 }
13128
13129
13130 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13131 PyObject *resultobj;
13132 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13133 int result;
13134 PyObject * obj0 = 0 ;
13135 char *kwnames[] = {
13136 (char *) "self", NULL
13137 };
13138
13139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13141 if (SWIG_arg_fail(1)) SWIG_fail;
13142 {
13143 PyThreadState* __tstate = wxPyBeginAllowThreads();
13144 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13145
13146 wxPyEndAllowThreads(__tstate);
13147 if (PyErr_Occurred()) SWIG_fail;
13148 }
13149 {
13150 resultobj = SWIG_From_int((int)(result));
13151 }
13152 return resultobj;
13153 fail:
13154 return NULL;
13155 }
13156
13157
13158 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13159 PyObject *resultobj;
13160 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13161 int result;
13162 PyObject * obj0 = 0 ;
13163 char *kwnames[] = {
13164 (char *) "self", NULL
13165 };
13166
13167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13169 if (SWIG_arg_fail(1)) SWIG_fail;
13170 {
13171 PyThreadState* __tstate = wxPyBeginAllowThreads();
13172 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13173
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 {
13178 resultobj = SWIG_From_int((int)(result));
13179 }
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13187 PyObject *resultobj;
13188 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13189 int arg2 ;
13190 PyObject * obj0 = 0 ;
13191 PyObject * obj1 = 0 ;
13192 char *kwnames[] = {
13193 (char *) "self",(char *) "stick", NULL
13194 };
13195
13196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13198 if (SWIG_arg_fail(1)) SWIG_fail;
13199 {
13200 arg2 = (int)(SWIG_As_int(obj1));
13201 if (SWIG_arg_fail(2)) SWIG_fail;
13202 }
13203 {
13204 PyThreadState* __tstate = wxPyBeginAllowThreads();
13205 (arg1)->SetJoystick(arg2);
13206
13207 wxPyEndAllowThreads(__tstate);
13208 if (PyErr_Occurred()) SWIG_fail;
13209 }
13210 Py_INCREF(Py_None); resultobj = Py_None;
13211 return resultobj;
13212 fail:
13213 return NULL;
13214 }
13215
13216
13217 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13218 PyObject *resultobj;
13219 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13220 int arg2 ;
13221 PyObject * obj0 = 0 ;
13222 PyObject * obj1 = 0 ;
13223 char *kwnames[] = {
13224 (char *) "self",(char *) "state", NULL
13225 };
13226
13227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13229 if (SWIG_arg_fail(1)) SWIG_fail;
13230 {
13231 arg2 = (int)(SWIG_As_int(obj1));
13232 if (SWIG_arg_fail(2)) SWIG_fail;
13233 }
13234 {
13235 PyThreadState* __tstate = wxPyBeginAllowThreads();
13236 (arg1)->SetButtonState(arg2);
13237
13238 wxPyEndAllowThreads(__tstate);
13239 if (PyErr_Occurred()) SWIG_fail;
13240 }
13241 Py_INCREF(Py_None); resultobj = Py_None;
13242 return resultobj;
13243 fail:
13244 return NULL;
13245 }
13246
13247
13248 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13249 PyObject *resultobj;
13250 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13251 int arg2 ;
13252 PyObject * obj0 = 0 ;
13253 PyObject * obj1 = 0 ;
13254 char *kwnames[] = {
13255 (char *) "self",(char *) "change", NULL
13256 };
13257
13258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13260 if (SWIG_arg_fail(1)) SWIG_fail;
13261 {
13262 arg2 = (int)(SWIG_As_int(obj1));
13263 if (SWIG_arg_fail(2)) SWIG_fail;
13264 }
13265 {
13266 PyThreadState* __tstate = wxPyBeginAllowThreads();
13267 (arg1)->SetButtonChange(arg2);
13268
13269 wxPyEndAllowThreads(__tstate);
13270 if (PyErr_Occurred()) SWIG_fail;
13271 }
13272 Py_INCREF(Py_None); resultobj = Py_None;
13273 return resultobj;
13274 fail:
13275 return NULL;
13276 }
13277
13278
13279 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13280 PyObject *resultobj;
13281 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13282 wxPoint *arg2 = 0 ;
13283 wxPoint temp2 ;
13284 PyObject * obj0 = 0 ;
13285 PyObject * obj1 = 0 ;
13286 char *kwnames[] = {
13287 (char *) "self",(char *) "pos", NULL
13288 };
13289
13290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13292 if (SWIG_arg_fail(1)) SWIG_fail;
13293 {
13294 arg2 = &temp2;
13295 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13296 }
13297 {
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 (arg1)->SetPosition((wxPoint const &)*arg2);
13300
13301 wxPyEndAllowThreads(__tstate);
13302 if (PyErr_Occurred()) SWIG_fail;
13303 }
13304 Py_INCREF(Py_None); resultobj = Py_None;
13305 return resultobj;
13306 fail:
13307 return NULL;
13308 }
13309
13310
13311 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13312 PyObject *resultobj;
13313 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13314 int arg2 ;
13315 PyObject * obj0 = 0 ;
13316 PyObject * obj1 = 0 ;
13317 char *kwnames[] = {
13318 (char *) "self",(char *) "zPos", NULL
13319 };
13320
13321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13323 if (SWIG_arg_fail(1)) SWIG_fail;
13324 {
13325 arg2 = (int)(SWIG_As_int(obj1));
13326 if (SWIG_arg_fail(2)) SWIG_fail;
13327 }
13328 {
13329 PyThreadState* __tstate = wxPyBeginAllowThreads();
13330 (arg1)->SetZPosition(arg2);
13331
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 Py_INCREF(Py_None); resultobj = Py_None;
13336 return resultobj;
13337 fail:
13338 return NULL;
13339 }
13340
13341
13342 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13343 PyObject *resultobj;
13344 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13345 bool result;
13346 PyObject * obj0 = 0 ;
13347 char *kwnames[] = {
13348 (char *) "self", NULL
13349 };
13350
13351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13353 if (SWIG_arg_fail(1)) SWIG_fail;
13354 {
13355 PyThreadState* __tstate = wxPyBeginAllowThreads();
13356 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13357
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 {
13362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13363 }
13364 return resultobj;
13365 fail:
13366 return NULL;
13367 }
13368
13369
13370 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13371 PyObject *resultobj;
13372 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13373 bool result;
13374 PyObject * obj0 = 0 ;
13375 char *kwnames[] = {
13376 (char *) "self", NULL
13377 };
13378
13379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13381 if (SWIG_arg_fail(1)) SWIG_fail;
13382 {
13383 PyThreadState* __tstate = wxPyBeginAllowThreads();
13384 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13385
13386 wxPyEndAllowThreads(__tstate);
13387 if (PyErr_Occurred()) SWIG_fail;
13388 }
13389 {
13390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13391 }
13392 return resultobj;
13393 fail:
13394 return NULL;
13395 }
13396
13397
13398 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13399 PyObject *resultobj;
13400 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13401 bool result;
13402 PyObject * obj0 = 0 ;
13403 char *kwnames[] = {
13404 (char *) "self", NULL
13405 };
13406
13407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13409 if (SWIG_arg_fail(1)) SWIG_fail;
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13413
13414 wxPyEndAllowThreads(__tstate);
13415 if (PyErr_Occurred()) SWIG_fail;
13416 }
13417 {
13418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13419 }
13420 return resultobj;
13421 fail:
13422 return NULL;
13423 }
13424
13425
13426 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13427 PyObject *resultobj;
13428 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13429 int arg2 = (int) wxJOY_BUTTON_ANY ;
13430 bool result;
13431 PyObject * obj0 = 0 ;
13432 PyObject * obj1 = 0 ;
13433 char *kwnames[] = {
13434 (char *) "self",(char *) "but", NULL
13435 };
13436
13437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13439 if (SWIG_arg_fail(1)) SWIG_fail;
13440 if (obj1) {
13441 {
13442 arg2 = (int)(SWIG_As_int(obj1));
13443 if (SWIG_arg_fail(2)) SWIG_fail;
13444 }
13445 }
13446 {
13447 PyThreadState* __tstate = wxPyBeginAllowThreads();
13448 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13449
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 {
13454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13455 }
13456 return resultobj;
13457 fail:
13458 return NULL;
13459 }
13460
13461
13462 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13463 PyObject *resultobj;
13464 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13465 int arg2 = (int) wxJOY_BUTTON_ANY ;
13466 bool result;
13467 PyObject * obj0 = 0 ;
13468 PyObject * obj1 = 0 ;
13469 char *kwnames[] = {
13470 (char *) "self",(char *) "but", NULL
13471 };
13472
13473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13475 if (SWIG_arg_fail(1)) SWIG_fail;
13476 if (obj1) {
13477 {
13478 arg2 = (int)(SWIG_As_int(obj1));
13479 if (SWIG_arg_fail(2)) SWIG_fail;
13480 }
13481 }
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13485
13486 wxPyEndAllowThreads(__tstate);
13487 if (PyErr_Occurred()) SWIG_fail;
13488 }
13489 {
13490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13491 }
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13499 PyObject *resultobj;
13500 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13501 int arg2 = (int) wxJOY_BUTTON_ANY ;
13502 bool result;
13503 PyObject * obj0 = 0 ;
13504 PyObject * obj1 = 0 ;
13505 char *kwnames[] = {
13506 (char *) "self",(char *) "but", NULL
13507 };
13508
13509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13511 if (SWIG_arg_fail(1)) SWIG_fail;
13512 if (obj1) {
13513 {
13514 arg2 = (int)(SWIG_As_int(obj1));
13515 if (SWIG_arg_fail(2)) SWIG_fail;
13516 }
13517 }
13518 {
13519 PyThreadState* __tstate = wxPyBeginAllowThreads();
13520 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13521
13522 wxPyEndAllowThreads(__tstate);
13523 if (PyErr_Occurred()) SWIG_fail;
13524 }
13525 {
13526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13527 }
13528 return resultobj;
13529 fail:
13530 return NULL;
13531 }
13532
13533
13534 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13535 PyObject *obj;
13536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13537 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13538 Py_INCREF(obj);
13539 return Py_BuildValue((char *)"");
13540 }
13541 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj;
13543 wxString const &arg1_defvalue = wxPyEmptyString ;
13544 wxString *arg1 = (wxString *) &arg1_defvalue ;
13545 wxSound *result;
13546 bool temp1 = false ;
13547 PyObject * obj0 = 0 ;
13548 char *kwnames[] = {
13549 (char *) "fileName", NULL
13550 };
13551
13552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13553 if (obj0) {
13554 {
13555 arg1 = wxString_in_helper(obj0);
13556 if (arg1 == NULL) SWIG_fail;
13557 temp1 = true;
13558 }
13559 }
13560 {
13561 if (!wxPyCheckForApp()) SWIG_fail;
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13564
13565 wxPyEndAllowThreads(__tstate);
13566 if (PyErr_Occurred()) SWIG_fail;
13567 }
13568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13569 {
13570 if (temp1)
13571 delete arg1;
13572 }
13573 return resultobj;
13574 fail:
13575 {
13576 if (temp1)
13577 delete arg1;
13578 }
13579 return NULL;
13580 }
13581
13582
13583 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13584 PyObject *resultobj;
13585 PyObject *arg1 = (PyObject *) 0 ;
13586 wxSound *result;
13587 PyObject * obj0 = 0 ;
13588 char *kwnames[] = {
13589 (char *) "data", NULL
13590 };
13591
13592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13593 arg1 = obj0;
13594 {
13595 if (!wxPyCheckForApp()) SWIG_fail;
13596 PyThreadState* __tstate = wxPyBeginAllowThreads();
13597 result = (wxSound *)new_wxSound(arg1);
13598
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13603 return resultobj;
13604 fail:
13605 return NULL;
13606 }
13607
13608
13609 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13610 PyObject *resultobj;
13611 wxSound *arg1 = (wxSound *) 0 ;
13612 PyObject * obj0 = 0 ;
13613 char *kwnames[] = {
13614 (char *) "self", NULL
13615 };
13616
13617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13619 if (SWIG_arg_fail(1)) SWIG_fail;
13620 {
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 delete arg1;
13623
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 Py_INCREF(Py_None); resultobj = Py_None;
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj;
13636 wxSound *arg1 = (wxSound *) 0 ;
13637 wxString *arg2 = 0 ;
13638 bool result;
13639 bool temp2 = false ;
13640 PyObject * obj0 = 0 ;
13641 PyObject * obj1 = 0 ;
13642 char *kwnames[] = {
13643 (char *) "self",(char *) "fileName", NULL
13644 };
13645
13646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13648 if (SWIG_arg_fail(1)) SWIG_fail;
13649 {
13650 arg2 = wxString_in_helper(obj1);
13651 if (arg2 == NULL) SWIG_fail;
13652 temp2 = true;
13653 }
13654 {
13655 PyThreadState* __tstate = wxPyBeginAllowThreads();
13656 result = (bool)(arg1)->Create((wxString const &)*arg2);
13657
13658 wxPyEndAllowThreads(__tstate);
13659 if (PyErr_Occurred()) SWIG_fail;
13660 }
13661 {
13662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13663 }
13664 {
13665 if (temp2)
13666 delete arg2;
13667 }
13668 return resultobj;
13669 fail:
13670 {
13671 if (temp2)
13672 delete arg2;
13673 }
13674 return NULL;
13675 }
13676
13677
13678 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13679 PyObject *resultobj;
13680 wxSound *arg1 = (wxSound *) 0 ;
13681 PyObject *arg2 = (PyObject *) 0 ;
13682 bool result;
13683 PyObject * obj0 = 0 ;
13684 PyObject * obj1 = 0 ;
13685 char *kwnames[] = {
13686 (char *) "self",(char *) "data", NULL
13687 };
13688
13689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13691 if (SWIG_arg_fail(1)) SWIG_fail;
13692 arg2 = obj1;
13693 {
13694 PyThreadState* __tstate = wxPyBeginAllowThreads();
13695 result = (bool)wxSound_CreateFromData(arg1,arg2);
13696
13697 wxPyEndAllowThreads(__tstate);
13698 if (PyErr_Occurred()) SWIG_fail;
13699 }
13700 {
13701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13702 }
13703 return resultobj;
13704 fail:
13705 return NULL;
13706 }
13707
13708
13709 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13710 PyObject *resultobj;
13711 wxSound *arg1 = (wxSound *) 0 ;
13712 bool result;
13713 PyObject * obj0 = 0 ;
13714 char *kwnames[] = {
13715 (char *) "self", NULL
13716 };
13717
13718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13720 if (SWIG_arg_fail(1)) SWIG_fail;
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 result = (bool)(arg1)->IsOk();
13724
13725 wxPyEndAllowThreads(__tstate);
13726 if (PyErr_Occurred()) SWIG_fail;
13727 }
13728 {
13729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13730 }
13731 return resultobj;
13732 fail:
13733 return NULL;
13734 }
13735
13736
13737 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13738 PyObject *resultobj;
13739 wxSound *arg1 = (wxSound *) 0 ;
13740 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13741 bool result;
13742 PyObject * obj0 = 0 ;
13743 PyObject * obj1 = 0 ;
13744 char *kwnames[] = {
13745 (char *) "self",(char *) "flags", NULL
13746 };
13747
13748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13750 if (SWIG_arg_fail(1)) SWIG_fail;
13751 if (obj1) {
13752 {
13753 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13754 if (SWIG_arg_fail(2)) SWIG_fail;
13755 }
13756 }
13757 {
13758 if (!wxPyCheckForApp()) SWIG_fail;
13759 PyThreadState* __tstate = wxPyBeginAllowThreads();
13760 result = (bool)((wxSound const *)arg1)->Play(arg2);
13761
13762 wxPyEndAllowThreads(__tstate);
13763 if (PyErr_Occurred()) SWIG_fail;
13764 }
13765 {
13766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13767 }
13768 return resultobj;
13769 fail:
13770 return NULL;
13771 }
13772
13773
13774 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13775 PyObject *resultobj;
13776 wxString *arg1 = 0 ;
13777 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13778 bool result;
13779 bool temp1 = false ;
13780 PyObject * obj0 = 0 ;
13781 PyObject * obj1 = 0 ;
13782 char *kwnames[] = {
13783 (char *) "filename",(char *) "flags", NULL
13784 };
13785
13786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13787 {
13788 arg1 = wxString_in_helper(obj0);
13789 if (arg1 == NULL) SWIG_fail;
13790 temp1 = true;
13791 }
13792 if (obj1) {
13793 {
13794 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13795 if (SWIG_arg_fail(2)) SWIG_fail;
13796 }
13797 }
13798 {
13799 if (!wxPyCheckForApp()) SWIG_fail;
13800 PyThreadState* __tstate = wxPyBeginAllowThreads();
13801 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13802
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 {
13807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13808 }
13809 {
13810 if (temp1)
13811 delete arg1;
13812 }
13813 return resultobj;
13814 fail:
13815 {
13816 if (temp1)
13817 delete arg1;
13818 }
13819 return NULL;
13820 }
13821
13822
13823 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13824 PyObject *resultobj;
13825 char *kwnames[] = {
13826 NULL
13827 };
13828
13829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13830 {
13831 if (!wxPyCheckForApp()) SWIG_fail;
13832 PyThreadState* __tstate = wxPyBeginAllowThreads();
13833 wxSound::Stop();
13834
13835 wxPyEndAllowThreads(__tstate);
13836 if (PyErr_Occurred()) SWIG_fail;
13837 }
13838 Py_INCREF(Py_None); resultobj = Py_None;
13839 return resultobj;
13840 fail:
13841 return NULL;
13842 }
13843
13844
13845 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13846 PyObject *obj;
13847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13848 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13849 Py_INCREF(obj);
13850 return Py_BuildValue((char *)"");
13851 }
13852 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13853 PyObject *resultobj;
13854 wxString *arg1 = 0 ;
13855 wxString *arg2 = 0 ;
13856 wxString *arg3 = 0 ;
13857 wxString *arg4 = 0 ;
13858 wxFileTypeInfo *result;
13859 bool temp1 = false ;
13860 bool temp2 = false ;
13861 bool temp3 = false ;
13862 bool temp4 = false ;
13863 PyObject * obj0 = 0 ;
13864 PyObject * obj1 = 0 ;
13865 PyObject * obj2 = 0 ;
13866 PyObject * obj3 = 0 ;
13867 char *kwnames[] = {
13868 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13869 };
13870
13871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13872 {
13873 arg1 = wxString_in_helper(obj0);
13874 if (arg1 == NULL) SWIG_fail;
13875 temp1 = true;
13876 }
13877 {
13878 arg2 = wxString_in_helper(obj1);
13879 if (arg2 == NULL) SWIG_fail;
13880 temp2 = true;
13881 }
13882 {
13883 arg3 = wxString_in_helper(obj2);
13884 if (arg3 == NULL) SWIG_fail;
13885 temp3 = true;
13886 }
13887 {
13888 arg4 = wxString_in_helper(obj3);
13889 if (arg4 == NULL) SWIG_fail;
13890 temp4 = true;
13891 }
13892 {
13893 PyThreadState* __tstate = wxPyBeginAllowThreads();
13894 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13895
13896 wxPyEndAllowThreads(__tstate);
13897 if (PyErr_Occurred()) SWIG_fail;
13898 }
13899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13900 {
13901 if (temp1)
13902 delete arg1;
13903 }
13904 {
13905 if (temp2)
13906 delete arg2;
13907 }
13908 {
13909 if (temp3)
13910 delete arg3;
13911 }
13912 {
13913 if (temp4)
13914 delete arg4;
13915 }
13916 return resultobj;
13917 fail:
13918 {
13919 if (temp1)
13920 delete arg1;
13921 }
13922 {
13923 if (temp2)
13924 delete arg2;
13925 }
13926 {
13927 if (temp3)
13928 delete arg3;
13929 }
13930 {
13931 if (temp4)
13932 delete arg4;
13933 }
13934 return NULL;
13935 }
13936
13937
13938 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13939 PyObject *resultobj;
13940 wxArrayString *arg1 = 0 ;
13941 wxFileTypeInfo *result;
13942 bool temp1 = false ;
13943 PyObject * obj0 = 0 ;
13944 char *kwnames[] = {
13945 (char *) "sArray", NULL
13946 };
13947
13948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13949 {
13950 if (! PySequence_Check(obj0)) {
13951 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13952 SWIG_fail;
13953 }
13954 arg1 = new wxArrayString;
13955 temp1 = true;
13956 int i, len=PySequence_Length(obj0);
13957 for (i=0; i<len; i++) {
13958 PyObject* item = PySequence_GetItem(obj0, i);
13959 wxString* s = wxString_in_helper(item);
13960 if (PyErr_Occurred()) SWIG_fail;
13961 arg1->Add(*s);
13962 delete s;
13963 Py_DECREF(item);
13964 }
13965 }
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13969
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13974 {
13975 if (temp1) delete arg1;
13976 }
13977 return resultobj;
13978 fail:
13979 {
13980 if (temp1) delete arg1;
13981 }
13982 return NULL;
13983 }
13984
13985
13986 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13987 PyObject *resultobj;
13988 wxFileTypeInfo *result;
13989 char *kwnames[] = {
13990 NULL
13991 };
13992
13993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13994 {
13995 PyThreadState* __tstate = wxPyBeginAllowThreads();
13996 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13997
13998 wxPyEndAllowThreads(__tstate);
13999 if (PyErr_Occurred()) SWIG_fail;
14000 }
14001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
14009 PyObject *resultobj;
14010 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14011 bool result;
14012 PyObject * obj0 = 0 ;
14013 char *kwnames[] = {
14014 (char *) "self", NULL
14015 };
14016
14017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
14018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14019 if (SWIG_arg_fail(1)) SWIG_fail;
14020 {
14021 PyThreadState* __tstate = wxPyBeginAllowThreads();
14022 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
14023
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 {
14028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14029 }
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14037 PyObject *resultobj;
14038 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14039 wxString *arg2 = 0 ;
14040 int arg3 = (int) 0 ;
14041 bool temp2 = false ;
14042 PyObject * obj0 = 0 ;
14043 PyObject * obj1 = 0 ;
14044 PyObject * obj2 = 0 ;
14045 char *kwnames[] = {
14046 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
14047 };
14048
14049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14051 if (SWIG_arg_fail(1)) SWIG_fail;
14052 {
14053 arg2 = wxString_in_helper(obj1);
14054 if (arg2 == NULL) SWIG_fail;
14055 temp2 = true;
14056 }
14057 if (obj2) {
14058 {
14059 arg3 = (int)(SWIG_As_int(obj2));
14060 if (SWIG_arg_fail(3)) SWIG_fail;
14061 }
14062 }
14063 {
14064 PyThreadState* __tstate = wxPyBeginAllowThreads();
14065 (arg1)->SetIcon((wxString const &)*arg2,arg3);
14066
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 Py_INCREF(Py_None); resultobj = Py_None;
14071 {
14072 if (temp2)
14073 delete arg2;
14074 }
14075 return resultobj;
14076 fail:
14077 {
14078 if (temp2)
14079 delete arg2;
14080 }
14081 return NULL;
14082 }
14083
14084
14085 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14086 PyObject *resultobj;
14087 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14088 wxString *arg2 = 0 ;
14089 bool temp2 = false ;
14090 PyObject * obj0 = 0 ;
14091 PyObject * obj1 = 0 ;
14092 char *kwnames[] = {
14093 (char *) "self",(char *) "shortDesc", NULL
14094 };
14095
14096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14098 if (SWIG_arg_fail(1)) SWIG_fail;
14099 {
14100 arg2 = wxString_in_helper(obj1);
14101 if (arg2 == NULL) SWIG_fail;
14102 temp2 = true;
14103 }
14104 {
14105 PyThreadState* __tstate = wxPyBeginAllowThreads();
14106 (arg1)->SetShortDesc((wxString const &)*arg2);
14107
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 Py_INCREF(Py_None); resultobj = Py_None;
14112 {
14113 if (temp2)
14114 delete arg2;
14115 }
14116 return resultobj;
14117 fail:
14118 {
14119 if (temp2)
14120 delete arg2;
14121 }
14122 return NULL;
14123 }
14124
14125
14126 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14127 PyObject *resultobj;
14128 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14129 wxString *result;
14130 PyObject * obj0 = 0 ;
14131 char *kwnames[] = {
14132 (char *) "self", NULL
14133 };
14134
14135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14137 if (SWIG_arg_fail(1)) SWIG_fail;
14138 {
14139 PyThreadState* __tstate = wxPyBeginAllowThreads();
14140 {
14141 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14142 result = (wxString *) &_result_ref;
14143 }
14144
14145 wxPyEndAllowThreads(__tstate);
14146 if (PyErr_Occurred()) SWIG_fail;
14147 }
14148 {
14149 #if wxUSE_UNICODE
14150 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14151 #else
14152 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14153 #endif
14154 }
14155 return resultobj;
14156 fail:
14157 return NULL;
14158 }
14159
14160
14161 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14162 PyObject *resultobj;
14163 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14164 wxString *result;
14165 PyObject * obj0 = 0 ;
14166 char *kwnames[] = {
14167 (char *) "self", NULL
14168 };
14169
14170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14172 if (SWIG_arg_fail(1)) SWIG_fail;
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 {
14176 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14177 result = (wxString *) &_result_ref;
14178 }
14179
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 {
14184 #if wxUSE_UNICODE
14185 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14186 #else
14187 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14188 #endif
14189 }
14190 return resultobj;
14191 fail:
14192 return NULL;
14193 }
14194
14195
14196 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14197 PyObject *resultobj;
14198 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14199 wxString *result;
14200 PyObject * obj0 = 0 ;
14201 char *kwnames[] = {
14202 (char *) "self", NULL
14203 };
14204
14205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14207 if (SWIG_arg_fail(1)) SWIG_fail;
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 {
14211 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14212 result = (wxString *) &_result_ref;
14213 }
14214
14215 wxPyEndAllowThreads(__tstate);
14216 if (PyErr_Occurred()) SWIG_fail;
14217 }
14218 {
14219 #if wxUSE_UNICODE
14220 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14221 #else
14222 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14223 #endif
14224 }
14225 return resultobj;
14226 fail:
14227 return NULL;
14228 }
14229
14230
14231 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14232 PyObject *resultobj;
14233 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14234 wxString *result;
14235 PyObject * obj0 = 0 ;
14236 char *kwnames[] = {
14237 (char *) "self", NULL
14238 };
14239
14240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14242 if (SWIG_arg_fail(1)) SWIG_fail;
14243 {
14244 PyThreadState* __tstate = wxPyBeginAllowThreads();
14245 {
14246 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14247 result = (wxString *) &_result_ref;
14248 }
14249
14250 wxPyEndAllowThreads(__tstate);
14251 if (PyErr_Occurred()) SWIG_fail;
14252 }
14253 {
14254 #if wxUSE_UNICODE
14255 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14256 #else
14257 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14258 #endif
14259 }
14260 return resultobj;
14261 fail:
14262 return NULL;
14263 }
14264
14265
14266 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14267 PyObject *resultobj;
14268 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14269 wxString *result;
14270 PyObject * obj0 = 0 ;
14271 char *kwnames[] = {
14272 (char *) "self", NULL
14273 };
14274
14275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14277 if (SWIG_arg_fail(1)) SWIG_fail;
14278 {
14279 PyThreadState* __tstate = wxPyBeginAllowThreads();
14280 {
14281 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14282 result = (wxString *) &_result_ref;
14283 }
14284
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 {
14289 #if wxUSE_UNICODE
14290 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14291 #else
14292 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14293 #endif
14294 }
14295 return resultobj;
14296 fail:
14297 return NULL;
14298 }
14299
14300
14301 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14302 PyObject *resultobj;
14303 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14304 wxArrayString *result;
14305 PyObject * obj0 = 0 ;
14306 char *kwnames[] = {
14307 (char *) "self", NULL
14308 };
14309
14310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14312 if (SWIG_arg_fail(1)) SWIG_fail;
14313 {
14314 PyThreadState* __tstate = wxPyBeginAllowThreads();
14315 {
14316 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14317 result = (wxArrayString *) &_result_ref;
14318 }
14319
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 {
14324 resultobj = wxArrayString2PyList_helper(*result);
14325 }
14326 return resultobj;
14327 fail:
14328 return NULL;
14329 }
14330
14331
14332 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14333 PyObject *resultobj;
14334 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14335 int result;
14336 PyObject * obj0 = 0 ;
14337 char *kwnames[] = {
14338 (char *) "self", NULL
14339 };
14340
14341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14343 if (SWIG_arg_fail(1)) SWIG_fail;
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14347
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 {
14352 resultobj = SWIG_From_int((int)(result));
14353 }
14354 return resultobj;
14355 fail:
14356 return NULL;
14357 }
14358
14359
14360 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14361 PyObject *resultobj;
14362 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14363 wxString *result;
14364 PyObject * obj0 = 0 ;
14365 char *kwnames[] = {
14366 (char *) "self", NULL
14367 };
14368
14369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14371 if (SWIG_arg_fail(1)) SWIG_fail;
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 {
14375 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14376 result = (wxString *) &_result_ref;
14377 }
14378
14379 wxPyEndAllowThreads(__tstate);
14380 if (PyErr_Occurred()) SWIG_fail;
14381 }
14382 {
14383 #if wxUSE_UNICODE
14384 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14385 #else
14386 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14387 #endif
14388 }
14389 return resultobj;
14390 fail:
14391 return NULL;
14392 }
14393
14394
14395 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14396 PyObject *resultobj;
14397 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14398 int result;
14399 PyObject * obj0 = 0 ;
14400 char *kwnames[] = {
14401 (char *) "self", NULL
14402 };
14403
14404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14406 if (SWIG_arg_fail(1)) SWIG_fail;
14407 {
14408 PyThreadState* __tstate = wxPyBeginAllowThreads();
14409 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14410
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 {
14415 resultobj = SWIG_From_int((int)(result));
14416 }
14417 return resultobj;
14418 fail:
14419 return NULL;
14420 }
14421
14422
14423 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14424 PyObject *obj;
14425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14426 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14427 Py_INCREF(obj);
14428 return Py_BuildValue((char *)"");
14429 }
14430 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14431 PyObject *resultobj;
14432 wxFileTypeInfo *arg1 = 0 ;
14433 wxFileType *result;
14434 PyObject * obj0 = 0 ;
14435 char *kwnames[] = {
14436 (char *) "ftInfo", NULL
14437 };
14438
14439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14440 {
14441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14442 if (SWIG_arg_fail(1)) SWIG_fail;
14443 if (arg1 == NULL) {
14444 SWIG_null_ref("wxFileTypeInfo");
14445 }
14446 if (SWIG_arg_fail(1)) SWIG_fail;
14447 }
14448 {
14449 PyThreadState* __tstate = wxPyBeginAllowThreads();
14450 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14451
14452 wxPyEndAllowThreads(__tstate);
14453 if (PyErr_Occurred()) SWIG_fail;
14454 }
14455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14456 return resultobj;
14457 fail:
14458 return NULL;
14459 }
14460
14461
14462 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14463 PyObject *resultobj;
14464 wxFileType *arg1 = (wxFileType *) 0 ;
14465 PyObject * obj0 = 0 ;
14466 char *kwnames[] = {
14467 (char *) "self", NULL
14468 };
14469
14470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14472 if (SWIG_arg_fail(1)) SWIG_fail;
14473 {
14474 PyThreadState* __tstate = wxPyBeginAllowThreads();
14475 delete arg1;
14476
14477 wxPyEndAllowThreads(__tstate);
14478 if (PyErr_Occurred()) SWIG_fail;
14479 }
14480 Py_INCREF(Py_None); resultobj = Py_None;
14481 return resultobj;
14482 fail:
14483 return NULL;
14484 }
14485
14486
14487 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14488 PyObject *resultobj;
14489 wxFileType *arg1 = (wxFileType *) 0 ;
14490 PyObject *result;
14491 PyObject * obj0 = 0 ;
14492 char *kwnames[] = {
14493 (char *) "self", NULL
14494 };
14495
14496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14498 if (SWIG_arg_fail(1)) SWIG_fail;
14499 {
14500 PyThreadState* __tstate = wxPyBeginAllowThreads();
14501 result = (PyObject *)wxFileType_GetMimeType(arg1);
14502
14503 wxPyEndAllowThreads(__tstate);
14504 if (PyErr_Occurred()) SWIG_fail;
14505 }
14506 resultobj = result;
14507 return resultobj;
14508 fail:
14509 return NULL;
14510 }
14511
14512
14513 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14514 PyObject *resultobj;
14515 wxFileType *arg1 = (wxFileType *) 0 ;
14516 PyObject *result;
14517 PyObject * obj0 = 0 ;
14518 char *kwnames[] = {
14519 (char *) "self", NULL
14520 };
14521
14522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14524 if (SWIG_arg_fail(1)) SWIG_fail;
14525 {
14526 PyThreadState* __tstate = wxPyBeginAllowThreads();
14527 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14528
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 resultobj = result;
14533 return resultobj;
14534 fail:
14535 return NULL;
14536 }
14537
14538
14539 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14540 PyObject *resultobj;
14541 wxFileType *arg1 = (wxFileType *) 0 ;
14542 PyObject *result;
14543 PyObject * obj0 = 0 ;
14544 char *kwnames[] = {
14545 (char *) "self", NULL
14546 };
14547
14548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14550 if (SWIG_arg_fail(1)) SWIG_fail;
14551 {
14552 PyThreadState* __tstate = wxPyBeginAllowThreads();
14553 result = (PyObject *)wxFileType_GetExtensions(arg1);
14554
14555 wxPyEndAllowThreads(__tstate);
14556 if (PyErr_Occurred()) SWIG_fail;
14557 }
14558 resultobj = result;
14559 return resultobj;
14560 fail:
14561 return NULL;
14562 }
14563
14564
14565 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14566 PyObject *resultobj;
14567 wxFileType *arg1 = (wxFileType *) 0 ;
14568 wxIcon *result;
14569 PyObject * obj0 = 0 ;
14570 char *kwnames[] = {
14571 (char *) "self", NULL
14572 };
14573
14574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14576 if (SWIG_arg_fail(1)) SWIG_fail;
14577 {
14578 PyThreadState* __tstate = wxPyBeginAllowThreads();
14579 result = (wxIcon *)wxFileType_GetIcon(arg1);
14580
14581 wxPyEndAllowThreads(__tstate);
14582 if (PyErr_Occurred()) SWIG_fail;
14583 }
14584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14585 return resultobj;
14586 fail:
14587 return NULL;
14588 }
14589
14590
14591 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14592 PyObject *resultobj;
14593 wxFileType *arg1 = (wxFileType *) 0 ;
14594 PyObject *result;
14595 PyObject * obj0 = 0 ;
14596 char *kwnames[] = {
14597 (char *) "self", NULL
14598 };
14599
14600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14602 if (SWIG_arg_fail(1)) SWIG_fail;
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14606
14607 wxPyEndAllowThreads(__tstate);
14608 if (PyErr_Occurred()) SWIG_fail;
14609 }
14610 resultobj = result;
14611 return resultobj;
14612 fail:
14613 return NULL;
14614 }
14615
14616
14617 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14618 PyObject *resultobj;
14619 wxFileType *arg1 = (wxFileType *) 0 ;
14620 PyObject *result;
14621 PyObject * obj0 = 0 ;
14622 char *kwnames[] = {
14623 (char *) "self", NULL
14624 };
14625
14626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14628 if (SWIG_arg_fail(1)) SWIG_fail;
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 result = (PyObject *)wxFileType_GetDescription(arg1);
14632
14633 wxPyEndAllowThreads(__tstate);
14634 if (PyErr_Occurred()) SWIG_fail;
14635 }
14636 resultobj = result;
14637 return resultobj;
14638 fail:
14639 return NULL;
14640 }
14641
14642
14643 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14644 PyObject *resultobj;
14645 wxFileType *arg1 = (wxFileType *) 0 ;
14646 wxString *arg2 = 0 ;
14647 wxString const &arg3_defvalue = wxPyEmptyString ;
14648 wxString *arg3 = (wxString *) &arg3_defvalue ;
14649 PyObject *result;
14650 bool temp2 = false ;
14651 bool temp3 = false ;
14652 PyObject * obj0 = 0 ;
14653 PyObject * obj1 = 0 ;
14654 PyObject * obj2 = 0 ;
14655 char *kwnames[] = {
14656 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14657 };
14658
14659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14661 if (SWIG_arg_fail(1)) SWIG_fail;
14662 {
14663 arg2 = wxString_in_helper(obj1);
14664 if (arg2 == NULL) SWIG_fail;
14665 temp2 = true;
14666 }
14667 if (obj2) {
14668 {
14669 arg3 = wxString_in_helper(obj2);
14670 if (arg3 == NULL) SWIG_fail;
14671 temp3 = true;
14672 }
14673 }
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14677
14678 wxPyEndAllowThreads(__tstate);
14679 if (PyErr_Occurred()) SWIG_fail;
14680 }
14681 resultobj = result;
14682 {
14683 if (temp2)
14684 delete arg2;
14685 }
14686 {
14687 if (temp3)
14688 delete arg3;
14689 }
14690 return resultobj;
14691 fail:
14692 {
14693 if (temp2)
14694 delete arg2;
14695 }
14696 {
14697 if (temp3)
14698 delete arg3;
14699 }
14700 return NULL;
14701 }
14702
14703
14704 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14705 PyObject *resultobj;
14706 wxFileType *arg1 = (wxFileType *) 0 ;
14707 wxString *arg2 = 0 ;
14708 wxString const &arg3_defvalue = wxPyEmptyString ;
14709 wxString *arg3 = (wxString *) &arg3_defvalue ;
14710 PyObject *result;
14711 bool temp2 = false ;
14712 bool temp3 = false ;
14713 PyObject * obj0 = 0 ;
14714 PyObject * obj1 = 0 ;
14715 PyObject * obj2 = 0 ;
14716 char *kwnames[] = {
14717 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14718 };
14719
14720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14722 if (SWIG_arg_fail(1)) SWIG_fail;
14723 {
14724 arg2 = wxString_in_helper(obj1);
14725 if (arg2 == NULL) SWIG_fail;
14726 temp2 = true;
14727 }
14728 if (obj2) {
14729 {
14730 arg3 = wxString_in_helper(obj2);
14731 if (arg3 == NULL) SWIG_fail;
14732 temp3 = true;
14733 }
14734 }
14735 {
14736 PyThreadState* __tstate = wxPyBeginAllowThreads();
14737 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14738
14739 wxPyEndAllowThreads(__tstate);
14740 if (PyErr_Occurred()) SWIG_fail;
14741 }
14742 resultobj = result;
14743 {
14744 if (temp2)
14745 delete arg2;
14746 }
14747 {
14748 if (temp3)
14749 delete arg3;
14750 }
14751 return resultobj;
14752 fail:
14753 {
14754 if (temp2)
14755 delete arg2;
14756 }
14757 {
14758 if (temp3)
14759 delete arg3;
14760 }
14761 return NULL;
14762 }
14763
14764
14765 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14766 PyObject *resultobj;
14767 wxFileType *arg1 = (wxFileType *) 0 ;
14768 wxString *arg2 = 0 ;
14769 wxString const &arg3_defvalue = wxPyEmptyString ;
14770 wxString *arg3 = (wxString *) &arg3_defvalue ;
14771 PyObject *result;
14772 bool temp2 = false ;
14773 bool temp3 = false ;
14774 PyObject * obj0 = 0 ;
14775 PyObject * obj1 = 0 ;
14776 PyObject * obj2 = 0 ;
14777 char *kwnames[] = {
14778 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14779 };
14780
14781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14783 if (SWIG_arg_fail(1)) SWIG_fail;
14784 {
14785 arg2 = wxString_in_helper(obj1);
14786 if (arg2 == NULL) SWIG_fail;
14787 temp2 = true;
14788 }
14789 if (obj2) {
14790 {
14791 arg3 = wxString_in_helper(obj2);
14792 if (arg3 == NULL) SWIG_fail;
14793 temp3 = true;
14794 }
14795 }
14796 {
14797 PyThreadState* __tstate = wxPyBeginAllowThreads();
14798 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14799
14800 wxPyEndAllowThreads(__tstate);
14801 if (PyErr_Occurred()) SWIG_fail;
14802 }
14803 resultobj = result;
14804 {
14805 if (temp2)
14806 delete arg2;
14807 }
14808 {
14809 if (temp3)
14810 delete arg3;
14811 }
14812 return resultobj;
14813 fail:
14814 {
14815 if (temp2)
14816 delete arg2;
14817 }
14818 {
14819 if (temp3)
14820 delete arg3;
14821 }
14822 return NULL;
14823 }
14824
14825
14826 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14827 PyObject *resultobj;
14828 wxFileType *arg1 = (wxFileType *) 0 ;
14829 wxString *arg2 = 0 ;
14830 wxString *arg3 = 0 ;
14831 bool arg4 = (bool) true ;
14832 bool result;
14833 bool temp2 = false ;
14834 bool temp3 = false ;
14835 PyObject * obj0 = 0 ;
14836 PyObject * obj1 = 0 ;
14837 PyObject * obj2 = 0 ;
14838 PyObject * obj3 = 0 ;
14839 char *kwnames[] = {
14840 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14841 };
14842
14843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14845 if (SWIG_arg_fail(1)) SWIG_fail;
14846 {
14847 arg2 = wxString_in_helper(obj1);
14848 if (arg2 == NULL) SWIG_fail;
14849 temp2 = true;
14850 }
14851 {
14852 arg3 = wxString_in_helper(obj2);
14853 if (arg3 == NULL) SWIG_fail;
14854 temp3 = true;
14855 }
14856 if (obj3) {
14857 {
14858 arg4 = (bool)(SWIG_As_bool(obj3));
14859 if (SWIG_arg_fail(4)) SWIG_fail;
14860 }
14861 }
14862 {
14863 PyThreadState* __tstate = wxPyBeginAllowThreads();
14864 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14865
14866 wxPyEndAllowThreads(__tstate);
14867 if (PyErr_Occurred()) SWIG_fail;
14868 }
14869 {
14870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14871 }
14872 {
14873 if (temp2)
14874 delete arg2;
14875 }
14876 {
14877 if (temp3)
14878 delete arg3;
14879 }
14880 return resultobj;
14881 fail:
14882 {
14883 if (temp2)
14884 delete arg2;
14885 }
14886 {
14887 if (temp3)
14888 delete arg3;
14889 }
14890 return NULL;
14891 }
14892
14893
14894 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14895 PyObject *resultobj;
14896 wxFileType *arg1 = (wxFileType *) 0 ;
14897 wxString const &arg2_defvalue = wxPyEmptyString ;
14898 wxString *arg2 = (wxString *) &arg2_defvalue ;
14899 int arg3 = (int) 0 ;
14900 bool result;
14901 bool temp2 = false ;
14902 PyObject * obj0 = 0 ;
14903 PyObject * obj1 = 0 ;
14904 PyObject * obj2 = 0 ;
14905 char *kwnames[] = {
14906 (char *) "self",(char *) "cmd",(char *) "index", NULL
14907 };
14908
14909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14911 if (SWIG_arg_fail(1)) SWIG_fail;
14912 if (obj1) {
14913 {
14914 arg2 = wxString_in_helper(obj1);
14915 if (arg2 == NULL) SWIG_fail;
14916 temp2 = true;
14917 }
14918 }
14919 if (obj2) {
14920 {
14921 arg3 = (int)(SWIG_As_int(obj2));
14922 if (SWIG_arg_fail(3)) SWIG_fail;
14923 }
14924 }
14925 {
14926 PyThreadState* __tstate = wxPyBeginAllowThreads();
14927 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14928
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 {
14933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14934 }
14935 {
14936 if (temp2)
14937 delete arg2;
14938 }
14939 return resultobj;
14940 fail:
14941 {
14942 if (temp2)
14943 delete arg2;
14944 }
14945 return NULL;
14946 }
14947
14948
14949 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14950 PyObject *resultobj;
14951 wxFileType *arg1 = (wxFileType *) 0 ;
14952 bool result;
14953 PyObject * obj0 = 0 ;
14954 char *kwnames[] = {
14955 (char *) "self", NULL
14956 };
14957
14958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14960 if (SWIG_arg_fail(1)) SWIG_fail;
14961 {
14962 PyThreadState* __tstate = wxPyBeginAllowThreads();
14963 result = (bool)(arg1)->Unassociate();
14964
14965 wxPyEndAllowThreads(__tstate);
14966 if (PyErr_Occurred()) SWIG_fail;
14967 }
14968 {
14969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14970 }
14971 return resultobj;
14972 fail:
14973 return NULL;
14974 }
14975
14976
14977 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14978 PyObject *resultobj;
14979 wxString *arg1 = 0 ;
14980 wxString *arg2 = 0 ;
14981 wxString const &arg3_defvalue = wxPyEmptyString ;
14982 wxString *arg3 = (wxString *) &arg3_defvalue ;
14983 wxString result;
14984 bool temp1 = false ;
14985 bool temp2 = false ;
14986 bool temp3 = false ;
14987 PyObject * obj0 = 0 ;
14988 PyObject * obj1 = 0 ;
14989 PyObject * obj2 = 0 ;
14990 char *kwnames[] = {
14991 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14992 };
14993
14994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14995 {
14996 arg1 = wxString_in_helper(obj0);
14997 if (arg1 == NULL) SWIG_fail;
14998 temp1 = true;
14999 }
15000 {
15001 arg2 = wxString_in_helper(obj1);
15002 if (arg2 == NULL) SWIG_fail;
15003 temp2 = true;
15004 }
15005 if (obj2) {
15006 {
15007 arg3 = wxString_in_helper(obj2);
15008 if (arg3 == NULL) SWIG_fail;
15009 temp3 = true;
15010 }
15011 }
15012 {
15013 PyThreadState* __tstate = wxPyBeginAllowThreads();
15014 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15015
15016 wxPyEndAllowThreads(__tstate);
15017 if (PyErr_Occurred()) SWIG_fail;
15018 }
15019 {
15020 #if wxUSE_UNICODE
15021 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15022 #else
15023 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15024 #endif
15025 }
15026 {
15027 if (temp1)
15028 delete arg1;
15029 }
15030 {
15031 if (temp2)
15032 delete arg2;
15033 }
15034 {
15035 if (temp3)
15036 delete arg3;
15037 }
15038 return resultobj;
15039 fail:
15040 {
15041 if (temp1)
15042 delete arg1;
15043 }
15044 {
15045 if (temp2)
15046 delete arg2;
15047 }
15048 {
15049 if (temp3)
15050 delete arg3;
15051 }
15052 return NULL;
15053 }
15054
15055
15056 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
15057 PyObject *obj;
15058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15059 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
15060 Py_INCREF(obj);
15061 return Py_BuildValue((char *)"");
15062 }
15063 static int _wrap_TheMimeTypesManager_set(PyObject *) {
15064 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
15065 return 1;
15066 }
15067
15068
15069 static PyObject *_wrap_TheMimeTypesManager_get(void) {
15070 PyObject *pyobj;
15071
15072 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
15073 return pyobj;
15074 }
15075
15076
15077 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
15078 PyObject *resultobj;
15079 wxString *arg1 = 0 ;
15080 wxString *arg2 = 0 ;
15081 bool result;
15082 bool temp1 = false ;
15083 bool temp2 = false ;
15084 PyObject * obj0 = 0 ;
15085 PyObject * obj1 = 0 ;
15086 char *kwnames[] = {
15087 (char *) "mimeType",(char *) "wildcard", NULL
15088 };
15089
15090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15091 {
15092 arg1 = wxString_in_helper(obj0);
15093 if (arg1 == NULL) SWIG_fail;
15094 temp1 = true;
15095 }
15096 {
15097 arg2 = wxString_in_helper(obj1);
15098 if (arg2 == NULL) SWIG_fail;
15099 temp2 = true;
15100 }
15101 {
15102 PyThreadState* __tstate = wxPyBeginAllowThreads();
15103 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15104
15105 wxPyEndAllowThreads(__tstate);
15106 if (PyErr_Occurred()) SWIG_fail;
15107 }
15108 {
15109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15110 }
15111 {
15112 if (temp1)
15113 delete arg1;
15114 }
15115 {
15116 if (temp2)
15117 delete arg2;
15118 }
15119 return resultobj;
15120 fail:
15121 {
15122 if (temp1)
15123 delete arg1;
15124 }
15125 {
15126 if (temp2)
15127 delete arg2;
15128 }
15129 return NULL;
15130 }
15131
15132
15133 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15134 PyObject *resultobj;
15135 wxMimeTypesManager *result;
15136 char *kwnames[] = {
15137 NULL
15138 };
15139
15140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15141 {
15142 PyThreadState* __tstate = wxPyBeginAllowThreads();
15143 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15144
15145 wxPyEndAllowThreads(__tstate);
15146 if (PyErr_Occurred()) SWIG_fail;
15147 }
15148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15149 return resultobj;
15150 fail:
15151 return NULL;
15152 }
15153
15154
15155 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15156 PyObject *resultobj;
15157 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15158 int arg2 = (int) wxMAILCAP_ALL ;
15159 wxString const &arg3_defvalue = wxPyEmptyString ;
15160 wxString *arg3 = (wxString *) &arg3_defvalue ;
15161 bool temp3 = false ;
15162 PyObject * obj0 = 0 ;
15163 PyObject * obj1 = 0 ;
15164 PyObject * obj2 = 0 ;
15165 char *kwnames[] = {
15166 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15167 };
15168
15169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15171 if (SWIG_arg_fail(1)) SWIG_fail;
15172 if (obj1) {
15173 {
15174 arg2 = (int)(SWIG_As_int(obj1));
15175 if (SWIG_arg_fail(2)) SWIG_fail;
15176 }
15177 }
15178 if (obj2) {
15179 {
15180 arg3 = wxString_in_helper(obj2);
15181 if (arg3 == NULL) SWIG_fail;
15182 temp3 = true;
15183 }
15184 }
15185 {
15186 PyThreadState* __tstate = wxPyBeginAllowThreads();
15187 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15188
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 Py_INCREF(Py_None); resultobj = Py_None;
15193 {
15194 if (temp3)
15195 delete arg3;
15196 }
15197 return resultobj;
15198 fail:
15199 {
15200 if (temp3)
15201 delete arg3;
15202 }
15203 return NULL;
15204 }
15205
15206
15207 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15208 PyObject *resultobj;
15209 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15210 PyObject * obj0 = 0 ;
15211 char *kwnames[] = {
15212 (char *) "self", NULL
15213 };
15214
15215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15217 if (SWIG_arg_fail(1)) SWIG_fail;
15218 {
15219 PyThreadState* __tstate = wxPyBeginAllowThreads();
15220 (arg1)->ClearData();
15221
15222 wxPyEndAllowThreads(__tstate);
15223 if (PyErr_Occurred()) SWIG_fail;
15224 }
15225 Py_INCREF(Py_None); resultobj = Py_None;
15226 return resultobj;
15227 fail:
15228 return NULL;
15229 }
15230
15231
15232 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15233 PyObject *resultobj;
15234 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15235 wxString *arg2 = 0 ;
15236 wxFileType *result;
15237 bool temp2 = false ;
15238 PyObject * obj0 = 0 ;
15239 PyObject * obj1 = 0 ;
15240 char *kwnames[] = {
15241 (char *) "self",(char *) "ext", NULL
15242 };
15243
15244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15246 if (SWIG_arg_fail(1)) SWIG_fail;
15247 {
15248 arg2 = wxString_in_helper(obj1);
15249 if (arg2 == NULL) SWIG_fail;
15250 temp2 = true;
15251 }
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15255
15256 wxPyEndAllowThreads(__tstate);
15257 if (PyErr_Occurred()) SWIG_fail;
15258 }
15259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15260 {
15261 if (temp2)
15262 delete arg2;
15263 }
15264 return resultobj;
15265 fail:
15266 {
15267 if (temp2)
15268 delete arg2;
15269 }
15270 return NULL;
15271 }
15272
15273
15274 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15275 PyObject *resultobj;
15276 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15277 wxString *arg2 = 0 ;
15278 wxFileType *result;
15279 bool temp2 = false ;
15280 PyObject * obj0 = 0 ;
15281 PyObject * obj1 = 0 ;
15282 char *kwnames[] = {
15283 (char *) "self",(char *) "mimeType", NULL
15284 };
15285
15286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15288 if (SWIG_arg_fail(1)) SWIG_fail;
15289 {
15290 arg2 = wxString_in_helper(obj1);
15291 if (arg2 == NULL) SWIG_fail;
15292 temp2 = true;
15293 }
15294 {
15295 PyThreadState* __tstate = wxPyBeginAllowThreads();
15296 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15297
15298 wxPyEndAllowThreads(__tstate);
15299 if (PyErr_Occurred()) SWIG_fail;
15300 }
15301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15302 {
15303 if (temp2)
15304 delete arg2;
15305 }
15306 return resultobj;
15307 fail:
15308 {
15309 if (temp2)
15310 delete arg2;
15311 }
15312 return NULL;
15313 }
15314
15315
15316 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15317 PyObject *resultobj;
15318 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15319 wxString *arg2 = 0 ;
15320 bool arg3 = (bool) false ;
15321 bool result;
15322 bool temp2 = false ;
15323 PyObject * obj0 = 0 ;
15324 PyObject * obj1 = 0 ;
15325 PyObject * obj2 = 0 ;
15326 char *kwnames[] = {
15327 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15328 };
15329
15330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = wxString_in_helper(obj1);
15335 if (arg2 == NULL) SWIG_fail;
15336 temp2 = true;
15337 }
15338 if (obj2) {
15339 {
15340 arg3 = (bool)(SWIG_As_bool(obj2));
15341 if (SWIG_arg_fail(3)) SWIG_fail;
15342 }
15343 }
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15347
15348 wxPyEndAllowThreads(__tstate);
15349 if (PyErr_Occurred()) SWIG_fail;
15350 }
15351 {
15352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15353 }
15354 {
15355 if (temp2)
15356 delete arg2;
15357 }
15358 return resultobj;
15359 fail:
15360 {
15361 if (temp2)
15362 delete arg2;
15363 }
15364 return NULL;
15365 }
15366
15367
15368 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15369 PyObject *resultobj;
15370 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15371 wxString *arg2 = 0 ;
15372 bool result;
15373 bool temp2 = false ;
15374 PyObject * obj0 = 0 ;
15375 PyObject * obj1 = 0 ;
15376 char *kwnames[] = {
15377 (char *) "self",(char *) "filename", NULL
15378 };
15379
15380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15382 if (SWIG_arg_fail(1)) SWIG_fail;
15383 {
15384 arg2 = wxString_in_helper(obj1);
15385 if (arg2 == NULL) SWIG_fail;
15386 temp2 = true;
15387 }
15388 {
15389 PyThreadState* __tstate = wxPyBeginAllowThreads();
15390 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15391
15392 wxPyEndAllowThreads(__tstate);
15393 if (PyErr_Occurred()) SWIG_fail;
15394 }
15395 {
15396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15397 }
15398 {
15399 if (temp2)
15400 delete arg2;
15401 }
15402 return resultobj;
15403 fail:
15404 {
15405 if (temp2)
15406 delete arg2;
15407 }
15408 return NULL;
15409 }
15410
15411
15412 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15413 PyObject *resultobj;
15414 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15415 PyObject *result;
15416 PyObject * obj0 = 0 ;
15417 char *kwnames[] = {
15418 (char *) "self", NULL
15419 };
15420
15421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15423 if (SWIG_arg_fail(1)) SWIG_fail;
15424 {
15425 PyThreadState* __tstate = wxPyBeginAllowThreads();
15426 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15427
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 resultobj = result;
15432 return resultobj;
15433 fail:
15434 return NULL;
15435 }
15436
15437
15438 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15439 PyObject *resultobj;
15440 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15441 wxFileTypeInfo *arg2 = 0 ;
15442 PyObject * obj0 = 0 ;
15443 PyObject * obj1 = 0 ;
15444 char *kwnames[] = {
15445 (char *) "self",(char *) "ft", NULL
15446 };
15447
15448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15450 if (SWIG_arg_fail(1)) SWIG_fail;
15451 {
15452 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15453 if (SWIG_arg_fail(2)) SWIG_fail;
15454 if (arg2 == NULL) {
15455 SWIG_null_ref("wxFileTypeInfo");
15456 }
15457 if (SWIG_arg_fail(2)) SWIG_fail;
15458 }
15459 {
15460 PyThreadState* __tstate = wxPyBeginAllowThreads();
15461 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15462
15463 wxPyEndAllowThreads(__tstate);
15464 if (PyErr_Occurred()) SWIG_fail;
15465 }
15466 Py_INCREF(Py_None); resultobj = Py_None;
15467 return resultobj;
15468 fail:
15469 return NULL;
15470 }
15471
15472
15473 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15474 PyObject *resultobj;
15475 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15476 wxFileTypeInfo *arg2 = 0 ;
15477 wxFileType *result;
15478 PyObject * obj0 = 0 ;
15479 PyObject * obj1 = 0 ;
15480 char *kwnames[] = {
15481 (char *) "self",(char *) "ftInfo", NULL
15482 };
15483
15484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15486 if (SWIG_arg_fail(1)) SWIG_fail;
15487 {
15488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15489 if (SWIG_arg_fail(2)) SWIG_fail;
15490 if (arg2 == NULL) {
15491 SWIG_null_ref("wxFileTypeInfo");
15492 }
15493 if (SWIG_arg_fail(2)) SWIG_fail;
15494 }
15495 {
15496 PyThreadState* __tstate = wxPyBeginAllowThreads();
15497 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15498
15499 wxPyEndAllowThreads(__tstate);
15500 if (PyErr_Occurred()) SWIG_fail;
15501 }
15502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15503 return resultobj;
15504 fail:
15505 return NULL;
15506 }
15507
15508
15509 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15510 PyObject *resultobj;
15511 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15512 wxFileType *arg2 = (wxFileType *) 0 ;
15513 bool result;
15514 PyObject * obj0 = 0 ;
15515 PyObject * obj1 = 0 ;
15516 char *kwnames[] = {
15517 (char *) "self",(char *) "ft", NULL
15518 };
15519
15520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15522 if (SWIG_arg_fail(1)) SWIG_fail;
15523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15524 if (SWIG_arg_fail(2)) SWIG_fail;
15525 {
15526 PyThreadState* __tstate = wxPyBeginAllowThreads();
15527 result = (bool)(arg1)->Unassociate(arg2);
15528
15529 wxPyEndAllowThreads(__tstate);
15530 if (PyErr_Occurred()) SWIG_fail;
15531 }
15532 {
15533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15534 }
15535 return resultobj;
15536 fail:
15537 return NULL;
15538 }
15539
15540
15541 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15542 PyObject *resultobj;
15543 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15544 PyObject * obj0 = 0 ;
15545 char *kwnames[] = {
15546 (char *) "self", NULL
15547 };
15548
15549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15551 if (SWIG_arg_fail(1)) SWIG_fail;
15552 {
15553 PyThreadState* __tstate = wxPyBeginAllowThreads();
15554 delete arg1;
15555
15556 wxPyEndAllowThreads(__tstate);
15557 if (PyErr_Occurred()) SWIG_fail;
15558 }
15559 Py_INCREF(Py_None); resultobj = Py_None;
15560 return resultobj;
15561 fail:
15562 return NULL;
15563 }
15564
15565
15566 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15567 PyObject *obj;
15568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15569 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15570 Py_INCREF(obj);
15571 return Py_BuildValue((char *)"");
15572 }
15573 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15574 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15575 return 1;
15576 }
15577
15578
15579 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15580 PyObject *pyobj;
15581
15582 {
15583 #if wxUSE_UNICODE
15584 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15585 #else
15586 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15587 #endif
15588 }
15589 return pyobj;
15590 }
15591
15592
15593 static int _wrap_ART_MENU_set(PyObject *) {
15594 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15595 return 1;
15596 }
15597
15598
15599 static PyObject *_wrap_ART_MENU_get(void) {
15600 PyObject *pyobj;
15601
15602 {
15603 #if wxUSE_UNICODE
15604 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15605 #else
15606 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15607 #endif
15608 }
15609 return pyobj;
15610 }
15611
15612
15613 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15614 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15615 return 1;
15616 }
15617
15618
15619 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15620 PyObject *pyobj;
15621
15622 {
15623 #if wxUSE_UNICODE
15624 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15625 #else
15626 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15627 #endif
15628 }
15629 return pyobj;
15630 }
15631
15632
15633 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15634 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15635 return 1;
15636 }
15637
15638
15639 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15640 PyObject *pyobj;
15641
15642 {
15643 #if wxUSE_UNICODE
15644 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15645 #else
15646 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15647 #endif
15648 }
15649 return pyobj;
15650 }
15651
15652
15653 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15654 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15655 return 1;
15656 }
15657
15658
15659 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15660 PyObject *pyobj;
15661
15662 {
15663 #if wxUSE_UNICODE
15664 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15665 #else
15666 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15667 #endif
15668 }
15669 return pyobj;
15670 }
15671
15672
15673 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15674 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15675 return 1;
15676 }
15677
15678
15679 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15680 PyObject *pyobj;
15681
15682 {
15683 #if wxUSE_UNICODE
15684 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15685 #else
15686 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15687 #endif
15688 }
15689 return pyobj;
15690 }
15691
15692
15693 static int _wrap_ART_BUTTON_set(PyObject *) {
15694 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15695 return 1;
15696 }
15697
15698
15699 static PyObject *_wrap_ART_BUTTON_get(void) {
15700 PyObject *pyobj;
15701
15702 {
15703 #if wxUSE_UNICODE
15704 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15705 #else
15706 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15707 #endif
15708 }
15709 return pyobj;
15710 }
15711
15712
15713 static int _wrap_ART_OTHER_set(PyObject *) {
15714 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15715 return 1;
15716 }
15717
15718
15719 static PyObject *_wrap_ART_OTHER_get(void) {
15720 PyObject *pyobj;
15721
15722 {
15723 #if wxUSE_UNICODE
15724 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15725 #else
15726 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15727 #endif
15728 }
15729 return pyobj;
15730 }
15731
15732
15733 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15734 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15735 return 1;
15736 }
15737
15738
15739 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15740 PyObject *pyobj;
15741
15742 {
15743 #if wxUSE_UNICODE
15744 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15745 #else
15746 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15747 #endif
15748 }
15749 return pyobj;
15750 }
15751
15752
15753 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15754 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15755 return 1;
15756 }
15757
15758
15759 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15760 PyObject *pyobj;
15761
15762 {
15763 #if wxUSE_UNICODE
15764 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15765 #else
15766 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15767 #endif
15768 }
15769 return pyobj;
15770 }
15771
15772
15773 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15774 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15775 return 1;
15776 }
15777
15778
15779 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15780 PyObject *pyobj;
15781
15782 {
15783 #if wxUSE_UNICODE
15784 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15785 #else
15786 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15787 #endif
15788 }
15789 return pyobj;
15790 }
15791
15792
15793 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15794 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15795 return 1;
15796 }
15797
15798
15799 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15800 PyObject *pyobj;
15801
15802 {
15803 #if wxUSE_UNICODE
15804 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15805 #else
15806 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15807 #endif
15808 }
15809 return pyobj;
15810 }
15811
15812
15813 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15814 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15815 return 1;
15816 }
15817
15818
15819 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15820 PyObject *pyobj;
15821
15822 {
15823 #if wxUSE_UNICODE
15824 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15825 #else
15826 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15827 #endif
15828 }
15829 return pyobj;
15830 }
15831
15832
15833 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15834 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15835 return 1;
15836 }
15837
15838
15839 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15840 PyObject *pyobj;
15841
15842 {
15843 #if wxUSE_UNICODE
15844 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15845 #else
15846 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15847 #endif
15848 }
15849 return pyobj;
15850 }
15851
15852
15853 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15854 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15855 return 1;
15856 }
15857
15858
15859 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15860 PyObject *pyobj;
15861
15862 {
15863 #if wxUSE_UNICODE
15864 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15865 #else
15866 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15867 #endif
15868 }
15869 return pyobj;
15870 }
15871
15872
15873 static int _wrap_ART_GO_BACK_set(PyObject *) {
15874 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15875 return 1;
15876 }
15877
15878
15879 static PyObject *_wrap_ART_GO_BACK_get(void) {
15880 PyObject *pyobj;
15881
15882 {
15883 #if wxUSE_UNICODE
15884 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15885 #else
15886 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15887 #endif
15888 }
15889 return pyobj;
15890 }
15891
15892
15893 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15894 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15895 return 1;
15896 }
15897
15898
15899 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15900 PyObject *pyobj;
15901
15902 {
15903 #if wxUSE_UNICODE
15904 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15905 #else
15906 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15907 #endif
15908 }
15909 return pyobj;
15910 }
15911
15912
15913 static int _wrap_ART_GO_UP_set(PyObject *) {
15914 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15915 return 1;
15916 }
15917
15918
15919 static PyObject *_wrap_ART_GO_UP_get(void) {
15920 PyObject *pyobj;
15921
15922 {
15923 #if wxUSE_UNICODE
15924 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15925 #else
15926 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15927 #endif
15928 }
15929 return pyobj;
15930 }
15931
15932
15933 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15934 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15935 return 1;
15936 }
15937
15938
15939 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15940 PyObject *pyobj;
15941
15942 {
15943 #if wxUSE_UNICODE
15944 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15945 #else
15946 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15947 #endif
15948 }
15949 return pyobj;
15950 }
15951
15952
15953 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15954 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15955 return 1;
15956 }
15957
15958
15959 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15960 PyObject *pyobj;
15961
15962 {
15963 #if wxUSE_UNICODE
15964 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15965 #else
15966 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15967 #endif
15968 }
15969 return pyobj;
15970 }
15971
15972
15973 static int _wrap_ART_GO_HOME_set(PyObject *) {
15974 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15975 return 1;
15976 }
15977
15978
15979 static PyObject *_wrap_ART_GO_HOME_get(void) {
15980 PyObject *pyobj;
15981
15982 {
15983 #if wxUSE_UNICODE
15984 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15985 #else
15986 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15987 #endif
15988 }
15989 return pyobj;
15990 }
15991
15992
15993 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15994 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15995 return 1;
15996 }
15997
15998
15999 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
16000 PyObject *pyobj;
16001
16002 {
16003 #if wxUSE_UNICODE
16004 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16005 #else
16006 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16007 #endif
16008 }
16009 return pyobj;
16010 }
16011
16012
16013 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
16014 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
16015 return 1;
16016 }
16017
16018
16019 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
16020 PyObject *pyobj;
16021
16022 {
16023 #if wxUSE_UNICODE
16024 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16025 #else
16026 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16027 #endif
16028 }
16029 return pyobj;
16030 }
16031
16032
16033 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
16034 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
16035 return 1;
16036 }
16037
16038
16039 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
16040 PyObject *pyobj;
16041
16042 {
16043 #if wxUSE_UNICODE
16044 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16045 #else
16046 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16047 #endif
16048 }
16049 return pyobj;
16050 }
16051
16052
16053 static int _wrap_ART_PRINT_set(PyObject *) {
16054 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
16055 return 1;
16056 }
16057
16058
16059 static PyObject *_wrap_ART_PRINT_get(void) {
16060 PyObject *pyobj;
16061
16062 {
16063 #if wxUSE_UNICODE
16064 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16065 #else
16066 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16067 #endif
16068 }
16069 return pyobj;
16070 }
16071
16072
16073 static int _wrap_ART_HELP_set(PyObject *) {
16074 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
16075 return 1;
16076 }
16077
16078
16079 static PyObject *_wrap_ART_HELP_get(void) {
16080 PyObject *pyobj;
16081
16082 {
16083 #if wxUSE_UNICODE
16084 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16085 #else
16086 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16087 #endif
16088 }
16089 return pyobj;
16090 }
16091
16092
16093 static int _wrap_ART_TIP_set(PyObject *) {
16094 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16095 return 1;
16096 }
16097
16098
16099 static PyObject *_wrap_ART_TIP_get(void) {
16100 PyObject *pyobj;
16101
16102 {
16103 #if wxUSE_UNICODE
16104 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16105 #else
16106 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16107 #endif
16108 }
16109 return pyobj;
16110 }
16111
16112
16113 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16114 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16115 return 1;
16116 }
16117
16118
16119 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16120 PyObject *pyobj;
16121
16122 {
16123 #if wxUSE_UNICODE
16124 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16125 #else
16126 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16127 #endif
16128 }
16129 return pyobj;
16130 }
16131
16132
16133 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16134 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16135 return 1;
16136 }
16137
16138
16139 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16140 PyObject *pyobj;
16141
16142 {
16143 #if wxUSE_UNICODE
16144 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16145 #else
16146 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16147 #endif
16148 }
16149 return pyobj;
16150 }
16151
16152
16153 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16154 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16155 return 1;
16156 }
16157
16158
16159 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16160 PyObject *pyobj;
16161
16162 {
16163 #if wxUSE_UNICODE
16164 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16165 #else
16166 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16167 #endif
16168 }
16169 return pyobj;
16170 }
16171
16172
16173 static int _wrap_ART_HARDDISK_set(PyObject *) {
16174 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16175 return 1;
16176 }
16177
16178
16179 static PyObject *_wrap_ART_HARDDISK_get(void) {
16180 PyObject *pyobj;
16181
16182 {
16183 #if wxUSE_UNICODE
16184 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16185 #else
16186 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16187 #endif
16188 }
16189 return pyobj;
16190 }
16191
16192
16193 static int _wrap_ART_FLOPPY_set(PyObject *) {
16194 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16195 return 1;
16196 }
16197
16198
16199 static PyObject *_wrap_ART_FLOPPY_get(void) {
16200 PyObject *pyobj;
16201
16202 {
16203 #if wxUSE_UNICODE
16204 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16205 #else
16206 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16207 #endif
16208 }
16209 return pyobj;
16210 }
16211
16212
16213 static int _wrap_ART_CDROM_set(PyObject *) {
16214 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16215 return 1;
16216 }
16217
16218
16219 static PyObject *_wrap_ART_CDROM_get(void) {
16220 PyObject *pyobj;
16221
16222 {
16223 #if wxUSE_UNICODE
16224 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16225 #else
16226 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16227 #endif
16228 }
16229 return pyobj;
16230 }
16231
16232
16233 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16234 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16235 return 1;
16236 }
16237
16238
16239 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16240 PyObject *pyobj;
16241
16242 {
16243 #if wxUSE_UNICODE
16244 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16245 #else
16246 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16247 #endif
16248 }
16249 return pyobj;
16250 }
16251
16252
16253 static int _wrap_ART_FOLDER_set(PyObject *) {
16254 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16255 return 1;
16256 }
16257
16258
16259 static PyObject *_wrap_ART_FOLDER_get(void) {
16260 PyObject *pyobj;
16261
16262 {
16263 #if wxUSE_UNICODE
16264 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16265 #else
16266 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16267 #endif
16268 }
16269 return pyobj;
16270 }
16271
16272
16273 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16274 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16275 return 1;
16276 }
16277
16278
16279 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16280 PyObject *pyobj;
16281
16282 {
16283 #if wxUSE_UNICODE
16284 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16285 #else
16286 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16287 #endif
16288 }
16289 return pyobj;
16290 }
16291
16292
16293 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16294 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16295 return 1;
16296 }
16297
16298
16299 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16300 PyObject *pyobj;
16301
16302 {
16303 #if wxUSE_UNICODE
16304 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16305 #else
16306 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16307 #endif
16308 }
16309 return pyobj;
16310 }
16311
16312
16313 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16314 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16315 return 1;
16316 }
16317
16318
16319 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16320 PyObject *pyobj;
16321
16322 {
16323 #if wxUSE_UNICODE
16324 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16325 #else
16326 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16327 #endif
16328 }
16329 return pyobj;
16330 }
16331
16332
16333 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16334 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16335 return 1;
16336 }
16337
16338
16339 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16340 PyObject *pyobj;
16341
16342 {
16343 #if wxUSE_UNICODE
16344 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16345 #else
16346 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16347 #endif
16348 }
16349 return pyobj;
16350 }
16351
16352
16353 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16354 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16355 return 1;
16356 }
16357
16358
16359 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16360 PyObject *pyobj;
16361
16362 {
16363 #if wxUSE_UNICODE
16364 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16365 #else
16366 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16367 #endif
16368 }
16369 return pyobj;
16370 }
16371
16372
16373 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16374 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16375 return 1;
16376 }
16377
16378
16379 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16380 PyObject *pyobj;
16381
16382 {
16383 #if wxUSE_UNICODE
16384 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16385 #else
16386 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16387 #endif
16388 }
16389 return pyobj;
16390 }
16391
16392
16393 static int _wrap_ART_ERROR_set(PyObject *) {
16394 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16395 return 1;
16396 }
16397
16398
16399 static PyObject *_wrap_ART_ERROR_get(void) {
16400 PyObject *pyobj;
16401
16402 {
16403 #if wxUSE_UNICODE
16404 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16405 #else
16406 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16407 #endif
16408 }
16409 return pyobj;
16410 }
16411
16412
16413 static int _wrap_ART_QUESTION_set(PyObject *) {
16414 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16415 return 1;
16416 }
16417
16418
16419 static PyObject *_wrap_ART_QUESTION_get(void) {
16420 PyObject *pyobj;
16421
16422 {
16423 #if wxUSE_UNICODE
16424 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16425 #else
16426 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16427 #endif
16428 }
16429 return pyobj;
16430 }
16431
16432
16433 static int _wrap_ART_WARNING_set(PyObject *) {
16434 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16435 return 1;
16436 }
16437
16438
16439 static PyObject *_wrap_ART_WARNING_get(void) {
16440 PyObject *pyobj;
16441
16442 {
16443 #if wxUSE_UNICODE
16444 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16445 #else
16446 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16447 #endif
16448 }
16449 return pyobj;
16450 }
16451
16452
16453 static int _wrap_ART_INFORMATION_set(PyObject *) {
16454 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16455 return 1;
16456 }
16457
16458
16459 static PyObject *_wrap_ART_INFORMATION_get(void) {
16460 PyObject *pyobj;
16461
16462 {
16463 #if wxUSE_UNICODE
16464 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16465 #else
16466 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16467 #endif
16468 }
16469 return pyobj;
16470 }
16471
16472
16473 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16474 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16475 return 1;
16476 }
16477
16478
16479 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16480 PyObject *pyobj;
16481
16482 {
16483 #if wxUSE_UNICODE
16484 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16485 #else
16486 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16487 #endif
16488 }
16489 return pyobj;
16490 }
16491
16492
16493 static int _wrap_ART_COPY_set(PyObject *) {
16494 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16495 return 1;
16496 }
16497
16498
16499 static PyObject *_wrap_ART_COPY_get(void) {
16500 PyObject *pyobj;
16501
16502 {
16503 #if wxUSE_UNICODE
16504 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16505 #else
16506 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16507 #endif
16508 }
16509 return pyobj;
16510 }
16511
16512
16513 static int _wrap_ART_CUT_set(PyObject *) {
16514 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16515 return 1;
16516 }
16517
16518
16519 static PyObject *_wrap_ART_CUT_get(void) {
16520 PyObject *pyobj;
16521
16522 {
16523 #if wxUSE_UNICODE
16524 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16525 #else
16526 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16527 #endif
16528 }
16529 return pyobj;
16530 }
16531
16532
16533 static int _wrap_ART_PASTE_set(PyObject *) {
16534 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16535 return 1;
16536 }
16537
16538
16539 static PyObject *_wrap_ART_PASTE_get(void) {
16540 PyObject *pyobj;
16541
16542 {
16543 #if wxUSE_UNICODE
16544 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16545 #else
16546 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16547 #endif
16548 }
16549 return pyobj;
16550 }
16551
16552
16553 static int _wrap_ART_DELETE_set(PyObject *) {
16554 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16555 return 1;
16556 }
16557
16558
16559 static PyObject *_wrap_ART_DELETE_get(void) {
16560 PyObject *pyobj;
16561
16562 {
16563 #if wxUSE_UNICODE
16564 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16565 #else
16566 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16567 #endif
16568 }
16569 return pyobj;
16570 }
16571
16572
16573 static int _wrap_ART_NEW_set(PyObject *) {
16574 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
16575 return 1;
16576 }
16577
16578
16579 static PyObject *_wrap_ART_NEW_get(void) {
16580 PyObject *pyobj;
16581
16582 {
16583 #if wxUSE_UNICODE
16584 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16585 #else
16586 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16587 #endif
16588 }
16589 return pyobj;
16590 }
16591
16592
16593 static int _wrap_ART_UNDO_set(PyObject *) {
16594 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16595 return 1;
16596 }
16597
16598
16599 static PyObject *_wrap_ART_UNDO_get(void) {
16600 PyObject *pyobj;
16601
16602 {
16603 #if wxUSE_UNICODE
16604 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16605 #else
16606 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16607 #endif
16608 }
16609 return pyobj;
16610 }
16611
16612
16613 static int _wrap_ART_REDO_set(PyObject *) {
16614 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16615 return 1;
16616 }
16617
16618
16619 static PyObject *_wrap_ART_REDO_get(void) {
16620 PyObject *pyobj;
16621
16622 {
16623 #if wxUSE_UNICODE
16624 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16625 #else
16626 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16627 #endif
16628 }
16629 return pyobj;
16630 }
16631
16632
16633 static int _wrap_ART_QUIT_set(PyObject *) {
16634 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16635 return 1;
16636 }
16637
16638
16639 static PyObject *_wrap_ART_QUIT_get(void) {
16640 PyObject *pyobj;
16641
16642 {
16643 #if wxUSE_UNICODE
16644 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16645 #else
16646 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16647 #endif
16648 }
16649 return pyobj;
16650 }
16651
16652
16653 static int _wrap_ART_FIND_set(PyObject *) {
16654 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16655 return 1;
16656 }
16657
16658
16659 static PyObject *_wrap_ART_FIND_get(void) {
16660 PyObject *pyobj;
16661
16662 {
16663 #if wxUSE_UNICODE
16664 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16665 #else
16666 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16667 #endif
16668 }
16669 return pyobj;
16670 }
16671
16672
16673 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16674 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16675 return 1;
16676 }
16677
16678
16679 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16680 PyObject *pyobj;
16681
16682 {
16683 #if wxUSE_UNICODE
16684 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16685 #else
16686 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16687 #endif
16688 }
16689 return pyobj;
16690 }
16691
16692
16693 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16694 PyObject *resultobj;
16695 wxPyArtProvider *result;
16696 char *kwnames[] = {
16697 NULL
16698 };
16699
16700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16701 {
16702 if (!wxPyCheckForApp()) SWIG_fail;
16703 PyThreadState* __tstate = wxPyBeginAllowThreads();
16704 result = (wxPyArtProvider *)new wxPyArtProvider();
16705
16706 wxPyEndAllowThreads(__tstate);
16707 if (PyErr_Occurred()) SWIG_fail;
16708 }
16709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16710 return resultobj;
16711 fail:
16712 return NULL;
16713 }
16714
16715
16716 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16717 PyObject *resultobj;
16718 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16719 PyObject *arg2 = (PyObject *) 0 ;
16720 PyObject *arg3 = (PyObject *) 0 ;
16721 PyObject * obj0 = 0 ;
16722 PyObject * obj1 = 0 ;
16723 PyObject * obj2 = 0 ;
16724 char *kwnames[] = {
16725 (char *) "self",(char *) "self",(char *) "_class", NULL
16726 };
16727
16728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16730 if (SWIG_arg_fail(1)) SWIG_fail;
16731 arg2 = obj1;
16732 arg3 = obj2;
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 (arg1)->_setCallbackInfo(arg2,arg3);
16736
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 Py_INCREF(Py_None); resultobj = Py_None;
16741 return resultobj;
16742 fail:
16743 return NULL;
16744 }
16745
16746
16747 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj;
16749 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16750 PyObject * obj0 = 0 ;
16751 char *kwnames[] = {
16752 (char *) "provider", NULL
16753 };
16754
16755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16757 if (SWIG_arg_fail(1)) SWIG_fail;
16758 {
16759 PyThreadState* __tstate = wxPyBeginAllowThreads();
16760 wxPyArtProvider::PushProvider(arg1);
16761
16762 wxPyEndAllowThreads(__tstate);
16763 if (PyErr_Occurred()) SWIG_fail;
16764 }
16765 Py_INCREF(Py_None); resultobj = Py_None;
16766 return resultobj;
16767 fail:
16768 return NULL;
16769 }
16770
16771
16772 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16773 PyObject *resultobj;
16774 bool result;
16775 char *kwnames[] = {
16776 NULL
16777 };
16778
16779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16780 {
16781 PyThreadState* __tstate = wxPyBeginAllowThreads();
16782 result = (bool)wxPyArtProvider::PopProvider();
16783
16784 wxPyEndAllowThreads(__tstate);
16785 if (PyErr_Occurred()) SWIG_fail;
16786 }
16787 {
16788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16789 }
16790 return resultobj;
16791 fail:
16792 return NULL;
16793 }
16794
16795
16796 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16797 PyObject *resultobj;
16798 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16799 bool result;
16800 PyObject * obj0 = 0 ;
16801 char *kwnames[] = {
16802 (char *) "provider", NULL
16803 };
16804
16805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16807 if (SWIG_arg_fail(1)) SWIG_fail;
16808 {
16809 PyThreadState* __tstate = wxPyBeginAllowThreads();
16810 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16811
16812 wxPyEndAllowThreads(__tstate);
16813 if (PyErr_Occurred()) SWIG_fail;
16814 }
16815 {
16816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16817 }
16818 return resultobj;
16819 fail:
16820 return NULL;
16821 }
16822
16823
16824 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16825 PyObject *resultobj;
16826 wxString *arg1 = 0 ;
16827 wxString const &arg2_defvalue = wxPyART_OTHER ;
16828 wxString *arg2 = (wxString *) &arg2_defvalue ;
16829 wxSize const &arg3_defvalue = wxDefaultSize ;
16830 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16831 wxBitmap result;
16832 bool temp1 = false ;
16833 bool temp2 = false ;
16834 wxSize temp3 ;
16835 PyObject * obj0 = 0 ;
16836 PyObject * obj1 = 0 ;
16837 PyObject * obj2 = 0 ;
16838 char *kwnames[] = {
16839 (char *) "id",(char *) "client",(char *) "size", NULL
16840 };
16841
16842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16843 {
16844 arg1 = wxString_in_helper(obj0);
16845 if (arg1 == NULL) SWIG_fail;
16846 temp1 = true;
16847 }
16848 if (obj1) {
16849 {
16850 arg2 = wxString_in_helper(obj1);
16851 if (arg2 == NULL) SWIG_fail;
16852 temp2 = true;
16853 }
16854 }
16855 if (obj2) {
16856 {
16857 arg3 = &temp3;
16858 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16859 }
16860 }
16861 {
16862 if (!wxPyCheckForApp()) SWIG_fail;
16863 PyThreadState* __tstate = wxPyBeginAllowThreads();
16864 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16865
16866 wxPyEndAllowThreads(__tstate);
16867 if (PyErr_Occurred()) SWIG_fail;
16868 }
16869 {
16870 wxBitmap * resultptr;
16871 resultptr = new wxBitmap((wxBitmap &)(result));
16872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16873 }
16874 {
16875 if (temp1)
16876 delete arg1;
16877 }
16878 {
16879 if (temp2)
16880 delete arg2;
16881 }
16882 return resultobj;
16883 fail:
16884 {
16885 if (temp1)
16886 delete arg1;
16887 }
16888 {
16889 if (temp2)
16890 delete arg2;
16891 }
16892 return NULL;
16893 }
16894
16895
16896 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16897 PyObject *resultobj;
16898 wxString *arg1 = 0 ;
16899 wxString const &arg2_defvalue = wxPyART_OTHER ;
16900 wxString *arg2 = (wxString *) &arg2_defvalue ;
16901 wxSize const &arg3_defvalue = wxDefaultSize ;
16902 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16903 wxIcon result;
16904 bool temp1 = false ;
16905 bool temp2 = false ;
16906 wxSize temp3 ;
16907 PyObject * obj0 = 0 ;
16908 PyObject * obj1 = 0 ;
16909 PyObject * obj2 = 0 ;
16910 char *kwnames[] = {
16911 (char *) "id",(char *) "client",(char *) "size", NULL
16912 };
16913
16914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16915 {
16916 arg1 = wxString_in_helper(obj0);
16917 if (arg1 == NULL) SWIG_fail;
16918 temp1 = true;
16919 }
16920 if (obj1) {
16921 {
16922 arg2 = wxString_in_helper(obj1);
16923 if (arg2 == NULL) SWIG_fail;
16924 temp2 = true;
16925 }
16926 }
16927 if (obj2) {
16928 {
16929 arg3 = &temp3;
16930 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16931 }
16932 }
16933 {
16934 if (!wxPyCheckForApp()) SWIG_fail;
16935 PyThreadState* __tstate = wxPyBeginAllowThreads();
16936 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16937
16938 wxPyEndAllowThreads(__tstate);
16939 if (PyErr_Occurred()) SWIG_fail;
16940 }
16941 {
16942 wxIcon * resultptr;
16943 resultptr = new wxIcon((wxIcon &)(result));
16944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16945 }
16946 {
16947 if (temp1)
16948 delete arg1;
16949 }
16950 {
16951 if (temp2)
16952 delete arg2;
16953 }
16954 return resultobj;
16955 fail:
16956 {
16957 if (temp1)
16958 delete arg1;
16959 }
16960 {
16961 if (temp2)
16962 delete arg2;
16963 }
16964 return NULL;
16965 }
16966
16967
16968 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16969 PyObject *resultobj;
16970 wxString *arg1 = 0 ;
16971 bool arg2 = (bool) false ;
16972 wxSize result;
16973 bool temp1 = false ;
16974 PyObject * obj0 = 0 ;
16975 PyObject * obj1 = 0 ;
16976 char *kwnames[] = {
16977 (char *) "client",(char *) "platform_dependent", NULL
16978 };
16979
16980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16981 {
16982 arg1 = wxString_in_helper(obj0);
16983 if (arg1 == NULL) SWIG_fail;
16984 temp1 = true;
16985 }
16986 if (obj1) {
16987 {
16988 arg2 = (bool)(SWIG_As_bool(obj1));
16989 if (SWIG_arg_fail(2)) SWIG_fail;
16990 }
16991 }
16992 {
16993 PyThreadState* __tstate = wxPyBeginAllowThreads();
16994 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16995
16996 wxPyEndAllowThreads(__tstate);
16997 if (PyErr_Occurred()) SWIG_fail;
16998 }
16999 {
17000 wxSize * resultptr;
17001 resultptr = new wxSize((wxSize &)(result));
17002 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
17003 }
17004 {
17005 if (temp1)
17006 delete arg1;
17007 }
17008 return resultobj;
17009 fail:
17010 {
17011 if (temp1)
17012 delete arg1;
17013 }
17014 return NULL;
17015 }
17016
17017
17018 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
17019 PyObject *resultobj;
17020 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17021 PyObject * obj0 = 0 ;
17022 char *kwnames[] = {
17023 (char *) "self", NULL
17024 };
17025
17026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
17027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17028 if (SWIG_arg_fail(1)) SWIG_fail;
17029 {
17030 PyThreadState* __tstate = wxPyBeginAllowThreads();
17031 wxPyArtProvider_Destroy(arg1);
17032
17033 wxPyEndAllowThreads(__tstate);
17034 if (PyErr_Occurred()) SWIG_fail;
17035 }
17036 Py_INCREF(Py_None); resultobj = Py_None;
17037 return resultobj;
17038 fail:
17039 return NULL;
17040 }
17041
17042
17043 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
17044 PyObject *obj;
17045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17046 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
17047 Py_INCREF(obj);
17048 return Py_BuildValue((char *)"");
17049 }
17050 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
17051 PyObject *resultobj;
17052 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17053 PyObject * obj0 = 0 ;
17054 char *kwnames[] = {
17055 (char *) "self", NULL
17056 };
17057
17058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
17059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17060 if (SWIG_arg_fail(1)) SWIG_fail;
17061 {
17062 PyThreadState* __tstate = wxPyBeginAllowThreads();
17063 delete arg1;
17064
17065 wxPyEndAllowThreads(__tstate);
17066 if (PyErr_Occurred()) SWIG_fail;
17067 }
17068 Py_INCREF(Py_None); resultobj = Py_None;
17069 return resultobj;
17070 fail:
17071 return NULL;
17072 }
17073
17074
17075 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
17076 PyObject *resultobj;
17077 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17078 wxConfigBase *result;
17079 PyObject * obj0 = 0 ;
17080 char *kwnames[] = {
17081 (char *) "config", NULL
17082 };
17083
17084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
17085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17086 if (SWIG_arg_fail(1)) SWIG_fail;
17087 {
17088 PyThreadState* __tstate = wxPyBeginAllowThreads();
17089 result = (wxConfigBase *)wxConfigBase::Set(arg1);
17090
17091 wxPyEndAllowThreads(__tstate);
17092 if (PyErr_Occurred()) SWIG_fail;
17093 }
17094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17095 return resultobj;
17096 fail:
17097 return NULL;
17098 }
17099
17100
17101 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17102 PyObject *resultobj;
17103 bool arg1 = (bool) true ;
17104 wxConfigBase *result;
17105 PyObject * obj0 = 0 ;
17106 char *kwnames[] = {
17107 (char *) "createOnDemand", NULL
17108 };
17109
17110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17111 if (obj0) {
17112 {
17113 arg1 = (bool)(SWIG_As_bool(obj0));
17114 if (SWIG_arg_fail(1)) SWIG_fail;
17115 }
17116 }
17117 {
17118 PyThreadState* __tstate = wxPyBeginAllowThreads();
17119 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17120
17121 wxPyEndAllowThreads(__tstate);
17122 if (PyErr_Occurred()) SWIG_fail;
17123 }
17124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17125 return resultobj;
17126 fail:
17127 return NULL;
17128 }
17129
17130
17131 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17132 PyObject *resultobj;
17133 wxConfigBase *result;
17134 char *kwnames[] = {
17135 NULL
17136 };
17137
17138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17139 {
17140 PyThreadState* __tstate = wxPyBeginAllowThreads();
17141 result = (wxConfigBase *)wxConfigBase::Create();
17142
17143 wxPyEndAllowThreads(__tstate);
17144 if (PyErr_Occurred()) SWIG_fail;
17145 }
17146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17147 return resultobj;
17148 fail:
17149 return NULL;
17150 }
17151
17152
17153 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17154 PyObject *resultobj;
17155 char *kwnames[] = {
17156 NULL
17157 };
17158
17159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17160 {
17161 PyThreadState* __tstate = wxPyBeginAllowThreads();
17162 wxConfigBase::DontCreateOnDemand();
17163
17164 wxPyEndAllowThreads(__tstate);
17165 if (PyErr_Occurred()) SWIG_fail;
17166 }
17167 Py_INCREF(Py_None); resultobj = Py_None;
17168 return resultobj;
17169 fail:
17170 return NULL;
17171 }
17172
17173
17174 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17175 PyObject *resultobj;
17176 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17177 wxString *arg2 = 0 ;
17178 bool temp2 = false ;
17179 PyObject * obj0 = 0 ;
17180 PyObject * obj1 = 0 ;
17181 char *kwnames[] = {
17182 (char *) "self",(char *) "path", NULL
17183 };
17184
17185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17187 if (SWIG_arg_fail(1)) SWIG_fail;
17188 {
17189 arg2 = wxString_in_helper(obj1);
17190 if (arg2 == NULL) SWIG_fail;
17191 temp2 = true;
17192 }
17193 {
17194 PyThreadState* __tstate = wxPyBeginAllowThreads();
17195 (arg1)->SetPath((wxString const &)*arg2);
17196
17197 wxPyEndAllowThreads(__tstate);
17198 if (PyErr_Occurred()) SWIG_fail;
17199 }
17200 Py_INCREF(Py_None); resultobj = Py_None;
17201 {
17202 if (temp2)
17203 delete arg2;
17204 }
17205 return resultobj;
17206 fail:
17207 {
17208 if (temp2)
17209 delete arg2;
17210 }
17211 return NULL;
17212 }
17213
17214
17215 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17216 PyObject *resultobj;
17217 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17218 wxString *result;
17219 PyObject * obj0 = 0 ;
17220 char *kwnames[] = {
17221 (char *) "self", NULL
17222 };
17223
17224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17226 if (SWIG_arg_fail(1)) SWIG_fail;
17227 {
17228 PyThreadState* __tstate = wxPyBeginAllowThreads();
17229 {
17230 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17231 result = (wxString *) &_result_ref;
17232 }
17233
17234 wxPyEndAllowThreads(__tstate);
17235 if (PyErr_Occurred()) SWIG_fail;
17236 }
17237 {
17238 #if wxUSE_UNICODE
17239 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17240 #else
17241 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17242 #endif
17243 }
17244 return resultobj;
17245 fail:
17246 return NULL;
17247 }
17248
17249
17250 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17251 PyObject *resultobj;
17252 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17253 PyObject *result;
17254 PyObject * obj0 = 0 ;
17255 char *kwnames[] = {
17256 (char *) "self", NULL
17257 };
17258
17259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17261 if (SWIG_arg_fail(1)) SWIG_fail;
17262 {
17263 PyThreadState* __tstate = wxPyBeginAllowThreads();
17264 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17265
17266 wxPyEndAllowThreads(__tstate);
17267 if (PyErr_Occurred()) SWIG_fail;
17268 }
17269 resultobj = result;
17270 return resultobj;
17271 fail:
17272 return NULL;
17273 }
17274
17275
17276 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17277 PyObject *resultobj;
17278 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17279 long arg2 ;
17280 PyObject *result;
17281 PyObject * obj0 = 0 ;
17282 PyObject * obj1 = 0 ;
17283 char *kwnames[] = {
17284 (char *) "self",(char *) "index", NULL
17285 };
17286
17287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17289 if (SWIG_arg_fail(1)) SWIG_fail;
17290 {
17291 arg2 = (long)(SWIG_As_long(obj1));
17292 if (SWIG_arg_fail(2)) SWIG_fail;
17293 }
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17297
17298 wxPyEndAllowThreads(__tstate);
17299 if (PyErr_Occurred()) SWIG_fail;
17300 }
17301 resultobj = result;
17302 return resultobj;
17303 fail:
17304 return NULL;
17305 }
17306
17307
17308 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17309 PyObject *resultobj;
17310 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17311 PyObject *result;
17312 PyObject * obj0 = 0 ;
17313 char *kwnames[] = {
17314 (char *) "self", NULL
17315 };
17316
17317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17319 if (SWIG_arg_fail(1)) SWIG_fail;
17320 {
17321 PyThreadState* __tstate = wxPyBeginAllowThreads();
17322 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17323
17324 wxPyEndAllowThreads(__tstate);
17325 if (PyErr_Occurred()) SWIG_fail;
17326 }
17327 resultobj = result;
17328 return resultobj;
17329 fail:
17330 return NULL;
17331 }
17332
17333
17334 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17335 PyObject *resultobj;
17336 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17337 long arg2 ;
17338 PyObject *result;
17339 PyObject * obj0 = 0 ;
17340 PyObject * obj1 = 0 ;
17341 char *kwnames[] = {
17342 (char *) "self",(char *) "index", NULL
17343 };
17344
17345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17347 if (SWIG_arg_fail(1)) SWIG_fail;
17348 {
17349 arg2 = (long)(SWIG_As_long(obj1));
17350 if (SWIG_arg_fail(2)) SWIG_fail;
17351 }
17352 {
17353 PyThreadState* __tstate = wxPyBeginAllowThreads();
17354 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17355
17356 wxPyEndAllowThreads(__tstate);
17357 if (PyErr_Occurred()) SWIG_fail;
17358 }
17359 resultobj = result;
17360 return resultobj;
17361 fail:
17362 return NULL;
17363 }
17364
17365
17366 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17367 PyObject *resultobj;
17368 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17369 bool arg2 = (bool) false ;
17370 size_t result;
17371 PyObject * obj0 = 0 ;
17372 PyObject * obj1 = 0 ;
17373 char *kwnames[] = {
17374 (char *) "self",(char *) "recursive", NULL
17375 };
17376
17377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17379 if (SWIG_arg_fail(1)) SWIG_fail;
17380 if (obj1) {
17381 {
17382 arg2 = (bool)(SWIG_As_bool(obj1));
17383 if (SWIG_arg_fail(2)) SWIG_fail;
17384 }
17385 }
17386 {
17387 PyThreadState* __tstate = wxPyBeginAllowThreads();
17388 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17389
17390 wxPyEndAllowThreads(__tstate);
17391 if (PyErr_Occurred()) SWIG_fail;
17392 }
17393 {
17394 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17395 }
17396 return resultobj;
17397 fail:
17398 return NULL;
17399 }
17400
17401
17402 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17403 PyObject *resultobj;
17404 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17405 bool arg2 = (bool) false ;
17406 size_t result;
17407 PyObject * obj0 = 0 ;
17408 PyObject * obj1 = 0 ;
17409 char *kwnames[] = {
17410 (char *) "self",(char *) "recursive", NULL
17411 };
17412
17413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17415 if (SWIG_arg_fail(1)) SWIG_fail;
17416 if (obj1) {
17417 {
17418 arg2 = (bool)(SWIG_As_bool(obj1));
17419 if (SWIG_arg_fail(2)) SWIG_fail;
17420 }
17421 }
17422 {
17423 PyThreadState* __tstate = wxPyBeginAllowThreads();
17424 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17425
17426 wxPyEndAllowThreads(__tstate);
17427 if (PyErr_Occurred()) SWIG_fail;
17428 }
17429 {
17430 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17431 }
17432 return resultobj;
17433 fail:
17434 return NULL;
17435 }
17436
17437
17438 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17439 PyObject *resultobj;
17440 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17441 wxString *arg2 = 0 ;
17442 bool result;
17443 bool temp2 = false ;
17444 PyObject * obj0 = 0 ;
17445 PyObject * obj1 = 0 ;
17446 char *kwnames[] = {
17447 (char *) "self",(char *) "name", NULL
17448 };
17449
17450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17452 if (SWIG_arg_fail(1)) SWIG_fail;
17453 {
17454 arg2 = wxString_in_helper(obj1);
17455 if (arg2 == NULL) SWIG_fail;
17456 temp2 = true;
17457 }
17458 {
17459 PyThreadState* __tstate = wxPyBeginAllowThreads();
17460 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17461
17462 wxPyEndAllowThreads(__tstate);
17463 if (PyErr_Occurred()) SWIG_fail;
17464 }
17465 {
17466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17467 }
17468 {
17469 if (temp2)
17470 delete arg2;
17471 }
17472 return resultobj;
17473 fail:
17474 {
17475 if (temp2)
17476 delete arg2;
17477 }
17478 return NULL;
17479 }
17480
17481
17482 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17483 PyObject *resultobj;
17484 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17485 wxString *arg2 = 0 ;
17486 bool result;
17487 bool temp2 = false ;
17488 PyObject * obj0 = 0 ;
17489 PyObject * obj1 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self",(char *) "name", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 arg2 = wxString_in_helper(obj1);
17499 if (arg2 == NULL) SWIG_fail;
17500 temp2 = true;
17501 }
17502 {
17503 PyThreadState* __tstate = wxPyBeginAllowThreads();
17504 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17505
17506 wxPyEndAllowThreads(__tstate);
17507 if (PyErr_Occurred()) SWIG_fail;
17508 }
17509 {
17510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17511 }
17512 {
17513 if (temp2)
17514 delete arg2;
17515 }
17516 return resultobj;
17517 fail:
17518 {
17519 if (temp2)
17520 delete arg2;
17521 }
17522 return NULL;
17523 }
17524
17525
17526 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17527 PyObject *resultobj;
17528 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17529 wxString *arg2 = 0 ;
17530 bool result;
17531 bool temp2 = false ;
17532 PyObject * obj0 = 0 ;
17533 PyObject * obj1 = 0 ;
17534 char *kwnames[] = {
17535 (char *) "self",(char *) "name", NULL
17536 };
17537
17538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17540 if (SWIG_arg_fail(1)) SWIG_fail;
17541 {
17542 arg2 = wxString_in_helper(obj1);
17543 if (arg2 == NULL) SWIG_fail;
17544 temp2 = true;
17545 }
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17549
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 {
17554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17555 }
17556 {
17557 if (temp2)
17558 delete arg2;
17559 }
17560 return resultobj;
17561 fail:
17562 {
17563 if (temp2)
17564 delete arg2;
17565 }
17566 return NULL;
17567 }
17568
17569
17570 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17571 PyObject *resultobj;
17572 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17573 wxString *arg2 = 0 ;
17574 wxConfigBase::EntryType result;
17575 bool temp2 = false ;
17576 PyObject * obj0 = 0 ;
17577 PyObject * obj1 = 0 ;
17578 char *kwnames[] = {
17579 (char *) "self",(char *) "name", NULL
17580 };
17581
17582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) 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 {
17591 PyThreadState* __tstate = wxPyBeginAllowThreads();
17592 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17593
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 resultobj = SWIG_From_int((result));
17598 {
17599 if (temp2)
17600 delete arg2;
17601 }
17602 return resultobj;
17603 fail:
17604 {
17605 if (temp2)
17606 delete arg2;
17607 }
17608 return NULL;
17609 }
17610
17611
17612 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17613 PyObject *resultobj;
17614 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17615 wxString *arg2 = 0 ;
17616 wxString const &arg3_defvalue = wxPyEmptyString ;
17617 wxString *arg3 = (wxString *) &arg3_defvalue ;
17618 wxString result;
17619 bool temp2 = false ;
17620 bool temp3 = false ;
17621 PyObject * obj0 = 0 ;
17622 PyObject * obj1 = 0 ;
17623 PyObject * obj2 = 0 ;
17624 char *kwnames[] = {
17625 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17626 };
17627
17628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17630 if (SWIG_arg_fail(1)) SWIG_fail;
17631 {
17632 arg2 = wxString_in_helper(obj1);
17633 if (arg2 == NULL) SWIG_fail;
17634 temp2 = true;
17635 }
17636 if (obj2) {
17637 {
17638 arg3 = wxString_in_helper(obj2);
17639 if (arg3 == NULL) SWIG_fail;
17640 temp3 = true;
17641 }
17642 }
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17646
17647 wxPyEndAllowThreads(__tstate);
17648 if (PyErr_Occurred()) SWIG_fail;
17649 }
17650 {
17651 #if wxUSE_UNICODE
17652 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17653 #else
17654 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17655 #endif
17656 }
17657 {
17658 if (temp2)
17659 delete arg2;
17660 }
17661 {
17662 if (temp3)
17663 delete arg3;
17664 }
17665 return resultobj;
17666 fail:
17667 {
17668 if (temp2)
17669 delete arg2;
17670 }
17671 {
17672 if (temp3)
17673 delete arg3;
17674 }
17675 return NULL;
17676 }
17677
17678
17679 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17680 PyObject *resultobj;
17681 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17682 wxString *arg2 = 0 ;
17683 long arg3 = (long) 0 ;
17684 long result;
17685 bool temp2 = false ;
17686 PyObject * obj0 = 0 ;
17687 PyObject * obj1 = 0 ;
17688 PyObject * obj2 = 0 ;
17689 char *kwnames[] = {
17690 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17691 };
17692
17693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17695 if (SWIG_arg_fail(1)) SWIG_fail;
17696 {
17697 arg2 = wxString_in_helper(obj1);
17698 if (arg2 == NULL) SWIG_fail;
17699 temp2 = true;
17700 }
17701 if (obj2) {
17702 {
17703 arg3 = (long)(SWIG_As_long(obj2));
17704 if (SWIG_arg_fail(3)) SWIG_fail;
17705 }
17706 }
17707 {
17708 PyThreadState* __tstate = wxPyBeginAllowThreads();
17709 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17710
17711 wxPyEndAllowThreads(__tstate);
17712 if (PyErr_Occurred()) SWIG_fail;
17713 }
17714 {
17715 resultobj = SWIG_From_long((long)(result));
17716 }
17717 {
17718 if (temp2)
17719 delete arg2;
17720 }
17721 return resultobj;
17722 fail:
17723 {
17724 if (temp2)
17725 delete arg2;
17726 }
17727 return NULL;
17728 }
17729
17730
17731 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17732 PyObject *resultobj;
17733 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17734 wxString *arg2 = 0 ;
17735 double arg3 = (double) 0.0 ;
17736 double result;
17737 bool temp2 = false ;
17738 PyObject * obj0 = 0 ;
17739 PyObject * obj1 = 0 ;
17740 PyObject * obj2 = 0 ;
17741 char *kwnames[] = {
17742 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17743 };
17744
17745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17747 if (SWIG_arg_fail(1)) SWIG_fail;
17748 {
17749 arg2 = wxString_in_helper(obj1);
17750 if (arg2 == NULL) SWIG_fail;
17751 temp2 = true;
17752 }
17753 if (obj2) {
17754 {
17755 arg3 = (double)(SWIG_As_double(obj2));
17756 if (SWIG_arg_fail(3)) SWIG_fail;
17757 }
17758 }
17759 {
17760 PyThreadState* __tstate = wxPyBeginAllowThreads();
17761 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17762
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 {
17767 resultobj = SWIG_From_double((double)(result));
17768 }
17769 {
17770 if (temp2)
17771 delete arg2;
17772 }
17773 return resultobj;
17774 fail:
17775 {
17776 if (temp2)
17777 delete arg2;
17778 }
17779 return NULL;
17780 }
17781
17782
17783 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17784 PyObject *resultobj;
17785 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17786 wxString *arg2 = 0 ;
17787 bool arg3 = (bool) false ;
17788 bool result;
17789 bool temp2 = false ;
17790 PyObject * obj0 = 0 ;
17791 PyObject * obj1 = 0 ;
17792 PyObject * obj2 = 0 ;
17793 char *kwnames[] = {
17794 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17795 };
17796
17797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17799 if (SWIG_arg_fail(1)) SWIG_fail;
17800 {
17801 arg2 = wxString_in_helper(obj1);
17802 if (arg2 == NULL) SWIG_fail;
17803 temp2 = true;
17804 }
17805 if (obj2) {
17806 {
17807 arg3 = (bool)(SWIG_As_bool(obj2));
17808 if (SWIG_arg_fail(3)) SWIG_fail;
17809 }
17810 }
17811 {
17812 PyThreadState* __tstate = wxPyBeginAllowThreads();
17813 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17814
17815 wxPyEndAllowThreads(__tstate);
17816 if (PyErr_Occurred()) SWIG_fail;
17817 }
17818 {
17819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17820 }
17821 {
17822 if (temp2)
17823 delete arg2;
17824 }
17825 return resultobj;
17826 fail:
17827 {
17828 if (temp2)
17829 delete arg2;
17830 }
17831 return NULL;
17832 }
17833
17834
17835 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj;
17837 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17838 wxString *arg2 = 0 ;
17839 wxString *arg3 = 0 ;
17840 bool result;
17841 bool temp2 = false ;
17842 bool temp3 = false ;
17843 PyObject * obj0 = 0 ;
17844 PyObject * obj1 = 0 ;
17845 PyObject * obj2 = 0 ;
17846 char *kwnames[] = {
17847 (char *) "self",(char *) "key",(char *) "value", NULL
17848 };
17849
17850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17852 if (SWIG_arg_fail(1)) SWIG_fail;
17853 {
17854 arg2 = wxString_in_helper(obj1);
17855 if (arg2 == NULL) SWIG_fail;
17856 temp2 = true;
17857 }
17858 {
17859 arg3 = wxString_in_helper(obj2);
17860 if (arg3 == NULL) SWIG_fail;
17861 temp3 = true;
17862 }
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17866
17867 wxPyEndAllowThreads(__tstate);
17868 if (PyErr_Occurred()) SWIG_fail;
17869 }
17870 {
17871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17872 }
17873 {
17874 if (temp2)
17875 delete arg2;
17876 }
17877 {
17878 if (temp3)
17879 delete arg3;
17880 }
17881 return resultobj;
17882 fail:
17883 {
17884 if (temp2)
17885 delete arg2;
17886 }
17887 {
17888 if (temp3)
17889 delete arg3;
17890 }
17891 return NULL;
17892 }
17893
17894
17895 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17896 PyObject *resultobj;
17897 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17898 wxString *arg2 = 0 ;
17899 long arg3 ;
17900 bool result;
17901 bool temp2 = false ;
17902 PyObject * obj0 = 0 ;
17903 PyObject * obj1 = 0 ;
17904 PyObject * obj2 = 0 ;
17905 char *kwnames[] = {
17906 (char *) "self",(char *) "key",(char *) "value", NULL
17907 };
17908
17909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17911 if (SWIG_arg_fail(1)) SWIG_fail;
17912 {
17913 arg2 = wxString_in_helper(obj1);
17914 if (arg2 == NULL) SWIG_fail;
17915 temp2 = true;
17916 }
17917 {
17918 arg3 = (long)(SWIG_As_long(obj2));
17919 if (SWIG_arg_fail(3)) SWIG_fail;
17920 }
17921 {
17922 PyThreadState* __tstate = wxPyBeginAllowThreads();
17923 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17924
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 {
17929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17930 }
17931 {
17932 if (temp2)
17933 delete arg2;
17934 }
17935 return resultobj;
17936 fail:
17937 {
17938 if (temp2)
17939 delete arg2;
17940 }
17941 return NULL;
17942 }
17943
17944
17945 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17946 PyObject *resultobj;
17947 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17948 wxString *arg2 = 0 ;
17949 double arg3 ;
17950 bool result;
17951 bool temp2 = false ;
17952 PyObject * obj0 = 0 ;
17953 PyObject * obj1 = 0 ;
17954 PyObject * obj2 = 0 ;
17955 char *kwnames[] = {
17956 (char *) "self",(char *) "key",(char *) "value", NULL
17957 };
17958
17959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17961 if (SWIG_arg_fail(1)) SWIG_fail;
17962 {
17963 arg2 = wxString_in_helper(obj1);
17964 if (arg2 == NULL) SWIG_fail;
17965 temp2 = true;
17966 }
17967 {
17968 arg3 = (double)(SWIG_As_double(obj2));
17969 if (SWIG_arg_fail(3)) SWIG_fail;
17970 }
17971 {
17972 PyThreadState* __tstate = wxPyBeginAllowThreads();
17973 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17974
17975 wxPyEndAllowThreads(__tstate);
17976 if (PyErr_Occurred()) SWIG_fail;
17977 }
17978 {
17979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17980 }
17981 {
17982 if (temp2)
17983 delete arg2;
17984 }
17985 return resultobj;
17986 fail:
17987 {
17988 if (temp2)
17989 delete arg2;
17990 }
17991 return NULL;
17992 }
17993
17994
17995 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17996 PyObject *resultobj;
17997 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17998 wxString *arg2 = 0 ;
17999 bool arg3 ;
18000 bool result;
18001 bool temp2 = false ;
18002 PyObject * obj0 = 0 ;
18003 PyObject * obj1 = 0 ;
18004 PyObject * obj2 = 0 ;
18005 char *kwnames[] = {
18006 (char *) "self",(char *) "key",(char *) "value", NULL
18007 };
18008
18009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18011 if (SWIG_arg_fail(1)) SWIG_fail;
18012 {
18013 arg2 = wxString_in_helper(obj1);
18014 if (arg2 == NULL) SWIG_fail;
18015 temp2 = true;
18016 }
18017 {
18018 arg3 = (bool)(SWIG_As_bool(obj2));
18019 if (SWIG_arg_fail(3)) SWIG_fail;
18020 }
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18024
18025 wxPyEndAllowThreads(__tstate);
18026 if (PyErr_Occurred()) SWIG_fail;
18027 }
18028 {
18029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18030 }
18031 {
18032 if (temp2)
18033 delete arg2;
18034 }
18035 return resultobj;
18036 fail:
18037 {
18038 if (temp2)
18039 delete arg2;
18040 }
18041 return NULL;
18042 }
18043
18044
18045 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
18046 PyObject *resultobj;
18047 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18048 bool arg2 = (bool) false ;
18049 bool result;
18050 PyObject * obj0 = 0 ;
18051 PyObject * obj1 = 0 ;
18052 char *kwnames[] = {
18053 (char *) "self",(char *) "currentOnly", NULL
18054 };
18055
18056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
18057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18058 if (SWIG_arg_fail(1)) SWIG_fail;
18059 if (obj1) {
18060 {
18061 arg2 = (bool)(SWIG_As_bool(obj1));
18062 if (SWIG_arg_fail(2)) SWIG_fail;
18063 }
18064 }
18065 {
18066 PyThreadState* __tstate = wxPyBeginAllowThreads();
18067 result = (bool)(arg1)->Flush(arg2);
18068
18069 wxPyEndAllowThreads(__tstate);
18070 if (PyErr_Occurred()) SWIG_fail;
18071 }
18072 {
18073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18074 }
18075 return resultobj;
18076 fail:
18077 return NULL;
18078 }
18079
18080
18081 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18082 PyObject *resultobj;
18083 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18084 wxString *arg2 = 0 ;
18085 wxString *arg3 = 0 ;
18086 bool result;
18087 bool temp2 = false ;
18088 bool temp3 = false ;
18089 PyObject * obj0 = 0 ;
18090 PyObject * obj1 = 0 ;
18091 PyObject * obj2 = 0 ;
18092 char *kwnames[] = {
18093 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18094 };
18095
18096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18098 if (SWIG_arg_fail(1)) SWIG_fail;
18099 {
18100 arg2 = wxString_in_helper(obj1);
18101 if (arg2 == NULL) SWIG_fail;
18102 temp2 = true;
18103 }
18104 {
18105 arg3 = wxString_in_helper(obj2);
18106 if (arg3 == NULL) SWIG_fail;
18107 temp3 = true;
18108 }
18109 {
18110 PyThreadState* __tstate = wxPyBeginAllowThreads();
18111 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18112
18113 wxPyEndAllowThreads(__tstate);
18114 if (PyErr_Occurred()) SWIG_fail;
18115 }
18116 {
18117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18118 }
18119 {
18120 if (temp2)
18121 delete arg2;
18122 }
18123 {
18124 if (temp3)
18125 delete arg3;
18126 }
18127 return resultobj;
18128 fail:
18129 {
18130 if (temp2)
18131 delete arg2;
18132 }
18133 {
18134 if (temp3)
18135 delete arg3;
18136 }
18137 return NULL;
18138 }
18139
18140
18141 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18142 PyObject *resultobj;
18143 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18144 wxString *arg2 = 0 ;
18145 wxString *arg3 = 0 ;
18146 bool result;
18147 bool temp2 = false ;
18148 bool temp3 = false ;
18149 PyObject * obj0 = 0 ;
18150 PyObject * obj1 = 0 ;
18151 PyObject * obj2 = 0 ;
18152 char *kwnames[] = {
18153 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18154 };
18155
18156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18158 if (SWIG_arg_fail(1)) SWIG_fail;
18159 {
18160 arg2 = wxString_in_helper(obj1);
18161 if (arg2 == NULL) SWIG_fail;
18162 temp2 = true;
18163 }
18164 {
18165 arg3 = wxString_in_helper(obj2);
18166 if (arg3 == NULL) SWIG_fail;
18167 temp3 = true;
18168 }
18169 {
18170 PyThreadState* __tstate = wxPyBeginAllowThreads();
18171 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18172
18173 wxPyEndAllowThreads(__tstate);
18174 if (PyErr_Occurred()) SWIG_fail;
18175 }
18176 {
18177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18178 }
18179 {
18180 if (temp2)
18181 delete arg2;
18182 }
18183 {
18184 if (temp3)
18185 delete arg3;
18186 }
18187 return resultobj;
18188 fail:
18189 {
18190 if (temp2)
18191 delete arg2;
18192 }
18193 {
18194 if (temp3)
18195 delete arg3;
18196 }
18197 return NULL;
18198 }
18199
18200
18201 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18202 PyObject *resultobj;
18203 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18204 wxString *arg2 = 0 ;
18205 bool arg3 = (bool) true ;
18206 bool result;
18207 bool temp2 = false ;
18208 PyObject * obj0 = 0 ;
18209 PyObject * obj1 = 0 ;
18210 PyObject * obj2 = 0 ;
18211 char *kwnames[] = {
18212 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18213 };
18214
18215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18217 if (SWIG_arg_fail(1)) SWIG_fail;
18218 {
18219 arg2 = wxString_in_helper(obj1);
18220 if (arg2 == NULL) SWIG_fail;
18221 temp2 = true;
18222 }
18223 if (obj2) {
18224 {
18225 arg3 = (bool)(SWIG_As_bool(obj2));
18226 if (SWIG_arg_fail(3)) SWIG_fail;
18227 }
18228 }
18229 {
18230 PyThreadState* __tstate = wxPyBeginAllowThreads();
18231 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18232
18233 wxPyEndAllowThreads(__tstate);
18234 if (PyErr_Occurred()) SWIG_fail;
18235 }
18236 {
18237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18238 }
18239 {
18240 if (temp2)
18241 delete arg2;
18242 }
18243 return resultobj;
18244 fail:
18245 {
18246 if (temp2)
18247 delete arg2;
18248 }
18249 return NULL;
18250 }
18251
18252
18253 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18254 PyObject *resultobj;
18255 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18256 wxString *arg2 = 0 ;
18257 bool result;
18258 bool temp2 = false ;
18259 PyObject * obj0 = 0 ;
18260 PyObject * obj1 = 0 ;
18261 char *kwnames[] = {
18262 (char *) "self",(char *) "key", NULL
18263 };
18264
18265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18267 if (SWIG_arg_fail(1)) SWIG_fail;
18268 {
18269 arg2 = wxString_in_helper(obj1);
18270 if (arg2 == NULL) SWIG_fail;
18271 temp2 = true;
18272 }
18273 {
18274 PyThreadState* __tstate = wxPyBeginAllowThreads();
18275 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18276
18277 wxPyEndAllowThreads(__tstate);
18278 if (PyErr_Occurred()) SWIG_fail;
18279 }
18280 {
18281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18282 }
18283 {
18284 if (temp2)
18285 delete arg2;
18286 }
18287 return resultobj;
18288 fail:
18289 {
18290 if (temp2)
18291 delete arg2;
18292 }
18293 return NULL;
18294 }
18295
18296
18297 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18298 PyObject *resultobj;
18299 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18300 bool result;
18301 PyObject * obj0 = 0 ;
18302 char *kwnames[] = {
18303 (char *) "self", NULL
18304 };
18305
18306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18308 if (SWIG_arg_fail(1)) SWIG_fail;
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 result = (bool)(arg1)->DeleteAll();
18312
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 {
18317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18318 }
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18326 PyObject *resultobj;
18327 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18328 bool arg2 = (bool) true ;
18329 PyObject * obj0 = 0 ;
18330 PyObject * obj1 = 0 ;
18331 char *kwnames[] = {
18332 (char *) "self",(char *) "doIt", NULL
18333 };
18334
18335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18337 if (SWIG_arg_fail(1)) SWIG_fail;
18338 if (obj1) {
18339 {
18340 arg2 = (bool)(SWIG_As_bool(obj1));
18341 if (SWIG_arg_fail(2)) SWIG_fail;
18342 }
18343 }
18344 {
18345 PyThreadState* __tstate = wxPyBeginAllowThreads();
18346 (arg1)->SetExpandEnvVars(arg2);
18347
18348 wxPyEndAllowThreads(__tstate);
18349 if (PyErr_Occurred()) SWIG_fail;
18350 }
18351 Py_INCREF(Py_None); resultobj = Py_None;
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18359 PyObject *resultobj;
18360 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18361 bool result;
18362 PyObject * obj0 = 0 ;
18363 char *kwnames[] = {
18364 (char *) "self", NULL
18365 };
18366
18367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18369 if (SWIG_arg_fail(1)) SWIG_fail;
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18373
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 {
18378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18379 }
18380 return resultobj;
18381 fail:
18382 return NULL;
18383 }
18384
18385
18386 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18387 PyObject *resultobj;
18388 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18389 bool arg2 = (bool) true ;
18390 PyObject * obj0 = 0 ;
18391 PyObject * obj1 = 0 ;
18392 char *kwnames[] = {
18393 (char *) "self",(char *) "doIt", NULL
18394 };
18395
18396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18398 if (SWIG_arg_fail(1)) SWIG_fail;
18399 if (obj1) {
18400 {
18401 arg2 = (bool)(SWIG_As_bool(obj1));
18402 if (SWIG_arg_fail(2)) SWIG_fail;
18403 }
18404 }
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 (arg1)->SetRecordDefaults(arg2);
18408
18409 wxPyEndAllowThreads(__tstate);
18410 if (PyErr_Occurred()) SWIG_fail;
18411 }
18412 Py_INCREF(Py_None); resultobj = Py_None;
18413 return resultobj;
18414 fail:
18415 return NULL;
18416 }
18417
18418
18419 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18420 PyObject *resultobj;
18421 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18422 bool result;
18423 PyObject * obj0 = 0 ;
18424 char *kwnames[] = {
18425 (char *) "self", NULL
18426 };
18427
18428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18430 if (SWIG_arg_fail(1)) SWIG_fail;
18431 {
18432 PyThreadState* __tstate = wxPyBeginAllowThreads();
18433 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18434
18435 wxPyEndAllowThreads(__tstate);
18436 if (PyErr_Occurred()) SWIG_fail;
18437 }
18438 {
18439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18440 }
18441 return resultobj;
18442 fail:
18443 return NULL;
18444 }
18445
18446
18447 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18448 PyObject *resultobj;
18449 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18450 wxString *arg2 = 0 ;
18451 wxString result;
18452 bool temp2 = false ;
18453 PyObject * obj0 = 0 ;
18454 PyObject * obj1 = 0 ;
18455 char *kwnames[] = {
18456 (char *) "self",(char *) "str", NULL
18457 };
18458
18459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",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 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18470
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 {
18475 #if wxUSE_UNICODE
18476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18477 #else
18478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18479 #endif
18480 }
18481 {
18482 if (temp2)
18483 delete arg2;
18484 }
18485 return resultobj;
18486 fail:
18487 {
18488 if (temp2)
18489 delete arg2;
18490 }
18491 return NULL;
18492 }
18493
18494
18495 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18496 PyObject *resultobj;
18497 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18498 wxString result;
18499 PyObject * obj0 = 0 ;
18500 char *kwnames[] = {
18501 (char *) "self", NULL
18502 };
18503
18504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18506 if (SWIG_arg_fail(1)) SWIG_fail;
18507 {
18508 PyThreadState* __tstate = wxPyBeginAllowThreads();
18509 result = ((wxConfigBase const *)arg1)->GetAppName();
18510
18511 wxPyEndAllowThreads(__tstate);
18512 if (PyErr_Occurred()) SWIG_fail;
18513 }
18514 {
18515 #if wxUSE_UNICODE
18516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18517 #else
18518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18519 #endif
18520 }
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj;
18529 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18530 wxString result;
18531 PyObject * obj0 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "self", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18538 if (SWIG_arg_fail(1)) SWIG_fail;
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 result = ((wxConfigBase const *)arg1)->GetVendorName();
18542
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 {
18547 #if wxUSE_UNICODE
18548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18549 #else
18550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18551 #endif
18552 }
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj;
18561 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18562 wxString *arg2 = 0 ;
18563 bool temp2 = false ;
18564 PyObject * obj0 = 0 ;
18565 PyObject * obj1 = 0 ;
18566 char *kwnames[] = {
18567 (char *) "self",(char *) "appName", NULL
18568 };
18569
18570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
18575 if (arg2 == NULL) SWIG_fail;
18576 temp2 = true;
18577 }
18578 {
18579 PyThreadState* __tstate = wxPyBeginAllowThreads();
18580 (arg1)->SetAppName((wxString const &)*arg2);
18581
18582 wxPyEndAllowThreads(__tstate);
18583 if (PyErr_Occurred()) SWIG_fail;
18584 }
18585 Py_INCREF(Py_None); resultobj = Py_None;
18586 {
18587 if (temp2)
18588 delete arg2;
18589 }
18590 return resultobj;
18591 fail:
18592 {
18593 if (temp2)
18594 delete arg2;
18595 }
18596 return NULL;
18597 }
18598
18599
18600 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18601 PyObject *resultobj;
18602 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18603 wxString *arg2 = 0 ;
18604 bool temp2 = false ;
18605 PyObject * obj0 = 0 ;
18606 PyObject * obj1 = 0 ;
18607 char *kwnames[] = {
18608 (char *) "self",(char *) "vendorName", NULL
18609 };
18610
18611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18613 if (SWIG_arg_fail(1)) SWIG_fail;
18614 {
18615 arg2 = wxString_in_helper(obj1);
18616 if (arg2 == NULL) SWIG_fail;
18617 temp2 = true;
18618 }
18619 {
18620 PyThreadState* __tstate = wxPyBeginAllowThreads();
18621 (arg1)->SetVendorName((wxString const &)*arg2);
18622
18623 wxPyEndAllowThreads(__tstate);
18624 if (PyErr_Occurred()) SWIG_fail;
18625 }
18626 Py_INCREF(Py_None); resultobj = Py_None;
18627 {
18628 if (temp2)
18629 delete arg2;
18630 }
18631 return resultobj;
18632 fail:
18633 {
18634 if (temp2)
18635 delete arg2;
18636 }
18637 return NULL;
18638 }
18639
18640
18641 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18642 PyObject *resultobj;
18643 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18644 long arg2 ;
18645 PyObject * obj0 = 0 ;
18646 PyObject * obj1 = 0 ;
18647 char *kwnames[] = {
18648 (char *) "self",(char *) "style", NULL
18649 };
18650
18651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18653 if (SWIG_arg_fail(1)) SWIG_fail;
18654 {
18655 arg2 = (long)(SWIG_As_long(obj1));
18656 if (SWIG_arg_fail(2)) SWIG_fail;
18657 }
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 (arg1)->SetStyle(arg2);
18661
18662 wxPyEndAllowThreads(__tstate);
18663 if (PyErr_Occurred()) SWIG_fail;
18664 }
18665 Py_INCREF(Py_None); resultobj = Py_None;
18666 return resultobj;
18667 fail:
18668 return NULL;
18669 }
18670
18671
18672 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18673 PyObject *resultobj;
18674 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18675 long result;
18676 PyObject * obj0 = 0 ;
18677 char *kwnames[] = {
18678 (char *) "self", NULL
18679 };
18680
18681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18683 if (SWIG_arg_fail(1)) SWIG_fail;
18684 {
18685 PyThreadState* __tstate = wxPyBeginAllowThreads();
18686 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18687
18688 wxPyEndAllowThreads(__tstate);
18689 if (PyErr_Occurred()) SWIG_fail;
18690 }
18691 {
18692 resultobj = SWIG_From_long((long)(result));
18693 }
18694 return resultobj;
18695 fail:
18696 return NULL;
18697 }
18698
18699
18700 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18701 PyObject *obj;
18702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18703 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18704 Py_INCREF(obj);
18705 return Py_BuildValue((char *)"");
18706 }
18707 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18708 PyObject *resultobj;
18709 wxString const &arg1_defvalue = wxPyEmptyString ;
18710 wxString *arg1 = (wxString *) &arg1_defvalue ;
18711 wxString const &arg2_defvalue = wxPyEmptyString ;
18712 wxString *arg2 = (wxString *) &arg2_defvalue ;
18713 wxString const &arg3_defvalue = wxPyEmptyString ;
18714 wxString *arg3 = (wxString *) &arg3_defvalue ;
18715 wxString const &arg4_defvalue = wxPyEmptyString ;
18716 wxString *arg4 = (wxString *) &arg4_defvalue ;
18717 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18718 wxConfig *result;
18719 bool temp1 = false ;
18720 bool temp2 = false ;
18721 bool temp3 = false ;
18722 bool temp4 = false ;
18723 PyObject * obj0 = 0 ;
18724 PyObject * obj1 = 0 ;
18725 PyObject * obj2 = 0 ;
18726 PyObject * obj3 = 0 ;
18727 PyObject * obj4 = 0 ;
18728 char *kwnames[] = {
18729 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18730 };
18731
18732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18733 if (obj0) {
18734 {
18735 arg1 = wxString_in_helper(obj0);
18736 if (arg1 == NULL) SWIG_fail;
18737 temp1 = true;
18738 }
18739 }
18740 if (obj1) {
18741 {
18742 arg2 = wxString_in_helper(obj1);
18743 if (arg2 == NULL) SWIG_fail;
18744 temp2 = true;
18745 }
18746 }
18747 if (obj2) {
18748 {
18749 arg3 = wxString_in_helper(obj2);
18750 if (arg3 == NULL) SWIG_fail;
18751 temp3 = true;
18752 }
18753 }
18754 if (obj3) {
18755 {
18756 arg4 = wxString_in_helper(obj3);
18757 if (arg4 == NULL) SWIG_fail;
18758 temp4 = true;
18759 }
18760 }
18761 if (obj4) {
18762 {
18763 arg5 = (long)(SWIG_As_long(obj4));
18764 if (SWIG_arg_fail(5)) SWIG_fail;
18765 }
18766 }
18767 {
18768 PyThreadState* __tstate = wxPyBeginAllowThreads();
18769 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18770
18771 wxPyEndAllowThreads(__tstate);
18772 if (PyErr_Occurred()) SWIG_fail;
18773 }
18774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18775 {
18776 if (temp1)
18777 delete arg1;
18778 }
18779 {
18780 if (temp2)
18781 delete arg2;
18782 }
18783 {
18784 if (temp3)
18785 delete arg3;
18786 }
18787 {
18788 if (temp4)
18789 delete arg4;
18790 }
18791 return resultobj;
18792 fail:
18793 {
18794 if (temp1)
18795 delete arg1;
18796 }
18797 {
18798 if (temp2)
18799 delete arg2;
18800 }
18801 {
18802 if (temp3)
18803 delete arg3;
18804 }
18805 {
18806 if (temp4)
18807 delete arg4;
18808 }
18809 return NULL;
18810 }
18811
18812
18813 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18814 PyObject *resultobj;
18815 wxConfig *arg1 = (wxConfig *) 0 ;
18816 PyObject * obj0 = 0 ;
18817 char *kwnames[] = {
18818 (char *) "self", NULL
18819 };
18820
18821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18823 if (SWIG_arg_fail(1)) SWIG_fail;
18824 {
18825 PyThreadState* __tstate = wxPyBeginAllowThreads();
18826 delete arg1;
18827
18828 wxPyEndAllowThreads(__tstate);
18829 if (PyErr_Occurred()) SWIG_fail;
18830 }
18831 Py_INCREF(Py_None); resultobj = Py_None;
18832 return resultobj;
18833 fail:
18834 return NULL;
18835 }
18836
18837
18838 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18839 PyObject *obj;
18840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18841 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18842 Py_INCREF(obj);
18843 return Py_BuildValue((char *)"");
18844 }
18845 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18846 PyObject *resultobj;
18847 wxString const &arg1_defvalue = wxPyEmptyString ;
18848 wxString *arg1 = (wxString *) &arg1_defvalue ;
18849 wxString const &arg2_defvalue = wxPyEmptyString ;
18850 wxString *arg2 = (wxString *) &arg2_defvalue ;
18851 wxString const &arg3_defvalue = wxPyEmptyString ;
18852 wxString *arg3 = (wxString *) &arg3_defvalue ;
18853 wxString const &arg4_defvalue = wxPyEmptyString ;
18854 wxString *arg4 = (wxString *) &arg4_defvalue ;
18855 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18856 wxFileConfig *result;
18857 bool temp1 = false ;
18858 bool temp2 = false ;
18859 bool temp3 = false ;
18860 bool temp4 = false ;
18861 PyObject * obj0 = 0 ;
18862 PyObject * obj1 = 0 ;
18863 PyObject * obj2 = 0 ;
18864 PyObject * obj3 = 0 ;
18865 PyObject * obj4 = 0 ;
18866 char *kwnames[] = {
18867 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18868 };
18869
18870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18871 if (obj0) {
18872 {
18873 arg1 = wxString_in_helper(obj0);
18874 if (arg1 == NULL) SWIG_fail;
18875 temp1 = true;
18876 }
18877 }
18878 if (obj1) {
18879 {
18880 arg2 = wxString_in_helper(obj1);
18881 if (arg2 == NULL) SWIG_fail;
18882 temp2 = true;
18883 }
18884 }
18885 if (obj2) {
18886 {
18887 arg3 = wxString_in_helper(obj2);
18888 if (arg3 == NULL) SWIG_fail;
18889 temp3 = true;
18890 }
18891 }
18892 if (obj3) {
18893 {
18894 arg4 = wxString_in_helper(obj3);
18895 if (arg4 == NULL) SWIG_fail;
18896 temp4 = true;
18897 }
18898 }
18899 if (obj4) {
18900 {
18901 arg5 = (long)(SWIG_As_long(obj4));
18902 if (SWIG_arg_fail(5)) SWIG_fail;
18903 }
18904 }
18905 {
18906 PyThreadState* __tstate = wxPyBeginAllowThreads();
18907 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18908
18909 wxPyEndAllowThreads(__tstate);
18910 if (PyErr_Occurred()) SWIG_fail;
18911 }
18912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18913 {
18914 if (temp1)
18915 delete arg1;
18916 }
18917 {
18918 if (temp2)
18919 delete arg2;
18920 }
18921 {
18922 if (temp3)
18923 delete arg3;
18924 }
18925 {
18926 if (temp4)
18927 delete arg4;
18928 }
18929 return resultobj;
18930 fail:
18931 {
18932 if (temp1)
18933 delete arg1;
18934 }
18935 {
18936 if (temp2)
18937 delete arg2;
18938 }
18939 {
18940 if (temp3)
18941 delete arg3;
18942 }
18943 {
18944 if (temp4)
18945 delete arg4;
18946 }
18947 return NULL;
18948 }
18949
18950
18951 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18952 PyObject *resultobj;
18953 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18954 PyObject * obj0 = 0 ;
18955 char *kwnames[] = {
18956 (char *) "self", NULL
18957 };
18958
18959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18961 if (SWIG_arg_fail(1)) SWIG_fail;
18962 {
18963 PyThreadState* __tstate = wxPyBeginAllowThreads();
18964 delete arg1;
18965
18966 wxPyEndAllowThreads(__tstate);
18967 if (PyErr_Occurred()) SWIG_fail;
18968 }
18969 Py_INCREF(Py_None); resultobj = Py_None;
18970 return resultobj;
18971 fail:
18972 return NULL;
18973 }
18974
18975
18976 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18977 PyObject *obj;
18978 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18979 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18980 Py_INCREF(obj);
18981 return Py_BuildValue((char *)"");
18982 }
18983 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18984 PyObject *resultobj;
18985 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18986 wxString *arg2 = 0 ;
18987 wxConfigPathChanger *result;
18988 bool temp2 = false ;
18989 PyObject * obj0 = 0 ;
18990 PyObject * obj1 = 0 ;
18991 char *kwnames[] = {
18992 (char *) "config",(char *) "entry", NULL
18993 };
18994
18995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18997 if (SWIG_arg_fail(1)) SWIG_fail;
18998 {
18999 arg2 = wxString_in_helper(obj1);
19000 if (arg2 == NULL) SWIG_fail;
19001 temp2 = true;
19002 }
19003 {
19004 PyThreadState* __tstate = wxPyBeginAllowThreads();
19005 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
19006
19007 wxPyEndAllowThreads(__tstate);
19008 if (PyErr_Occurred()) SWIG_fail;
19009 }
19010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
19011 {
19012 if (temp2)
19013 delete arg2;
19014 }
19015 return resultobj;
19016 fail:
19017 {
19018 if (temp2)
19019 delete arg2;
19020 }
19021 return NULL;
19022 }
19023
19024
19025 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19026 PyObject *resultobj;
19027 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19028 PyObject * obj0 = 0 ;
19029 char *kwnames[] = {
19030 (char *) "self", NULL
19031 };
19032
19033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
19034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19035 if (SWIG_arg_fail(1)) SWIG_fail;
19036 {
19037 PyThreadState* __tstate = wxPyBeginAllowThreads();
19038 delete arg1;
19039
19040 wxPyEndAllowThreads(__tstate);
19041 if (PyErr_Occurred()) SWIG_fail;
19042 }
19043 Py_INCREF(Py_None); resultobj = Py_None;
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj;
19052 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19053 wxString *result;
19054 PyObject * obj0 = 0 ;
19055 char *kwnames[] = {
19056 (char *) "self", NULL
19057 };
19058
19059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
19060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19061 if (SWIG_arg_fail(1)) SWIG_fail;
19062 {
19063 PyThreadState* __tstate = wxPyBeginAllowThreads();
19064 {
19065 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
19066 result = (wxString *) &_result_ref;
19067 }
19068
19069 wxPyEndAllowThreads(__tstate);
19070 if (PyErr_Occurred()) SWIG_fail;
19071 }
19072 {
19073 #if wxUSE_UNICODE
19074 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19075 #else
19076 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19077 #endif
19078 }
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
19086 PyObject *obj;
19087 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19088 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
19089 Py_INCREF(obj);
19090 return Py_BuildValue((char *)"");
19091 }
19092 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19093 PyObject *resultobj;
19094 wxString *arg1 = 0 ;
19095 wxString result;
19096 bool temp1 = false ;
19097 PyObject * obj0 = 0 ;
19098 char *kwnames[] = {
19099 (char *) "sz", NULL
19100 };
19101
19102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19103 {
19104 arg1 = wxString_in_helper(obj0);
19105 if (arg1 == NULL) SWIG_fail;
19106 temp1 = true;
19107 }
19108 {
19109 PyThreadState* __tstate = wxPyBeginAllowThreads();
19110 result = wxExpandEnvVars((wxString const &)*arg1);
19111
19112 wxPyEndAllowThreads(__tstate);
19113 if (PyErr_Occurred()) SWIG_fail;
19114 }
19115 {
19116 #if wxUSE_UNICODE
19117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19118 #else
19119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19120 #endif
19121 }
19122 {
19123 if (temp1)
19124 delete arg1;
19125 }
19126 return resultobj;
19127 fail:
19128 {
19129 if (temp1)
19130 delete arg1;
19131 }
19132 return NULL;
19133 }
19134
19135
19136 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19137 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19138 return 1;
19139 }
19140
19141
19142 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19143 PyObject *pyobj;
19144
19145 {
19146 #if wxUSE_UNICODE
19147 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19148 #else
19149 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19150 #endif
19151 }
19152 return pyobj;
19153 }
19154
19155
19156 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19157 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19158 return 1;
19159 }
19160
19161
19162 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19163 PyObject *pyobj;
19164
19165 {
19166 #if wxUSE_UNICODE
19167 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19168 #else
19169 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19170 #endif
19171 }
19172 return pyobj;
19173 }
19174
19175
19176 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19177 PyObject *resultobj;
19178 wxDateTime::Country arg1 ;
19179 PyObject * obj0 = 0 ;
19180 char *kwnames[] = {
19181 (char *) "country", NULL
19182 };
19183
19184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19185 {
19186 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19187 if (SWIG_arg_fail(1)) SWIG_fail;
19188 }
19189 {
19190 PyThreadState* __tstate = wxPyBeginAllowThreads();
19191 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19192
19193 wxPyEndAllowThreads(__tstate);
19194 if (PyErr_Occurred()) SWIG_fail;
19195 }
19196 Py_INCREF(Py_None); resultobj = Py_None;
19197 return resultobj;
19198 fail:
19199 return NULL;
19200 }
19201
19202
19203 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19204 PyObject *resultobj;
19205 wxDateTime::Country result;
19206 char *kwnames[] = {
19207 NULL
19208 };
19209
19210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19211 {
19212 PyThreadState* __tstate = wxPyBeginAllowThreads();
19213 result = (wxDateTime::Country)wxDateTime::GetCountry();
19214
19215 wxPyEndAllowThreads(__tstate);
19216 if (PyErr_Occurred()) SWIG_fail;
19217 }
19218 resultobj = SWIG_From_int((result));
19219 return resultobj;
19220 fail:
19221 return NULL;
19222 }
19223
19224
19225 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19226 PyObject *resultobj;
19227 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19228 bool result;
19229 PyObject * obj0 = 0 ;
19230 char *kwnames[] = {
19231 (char *) "country", NULL
19232 };
19233
19234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19235 if (obj0) {
19236 {
19237 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19238 if (SWIG_arg_fail(1)) SWIG_fail;
19239 }
19240 }
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19244
19245 wxPyEndAllowThreads(__tstate);
19246 if (PyErr_Occurred()) SWIG_fail;
19247 }
19248 {
19249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19250 }
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19258 PyObject *resultobj;
19259 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19260 int result;
19261 PyObject * obj0 = 0 ;
19262 char *kwnames[] = {
19263 (char *) "cal", NULL
19264 };
19265
19266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19267 if (obj0) {
19268 {
19269 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19270 if (SWIG_arg_fail(1)) SWIG_fail;
19271 }
19272 }
19273 {
19274 PyThreadState* __tstate = wxPyBeginAllowThreads();
19275 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19276
19277 wxPyEndAllowThreads(__tstate);
19278 if (PyErr_Occurred()) SWIG_fail;
19279 }
19280 {
19281 resultobj = SWIG_From_int((int)(result));
19282 }
19283 return resultobj;
19284 fail:
19285 return NULL;
19286 }
19287
19288
19289 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19290 PyObject *resultobj;
19291 int arg1 ;
19292 int result;
19293 PyObject * obj0 = 0 ;
19294 char *kwnames[] = {
19295 (char *) "year", NULL
19296 };
19297
19298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19299 {
19300 arg1 = (int)(SWIG_As_int(obj0));
19301 if (SWIG_arg_fail(1)) SWIG_fail;
19302 }
19303 {
19304 PyThreadState* __tstate = wxPyBeginAllowThreads();
19305 result = (int)wxDateTime::ConvertYearToBC(arg1);
19306
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 {
19311 resultobj = SWIG_From_int((int)(result));
19312 }
19313 return resultobj;
19314 fail:
19315 return NULL;
19316 }
19317
19318
19319 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19320 PyObject *resultobj;
19321 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19322 wxDateTime::Month result;
19323 PyObject * obj0 = 0 ;
19324 char *kwnames[] = {
19325 (char *) "cal", NULL
19326 };
19327
19328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19329 if (obj0) {
19330 {
19331 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19332 if (SWIG_arg_fail(1)) SWIG_fail;
19333 }
19334 }
19335 {
19336 PyThreadState* __tstate = wxPyBeginAllowThreads();
19337 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19338
19339 wxPyEndAllowThreads(__tstate);
19340 if (PyErr_Occurred()) SWIG_fail;
19341 }
19342 resultobj = SWIG_From_int((result));
19343 return resultobj;
19344 fail:
19345 return NULL;
19346 }
19347
19348
19349 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19350 PyObject *resultobj;
19351 int arg1 = (int) wxDateTime::Inv_Year ;
19352 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19353 bool result;
19354 PyObject * obj0 = 0 ;
19355 PyObject * obj1 = 0 ;
19356 char *kwnames[] = {
19357 (char *) "year",(char *) "cal", NULL
19358 };
19359
19360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19361 if (obj0) {
19362 {
19363 arg1 = (int)(SWIG_As_int(obj0));
19364 if (SWIG_arg_fail(1)) SWIG_fail;
19365 }
19366 }
19367 if (obj1) {
19368 {
19369 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19370 if (SWIG_arg_fail(2)) SWIG_fail;
19371 }
19372 }
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19376
19377 wxPyEndAllowThreads(__tstate);
19378 if (PyErr_Occurred()) SWIG_fail;
19379 }
19380 {
19381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19382 }
19383 return resultobj;
19384 fail:
19385 return NULL;
19386 }
19387
19388
19389 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19390 PyObject *resultobj;
19391 int arg1 = (int) wxDateTime::Inv_Year ;
19392 int result;
19393 PyObject * obj0 = 0 ;
19394 char *kwnames[] = {
19395 (char *) "year", NULL
19396 };
19397
19398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19399 if (obj0) {
19400 {
19401 arg1 = (int)(SWIG_As_int(obj0));
19402 if (SWIG_arg_fail(1)) SWIG_fail;
19403 }
19404 }
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 result = (int)wxDateTime::GetCentury(arg1);
19408
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 {
19413 resultobj = SWIG_From_int((int)(result));
19414 }
19415 return resultobj;
19416 fail:
19417 return NULL;
19418 }
19419
19420
19421 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19422 PyObject *resultobj;
19423 int arg1 ;
19424 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19425 int result;
19426 PyObject * obj0 = 0 ;
19427 PyObject * obj1 = 0 ;
19428 char *kwnames[] = {
19429 (char *) "year",(char *) "cal", NULL
19430 };
19431
19432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19433 {
19434 arg1 = (int)(SWIG_As_int(obj0));
19435 if (SWIG_arg_fail(1)) SWIG_fail;
19436 }
19437 if (obj1) {
19438 {
19439 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19440 if (SWIG_arg_fail(2)) SWIG_fail;
19441 }
19442 }
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19446
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 {
19451 resultobj = SWIG_From_int((int)(result));
19452 }
19453 return resultobj;
19454 fail:
19455 return NULL;
19456 }
19457
19458
19459 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19460 PyObject *resultobj;
19461 wxDateTime::Month arg1 ;
19462 int arg2 = (int) wxDateTime::Inv_Year ;
19463 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19464 int result;
19465 PyObject * obj0 = 0 ;
19466 PyObject * obj1 = 0 ;
19467 PyObject * obj2 = 0 ;
19468 char *kwnames[] = {
19469 (char *) "month",(char *) "year",(char *) "cal", NULL
19470 };
19471
19472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19473 {
19474 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19475 if (SWIG_arg_fail(1)) SWIG_fail;
19476 }
19477 if (obj1) {
19478 {
19479 arg2 = (int)(SWIG_As_int(obj1));
19480 if (SWIG_arg_fail(2)) SWIG_fail;
19481 }
19482 }
19483 if (obj2) {
19484 {
19485 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19486 if (SWIG_arg_fail(3)) SWIG_fail;
19487 }
19488 }
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19492
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 {
19497 resultobj = SWIG_From_int((int)(result));
19498 }
19499 return resultobj;
19500 fail:
19501 return NULL;
19502 }
19503
19504
19505 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19506 PyObject *resultobj;
19507 wxDateTime::Month arg1 ;
19508 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19509 wxString result;
19510 PyObject * obj0 = 0 ;
19511 PyObject * obj1 = 0 ;
19512 char *kwnames[] = {
19513 (char *) "month",(char *) "flags", NULL
19514 };
19515
19516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19517 {
19518 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19519 if (SWIG_arg_fail(1)) SWIG_fail;
19520 }
19521 if (obj1) {
19522 {
19523 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19524 if (SWIG_arg_fail(2)) SWIG_fail;
19525 }
19526 }
19527 {
19528 PyThreadState* __tstate = wxPyBeginAllowThreads();
19529 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19530
19531 wxPyEndAllowThreads(__tstate);
19532 if (PyErr_Occurred()) SWIG_fail;
19533 }
19534 {
19535 #if wxUSE_UNICODE
19536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19537 #else
19538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19539 #endif
19540 }
19541 return resultobj;
19542 fail:
19543 return NULL;
19544 }
19545
19546
19547 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19548 PyObject *resultobj;
19549 wxDateTime::WeekDay arg1 ;
19550 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19551 wxString result;
19552 PyObject * obj0 = 0 ;
19553 PyObject * obj1 = 0 ;
19554 char *kwnames[] = {
19555 (char *) "weekday",(char *) "flags", NULL
19556 };
19557
19558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19559 {
19560 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19561 if (SWIG_arg_fail(1)) SWIG_fail;
19562 }
19563 if (obj1) {
19564 {
19565 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19566 if (SWIG_arg_fail(2)) SWIG_fail;
19567 }
19568 }
19569 {
19570 PyThreadState* __tstate = wxPyBeginAllowThreads();
19571 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19572
19573 wxPyEndAllowThreads(__tstate);
19574 if (PyErr_Occurred()) SWIG_fail;
19575 }
19576 {
19577 #if wxUSE_UNICODE
19578 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19579 #else
19580 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19581 #endif
19582 }
19583 return resultobj;
19584 fail:
19585 return NULL;
19586 }
19587
19588
19589 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19590 PyObject *resultobj;
19591 PyObject *result;
19592 char *kwnames[] = {
19593 NULL
19594 };
19595
19596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19597 {
19598 PyThreadState* __tstate = wxPyBeginAllowThreads();
19599 result = (PyObject *)DateTime_GetAmPmStrings();
19600
19601 wxPyEndAllowThreads(__tstate);
19602 if (PyErr_Occurred()) SWIG_fail;
19603 }
19604 resultobj = result;
19605 return resultobj;
19606 fail:
19607 return NULL;
19608 }
19609
19610
19611 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19612 PyObject *resultobj;
19613 int arg1 = (int) wxDateTime::Inv_Year ;
19614 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19615 bool result;
19616 PyObject * obj0 = 0 ;
19617 PyObject * obj1 = 0 ;
19618 char *kwnames[] = {
19619 (char *) "year",(char *) "country", NULL
19620 };
19621
19622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19623 if (obj0) {
19624 {
19625 arg1 = (int)(SWIG_As_int(obj0));
19626 if (SWIG_arg_fail(1)) SWIG_fail;
19627 }
19628 }
19629 if (obj1) {
19630 {
19631 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19632 if (SWIG_arg_fail(2)) SWIG_fail;
19633 }
19634 }
19635 {
19636 PyThreadState* __tstate = wxPyBeginAllowThreads();
19637 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19638
19639 wxPyEndAllowThreads(__tstate);
19640 if (PyErr_Occurred()) SWIG_fail;
19641 }
19642 {
19643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19644 }
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj;
19653 int arg1 = (int) wxDateTime::Inv_Year ;
19654 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19655 wxDateTime result;
19656 PyObject * obj0 = 0 ;
19657 PyObject * obj1 = 0 ;
19658 char *kwnames[] = {
19659 (char *) "year",(char *) "country", NULL
19660 };
19661
19662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19663 if (obj0) {
19664 {
19665 arg1 = (int)(SWIG_As_int(obj0));
19666 if (SWIG_arg_fail(1)) SWIG_fail;
19667 }
19668 }
19669 if (obj1) {
19670 {
19671 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19672 if (SWIG_arg_fail(2)) SWIG_fail;
19673 }
19674 }
19675 {
19676 PyThreadState* __tstate = wxPyBeginAllowThreads();
19677 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19678
19679 wxPyEndAllowThreads(__tstate);
19680 if (PyErr_Occurred()) SWIG_fail;
19681 }
19682 {
19683 wxDateTime * resultptr;
19684 resultptr = new wxDateTime((wxDateTime &)(result));
19685 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19686 }
19687 return resultobj;
19688 fail:
19689 return NULL;
19690 }
19691
19692
19693 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19694 PyObject *resultobj;
19695 int arg1 = (int) wxDateTime::Inv_Year ;
19696 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19697 wxDateTime result;
19698 PyObject * obj0 = 0 ;
19699 PyObject * obj1 = 0 ;
19700 char *kwnames[] = {
19701 (char *) "year",(char *) "country", NULL
19702 };
19703
19704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19705 if (obj0) {
19706 {
19707 arg1 = (int)(SWIG_As_int(obj0));
19708 if (SWIG_arg_fail(1)) SWIG_fail;
19709 }
19710 }
19711 if (obj1) {
19712 {
19713 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19714 if (SWIG_arg_fail(2)) SWIG_fail;
19715 }
19716 }
19717 {
19718 PyThreadState* __tstate = wxPyBeginAllowThreads();
19719 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19720
19721 wxPyEndAllowThreads(__tstate);
19722 if (PyErr_Occurred()) SWIG_fail;
19723 }
19724 {
19725 wxDateTime * resultptr;
19726 resultptr = new wxDateTime((wxDateTime &)(result));
19727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19728 }
19729 return resultobj;
19730 fail:
19731 return NULL;
19732 }
19733
19734
19735 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19736 PyObject *resultobj;
19737 wxDateTime result;
19738 char *kwnames[] = {
19739 NULL
19740 };
19741
19742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = wxDateTime::Now();
19746
19747 wxPyEndAllowThreads(__tstate);
19748 if (PyErr_Occurred()) SWIG_fail;
19749 }
19750 {
19751 wxDateTime * resultptr;
19752 resultptr = new wxDateTime((wxDateTime &)(result));
19753 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19754 }
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 wxDateTime result;
19764 char *kwnames[] = {
19765 NULL
19766 };
19767
19768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19769 {
19770 PyThreadState* __tstate = wxPyBeginAllowThreads();
19771 result = wxDateTime::UNow();
19772
19773 wxPyEndAllowThreads(__tstate);
19774 if (PyErr_Occurred()) SWIG_fail;
19775 }
19776 {
19777 wxDateTime * resultptr;
19778 resultptr = new wxDateTime((wxDateTime &)(result));
19779 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19780 }
19781 return resultobj;
19782 fail:
19783 return NULL;
19784 }
19785
19786
19787 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19788 PyObject *resultobj;
19789 wxDateTime result;
19790 char *kwnames[] = {
19791 NULL
19792 };
19793
19794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19795 {
19796 PyThreadState* __tstate = wxPyBeginAllowThreads();
19797 result = wxDateTime::Today();
19798
19799 wxPyEndAllowThreads(__tstate);
19800 if (PyErr_Occurred()) SWIG_fail;
19801 }
19802 {
19803 wxDateTime * resultptr;
19804 resultptr = new wxDateTime((wxDateTime &)(result));
19805 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19806 }
19807 return resultobj;
19808 fail:
19809 return NULL;
19810 }
19811
19812
19813 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19814 PyObject *resultobj;
19815 wxDateTime *result;
19816 char *kwnames[] = {
19817 NULL
19818 };
19819
19820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19821 {
19822 PyThreadState* __tstate = wxPyBeginAllowThreads();
19823 result = (wxDateTime *)new wxDateTime();
19824
19825 wxPyEndAllowThreads(__tstate);
19826 if (PyErr_Occurred()) SWIG_fail;
19827 }
19828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19829 return resultobj;
19830 fail:
19831 return NULL;
19832 }
19833
19834
19835 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19836 PyObject *resultobj;
19837 time_t arg1 ;
19838 wxDateTime *result;
19839 PyObject * obj0 = 0 ;
19840 char *kwnames[] = {
19841 (char *) "timet", NULL
19842 };
19843
19844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19845 {
19846 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19847 if (SWIG_arg_fail(1)) SWIG_fail;
19848 }
19849 {
19850 PyThreadState* __tstate = wxPyBeginAllowThreads();
19851 result = (wxDateTime *)new wxDateTime(arg1);
19852
19853 wxPyEndAllowThreads(__tstate);
19854 if (PyErr_Occurred()) SWIG_fail;
19855 }
19856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19857 return resultobj;
19858 fail:
19859 return NULL;
19860 }
19861
19862
19863 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19864 PyObject *resultobj;
19865 double arg1 ;
19866 wxDateTime *result;
19867 PyObject * obj0 = 0 ;
19868 char *kwnames[] = {
19869 (char *) "jdn", NULL
19870 };
19871
19872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19873 {
19874 arg1 = (double)(SWIG_As_double(obj0));
19875 if (SWIG_arg_fail(1)) SWIG_fail;
19876 }
19877 {
19878 PyThreadState* __tstate = wxPyBeginAllowThreads();
19879 result = (wxDateTime *)new wxDateTime(arg1);
19880
19881 wxPyEndAllowThreads(__tstate);
19882 if (PyErr_Occurred()) SWIG_fail;
19883 }
19884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19885 return resultobj;
19886 fail:
19887 return NULL;
19888 }
19889
19890
19891 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19892 PyObject *resultobj;
19893 int arg1 ;
19894 int arg2 = (int) 0 ;
19895 int arg3 = (int) 0 ;
19896 int arg4 = (int) 0 ;
19897 wxDateTime *result;
19898 PyObject * obj0 = 0 ;
19899 PyObject * obj1 = 0 ;
19900 PyObject * obj2 = 0 ;
19901 PyObject * obj3 = 0 ;
19902 char *kwnames[] = {
19903 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19904 };
19905
19906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19907 {
19908 arg1 = (int)(SWIG_As_int(obj0));
19909 if (SWIG_arg_fail(1)) SWIG_fail;
19910 }
19911 if (obj1) {
19912 {
19913 arg2 = (int)(SWIG_As_int(obj1));
19914 if (SWIG_arg_fail(2)) SWIG_fail;
19915 }
19916 }
19917 if (obj2) {
19918 {
19919 arg3 = (int)(SWIG_As_int(obj2));
19920 if (SWIG_arg_fail(3)) SWIG_fail;
19921 }
19922 }
19923 if (obj3) {
19924 {
19925 arg4 = (int)(SWIG_As_int(obj3));
19926 if (SWIG_arg_fail(4)) SWIG_fail;
19927 }
19928 }
19929 {
19930 PyThreadState* __tstate = wxPyBeginAllowThreads();
19931 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19932
19933 wxPyEndAllowThreads(__tstate);
19934 if (PyErr_Occurred()) SWIG_fail;
19935 }
19936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19937 return resultobj;
19938 fail:
19939 return NULL;
19940 }
19941
19942
19943 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19944 PyObject *resultobj;
19945 int arg1 ;
19946 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19947 int arg3 = (int) wxDateTime::Inv_Year ;
19948 int arg4 = (int) 0 ;
19949 int arg5 = (int) 0 ;
19950 int arg6 = (int) 0 ;
19951 int arg7 = (int) 0 ;
19952 wxDateTime *result;
19953 PyObject * obj0 = 0 ;
19954 PyObject * obj1 = 0 ;
19955 PyObject * obj2 = 0 ;
19956 PyObject * obj3 = 0 ;
19957 PyObject * obj4 = 0 ;
19958 PyObject * obj5 = 0 ;
19959 PyObject * obj6 = 0 ;
19960 char *kwnames[] = {
19961 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19962 };
19963
19964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19965 {
19966 arg1 = (int)(SWIG_As_int(obj0));
19967 if (SWIG_arg_fail(1)) SWIG_fail;
19968 }
19969 if (obj1) {
19970 {
19971 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19972 if (SWIG_arg_fail(2)) SWIG_fail;
19973 }
19974 }
19975 if (obj2) {
19976 {
19977 arg3 = (int)(SWIG_As_int(obj2));
19978 if (SWIG_arg_fail(3)) SWIG_fail;
19979 }
19980 }
19981 if (obj3) {
19982 {
19983 arg4 = (int)(SWIG_As_int(obj3));
19984 if (SWIG_arg_fail(4)) SWIG_fail;
19985 }
19986 }
19987 if (obj4) {
19988 {
19989 arg5 = (int)(SWIG_As_int(obj4));
19990 if (SWIG_arg_fail(5)) SWIG_fail;
19991 }
19992 }
19993 if (obj5) {
19994 {
19995 arg6 = (int)(SWIG_As_int(obj5));
19996 if (SWIG_arg_fail(6)) SWIG_fail;
19997 }
19998 }
19999 if (obj6) {
20000 {
20001 arg7 = (int)(SWIG_As_int(obj6));
20002 if (SWIG_arg_fail(7)) SWIG_fail;
20003 }
20004 }
20005 {
20006 PyThreadState* __tstate = wxPyBeginAllowThreads();
20007 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
20008
20009 wxPyEndAllowThreads(__tstate);
20010 if (PyErr_Occurred()) SWIG_fail;
20011 }
20012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20013 return resultobj;
20014 fail:
20015 return NULL;
20016 }
20017
20018
20019 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20020 PyObject *resultobj;
20021 wxDateTime *arg1 = (wxDateTime *) 0 ;
20022 PyObject * obj0 = 0 ;
20023 char *kwnames[] = {
20024 (char *) "self", NULL
20025 };
20026
20027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
20028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20029 if (SWIG_arg_fail(1)) SWIG_fail;
20030 {
20031 PyThreadState* __tstate = wxPyBeginAllowThreads();
20032 delete arg1;
20033
20034 wxPyEndAllowThreads(__tstate);
20035 if (PyErr_Occurred()) SWIG_fail;
20036 }
20037 Py_INCREF(Py_None); resultobj = Py_None;
20038 return resultobj;
20039 fail:
20040 return NULL;
20041 }
20042
20043
20044 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
20045 PyObject *resultobj;
20046 wxDateTime *arg1 = (wxDateTime *) 0 ;
20047 wxDateTime *result;
20048 PyObject * obj0 = 0 ;
20049 char *kwnames[] = {
20050 (char *) "self", NULL
20051 };
20052
20053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
20054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20055 if (SWIG_arg_fail(1)) SWIG_fail;
20056 {
20057 PyThreadState* __tstate = wxPyBeginAllowThreads();
20058 {
20059 wxDateTime &_result_ref = (arg1)->SetToCurrent();
20060 result = (wxDateTime *) &_result_ref;
20061 }
20062
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20067 return resultobj;
20068 fail:
20069 return NULL;
20070 }
20071
20072
20073 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20074 PyObject *resultobj;
20075 wxDateTime *arg1 = (wxDateTime *) 0 ;
20076 time_t arg2 ;
20077 wxDateTime *result;
20078 PyObject * obj0 = 0 ;
20079 PyObject * obj1 = 0 ;
20080 char *kwnames[] = {
20081 (char *) "self",(char *) "timet", NULL
20082 };
20083
20084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
20085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20086 if (SWIG_arg_fail(1)) SWIG_fail;
20087 {
20088 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
20089 if (SWIG_arg_fail(2)) SWIG_fail;
20090 }
20091 {
20092 PyThreadState* __tstate = wxPyBeginAllowThreads();
20093 {
20094 wxDateTime &_result_ref = (arg1)->Set(arg2);
20095 result = (wxDateTime *) &_result_ref;
20096 }
20097
20098 wxPyEndAllowThreads(__tstate);
20099 if (PyErr_Occurred()) SWIG_fail;
20100 }
20101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20102 return resultobj;
20103 fail:
20104 return NULL;
20105 }
20106
20107
20108 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20109 PyObject *resultobj;
20110 wxDateTime *arg1 = (wxDateTime *) 0 ;
20111 double arg2 ;
20112 wxDateTime *result;
20113 PyObject * obj0 = 0 ;
20114 PyObject * obj1 = 0 ;
20115 char *kwnames[] = {
20116 (char *) "self",(char *) "jdn", NULL
20117 };
20118
20119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20121 if (SWIG_arg_fail(1)) SWIG_fail;
20122 {
20123 arg2 = (double)(SWIG_As_double(obj1));
20124 if (SWIG_arg_fail(2)) SWIG_fail;
20125 }
20126 {
20127 PyThreadState* __tstate = wxPyBeginAllowThreads();
20128 {
20129 wxDateTime &_result_ref = (arg1)->Set(arg2);
20130 result = (wxDateTime *) &_result_ref;
20131 }
20132
20133 wxPyEndAllowThreads(__tstate);
20134 if (PyErr_Occurred()) SWIG_fail;
20135 }
20136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20137 return resultobj;
20138 fail:
20139 return NULL;
20140 }
20141
20142
20143 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20144 PyObject *resultobj;
20145 wxDateTime *arg1 = (wxDateTime *) 0 ;
20146 int arg2 ;
20147 int arg3 = (int) 0 ;
20148 int arg4 = (int) 0 ;
20149 int arg5 = (int) 0 ;
20150 wxDateTime *result;
20151 PyObject * obj0 = 0 ;
20152 PyObject * obj1 = 0 ;
20153 PyObject * obj2 = 0 ;
20154 PyObject * obj3 = 0 ;
20155 PyObject * obj4 = 0 ;
20156 char *kwnames[] = {
20157 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20158 };
20159
20160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20162 if (SWIG_arg_fail(1)) SWIG_fail;
20163 {
20164 arg2 = (int)(SWIG_As_int(obj1));
20165 if (SWIG_arg_fail(2)) SWIG_fail;
20166 }
20167 if (obj2) {
20168 {
20169 arg3 = (int)(SWIG_As_int(obj2));
20170 if (SWIG_arg_fail(3)) SWIG_fail;
20171 }
20172 }
20173 if (obj3) {
20174 {
20175 arg4 = (int)(SWIG_As_int(obj3));
20176 if (SWIG_arg_fail(4)) SWIG_fail;
20177 }
20178 }
20179 if (obj4) {
20180 {
20181 arg5 = (int)(SWIG_As_int(obj4));
20182 if (SWIG_arg_fail(5)) SWIG_fail;
20183 }
20184 }
20185 {
20186 PyThreadState* __tstate = wxPyBeginAllowThreads();
20187 {
20188 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20189 result = (wxDateTime *) &_result_ref;
20190 }
20191
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20196 return resultobj;
20197 fail:
20198 return NULL;
20199 }
20200
20201
20202 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20203 PyObject *resultobj;
20204 wxDateTime *arg1 = (wxDateTime *) 0 ;
20205 int arg2 ;
20206 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20207 int arg4 = (int) wxDateTime::Inv_Year ;
20208 int arg5 = (int) 0 ;
20209 int arg6 = (int) 0 ;
20210 int arg7 = (int) 0 ;
20211 int arg8 = (int) 0 ;
20212 wxDateTime *result;
20213 PyObject * obj0 = 0 ;
20214 PyObject * obj1 = 0 ;
20215 PyObject * obj2 = 0 ;
20216 PyObject * obj3 = 0 ;
20217 PyObject * obj4 = 0 ;
20218 PyObject * obj5 = 0 ;
20219 PyObject * obj6 = 0 ;
20220 PyObject * obj7 = 0 ;
20221 char *kwnames[] = {
20222 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20223 };
20224
20225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20227 if (SWIG_arg_fail(1)) SWIG_fail;
20228 {
20229 arg2 = (int)(SWIG_As_int(obj1));
20230 if (SWIG_arg_fail(2)) SWIG_fail;
20231 }
20232 if (obj2) {
20233 {
20234 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20235 if (SWIG_arg_fail(3)) SWIG_fail;
20236 }
20237 }
20238 if (obj3) {
20239 {
20240 arg4 = (int)(SWIG_As_int(obj3));
20241 if (SWIG_arg_fail(4)) SWIG_fail;
20242 }
20243 }
20244 if (obj4) {
20245 {
20246 arg5 = (int)(SWIG_As_int(obj4));
20247 if (SWIG_arg_fail(5)) SWIG_fail;
20248 }
20249 }
20250 if (obj5) {
20251 {
20252 arg6 = (int)(SWIG_As_int(obj5));
20253 if (SWIG_arg_fail(6)) SWIG_fail;
20254 }
20255 }
20256 if (obj6) {
20257 {
20258 arg7 = (int)(SWIG_As_int(obj6));
20259 if (SWIG_arg_fail(7)) SWIG_fail;
20260 }
20261 }
20262 if (obj7) {
20263 {
20264 arg8 = (int)(SWIG_As_int(obj7));
20265 if (SWIG_arg_fail(8)) SWIG_fail;
20266 }
20267 }
20268 {
20269 PyThreadState* __tstate = wxPyBeginAllowThreads();
20270 {
20271 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20272 result = (wxDateTime *) &_result_ref;
20273 }
20274
20275 wxPyEndAllowThreads(__tstate);
20276 if (PyErr_Occurred()) SWIG_fail;
20277 }
20278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20279 return resultobj;
20280 fail:
20281 return NULL;
20282 }
20283
20284
20285 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20286 PyObject *resultobj;
20287 wxDateTime *arg1 = (wxDateTime *) 0 ;
20288 wxDateTime *result;
20289 PyObject * obj0 = 0 ;
20290 char *kwnames[] = {
20291 (char *) "self", NULL
20292 };
20293
20294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20296 if (SWIG_arg_fail(1)) SWIG_fail;
20297 {
20298 PyThreadState* __tstate = wxPyBeginAllowThreads();
20299 {
20300 wxDateTime &_result_ref = (arg1)->ResetTime();
20301 result = (wxDateTime *) &_result_ref;
20302 }
20303
20304 wxPyEndAllowThreads(__tstate);
20305 if (PyErr_Occurred()) SWIG_fail;
20306 }
20307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20308 return resultobj;
20309 fail:
20310 return NULL;
20311 }
20312
20313
20314 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20315 PyObject *resultobj;
20316 wxDateTime *arg1 = (wxDateTime *) 0 ;
20317 int arg2 ;
20318 wxDateTime *result;
20319 PyObject * obj0 = 0 ;
20320 PyObject * obj1 = 0 ;
20321 char *kwnames[] = {
20322 (char *) "self",(char *) "year", NULL
20323 };
20324
20325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20327 if (SWIG_arg_fail(1)) SWIG_fail;
20328 {
20329 arg2 = (int)(SWIG_As_int(obj1));
20330 if (SWIG_arg_fail(2)) SWIG_fail;
20331 }
20332 {
20333 PyThreadState* __tstate = wxPyBeginAllowThreads();
20334 {
20335 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20336 result = (wxDateTime *) &_result_ref;
20337 }
20338
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20343 return resultobj;
20344 fail:
20345 return NULL;
20346 }
20347
20348
20349 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20350 PyObject *resultobj;
20351 wxDateTime *arg1 = (wxDateTime *) 0 ;
20352 wxDateTime::Month arg2 ;
20353 wxDateTime *result;
20354 PyObject * obj0 = 0 ;
20355 PyObject * obj1 = 0 ;
20356 char *kwnames[] = {
20357 (char *) "self",(char *) "month", NULL
20358 };
20359
20360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20362 if (SWIG_arg_fail(1)) SWIG_fail;
20363 {
20364 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20365 if (SWIG_arg_fail(2)) SWIG_fail;
20366 }
20367 {
20368 PyThreadState* __tstate = wxPyBeginAllowThreads();
20369 {
20370 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20371 result = (wxDateTime *) &_result_ref;
20372 }
20373
20374 wxPyEndAllowThreads(__tstate);
20375 if (PyErr_Occurred()) SWIG_fail;
20376 }
20377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20385 PyObject *resultobj;
20386 wxDateTime *arg1 = (wxDateTime *) 0 ;
20387 int arg2 ;
20388 wxDateTime *result;
20389 PyObject * obj0 = 0 ;
20390 PyObject * obj1 = 0 ;
20391 char *kwnames[] = {
20392 (char *) "self",(char *) "day", NULL
20393 };
20394
20395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20397 if (SWIG_arg_fail(1)) SWIG_fail;
20398 {
20399 arg2 = (int)(SWIG_As_int(obj1));
20400 if (SWIG_arg_fail(2)) SWIG_fail;
20401 }
20402 {
20403 PyThreadState* __tstate = wxPyBeginAllowThreads();
20404 {
20405 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20406 result = (wxDateTime *) &_result_ref;
20407 }
20408
20409 wxPyEndAllowThreads(__tstate);
20410 if (PyErr_Occurred()) SWIG_fail;
20411 }
20412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20413 return resultobj;
20414 fail:
20415 return NULL;
20416 }
20417
20418
20419 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20420 PyObject *resultobj;
20421 wxDateTime *arg1 = (wxDateTime *) 0 ;
20422 int arg2 ;
20423 wxDateTime *result;
20424 PyObject * obj0 = 0 ;
20425 PyObject * obj1 = 0 ;
20426 char *kwnames[] = {
20427 (char *) "self",(char *) "hour", NULL
20428 };
20429
20430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20432 if (SWIG_arg_fail(1)) SWIG_fail;
20433 {
20434 arg2 = (int)(SWIG_As_int(obj1));
20435 if (SWIG_arg_fail(2)) SWIG_fail;
20436 }
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 {
20440 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20441 result = (wxDateTime *) &_result_ref;
20442 }
20443
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20448 return resultobj;
20449 fail:
20450 return NULL;
20451 }
20452
20453
20454 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20455 PyObject *resultobj;
20456 wxDateTime *arg1 = (wxDateTime *) 0 ;
20457 int arg2 ;
20458 wxDateTime *result;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "self",(char *) "minute", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20467 if (SWIG_arg_fail(1)) SWIG_fail;
20468 {
20469 arg2 = (int)(SWIG_As_int(obj1));
20470 if (SWIG_arg_fail(2)) SWIG_fail;
20471 }
20472 {
20473 PyThreadState* __tstate = wxPyBeginAllowThreads();
20474 {
20475 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20476 result = (wxDateTime *) &_result_ref;
20477 }
20478
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20483 return resultobj;
20484 fail:
20485 return NULL;
20486 }
20487
20488
20489 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20490 PyObject *resultobj;
20491 wxDateTime *arg1 = (wxDateTime *) 0 ;
20492 int arg2 ;
20493 wxDateTime *result;
20494 PyObject * obj0 = 0 ;
20495 PyObject * obj1 = 0 ;
20496 char *kwnames[] = {
20497 (char *) "self",(char *) "second", NULL
20498 };
20499
20500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20502 if (SWIG_arg_fail(1)) SWIG_fail;
20503 {
20504 arg2 = (int)(SWIG_As_int(obj1));
20505 if (SWIG_arg_fail(2)) SWIG_fail;
20506 }
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 {
20510 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20511 result = (wxDateTime *) &_result_ref;
20512 }
20513
20514 wxPyEndAllowThreads(__tstate);
20515 if (PyErr_Occurred()) SWIG_fail;
20516 }
20517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20525 PyObject *resultobj;
20526 wxDateTime *arg1 = (wxDateTime *) 0 ;
20527 int arg2 ;
20528 wxDateTime *result;
20529 PyObject * obj0 = 0 ;
20530 PyObject * obj1 = 0 ;
20531 char *kwnames[] = {
20532 (char *) "self",(char *) "millisecond", NULL
20533 };
20534
20535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20537 if (SWIG_arg_fail(1)) SWIG_fail;
20538 {
20539 arg2 = (int)(SWIG_As_int(obj1));
20540 if (SWIG_arg_fail(2)) SWIG_fail;
20541 }
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 {
20545 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20546 result = (wxDateTime *) &_result_ref;
20547 }
20548
20549 wxPyEndAllowThreads(__tstate);
20550 if (PyErr_Occurred()) SWIG_fail;
20551 }
20552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20553 return resultobj;
20554 fail:
20555 return NULL;
20556 }
20557
20558
20559 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20560 PyObject *resultobj;
20561 wxDateTime *arg1 = (wxDateTime *) 0 ;
20562 wxDateTime::WeekDay arg2 ;
20563 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20564 wxDateTime *result;
20565 PyObject * obj0 = 0 ;
20566 PyObject * obj1 = 0 ;
20567 PyObject * obj2 = 0 ;
20568 char *kwnames[] = {
20569 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20570 };
20571
20572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20574 if (SWIG_arg_fail(1)) SWIG_fail;
20575 {
20576 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20577 if (SWIG_arg_fail(2)) SWIG_fail;
20578 }
20579 if (obj2) {
20580 {
20581 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20582 if (SWIG_arg_fail(3)) SWIG_fail;
20583 }
20584 }
20585 {
20586 PyThreadState* __tstate = wxPyBeginAllowThreads();
20587 {
20588 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20589 result = (wxDateTime *) &_result_ref;
20590 }
20591
20592 wxPyEndAllowThreads(__tstate);
20593 if (PyErr_Occurred()) SWIG_fail;
20594 }
20595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20596 return resultobj;
20597 fail:
20598 return NULL;
20599 }
20600
20601
20602 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20603 PyObject *resultobj;
20604 wxDateTime *arg1 = (wxDateTime *) 0 ;
20605 wxDateTime::WeekDay arg2 ;
20606 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20607 wxDateTime result;
20608 PyObject * obj0 = 0 ;
20609 PyObject * obj1 = 0 ;
20610 PyObject * obj2 = 0 ;
20611 char *kwnames[] = {
20612 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20613 };
20614
20615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20617 if (SWIG_arg_fail(1)) SWIG_fail;
20618 {
20619 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20620 if (SWIG_arg_fail(2)) SWIG_fail;
20621 }
20622 if (obj2) {
20623 {
20624 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20625 if (SWIG_arg_fail(3)) SWIG_fail;
20626 }
20627 }
20628 {
20629 PyThreadState* __tstate = wxPyBeginAllowThreads();
20630 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20631
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 {
20636 wxDateTime * resultptr;
20637 resultptr = new wxDateTime((wxDateTime &)(result));
20638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20639 }
20640 return resultobj;
20641 fail:
20642 return NULL;
20643 }
20644
20645
20646 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20647 PyObject *resultobj;
20648 wxDateTime *arg1 = (wxDateTime *) 0 ;
20649 wxDateTime::WeekDay arg2 ;
20650 wxDateTime *result;
20651 PyObject * obj0 = 0 ;
20652 PyObject * obj1 = 0 ;
20653 char *kwnames[] = {
20654 (char *) "self",(char *) "weekday", NULL
20655 };
20656
20657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20659 if (SWIG_arg_fail(1)) SWIG_fail;
20660 {
20661 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20662 if (SWIG_arg_fail(2)) SWIG_fail;
20663 }
20664 {
20665 PyThreadState* __tstate = wxPyBeginAllowThreads();
20666 {
20667 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20668 result = (wxDateTime *) &_result_ref;
20669 }
20670
20671 wxPyEndAllowThreads(__tstate);
20672 if (PyErr_Occurred()) SWIG_fail;
20673 }
20674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20675 return resultobj;
20676 fail:
20677 return NULL;
20678 }
20679
20680
20681 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20682 PyObject *resultobj;
20683 wxDateTime *arg1 = (wxDateTime *) 0 ;
20684 wxDateTime::WeekDay arg2 ;
20685 wxDateTime result;
20686 PyObject * obj0 = 0 ;
20687 PyObject * obj1 = 0 ;
20688 char *kwnames[] = {
20689 (char *) "self",(char *) "weekday", NULL
20690 };
20691
20692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20694 if (SWIG_arg_fail(1)) SWIG_fail;
20695 {
20696 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20697 if (SWIG_arg_fail(2)) SWIG_fail;
20698 }
20699 {
20700 PyThreadState* __tstate = wxPyBeginAllowThreads();
20701 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20702
20703 wxPyEndAllowThreads(__tstate);
20704 if (PyErr_Occurred()) SWIG_fail;
20705 }
20706 {
20707 wxDateTime * resultptr;
20708 resultptr = new wxDateTime((wxDateTime &)(result));
20709 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20710 }
20711 return resultobj;
20712 fail:
20713 return NULL;
20714 }
20715
20716
20717 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20718 PyObject *resultobj;
20719 wxDateTime *arg1 = (wxDateTime *) 0 ;
20720 wxDateTime::WeekDay arg2 ;
20721 wxDateTime *result;
20722 PyObject * obj0 = 0 ;
20723 PyObject * obj1 = 0 ;
20724 char *kwnames[] = {
20725 (char *) "self",(char *) "weekday", NULL
20726 };
20727
20728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20730 if (SWIG_arg_fail(1)) SWIG_fail;
20731 {
20732 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20733 if (SWIG_arg_fail(2)) SWIG_fail;
20734 }
20735 {
20736 PyThreadState* __tstate = wxPyBeginAllowThreads();
20737 {
20738 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20739 result = (wxDateTime *) &_result_ref;
20740 }
20741
20742 wxPyEndAllowThreads(__tstate);
20743 if (PyErr_Occurred()) SWIG_fail;
20744 }
20745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20746 return resultobj;
20747 fail:
20748 return NULL;
20749 }
20750
20751
20752 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20753 PyObject *resultobj;
20754 wxDateTime *arg1 = (wxDateTime *) 0 ;
20755 wxDateTime::WeekDay arg2 ;
20756 wxDateTime result;
20757 PyObject * obj0 = 0 ;
20758 PyObject * obj1 = 0 ;
20759 char *kwnames[] = {
20760 (char *) "self",(char *) "weekday", NULL
20761 };
20762
20763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20765 if (SWIG_arg_fail(1)) SWIG_fail;
20766 {
20767 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20768 if (SWIG_arg_fail(2)) SWIG_fail;
20769 }
20770 {
20771 PyThreadState* __tstate = wxPyBeginAllowThreads();
20772 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20773
20774 wxPyEndAllowThreads(__tstate);
20775 if (PyErr_Occurred()) SWIG_fail;
20776 }
20777 {
20778 wxDateTime * resultptr;
20779 resultptr = new wxDateTime((wxDateTime &)(result));
20780 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20781 }
20782 return resultobj;
20783 fail:
20784 return NULL;
20785 }
20786
20787
20788 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20789 PyObject *resultobj;
20790 wxDateTime *arg1 = (wxDateTime *) 0 ;
20791 wxDateTime::WeekDay arg2 ;
20792 int arg3 = (int) 1 ;
20793 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20794 int arg5 = (int) wxDateTime::Inv_Year ;
20795 bool result;
20796 PyObject * obj0 = 0 ;
20797 PyObject * obj1 = 0 ;
20798 PyObject * obj2 = 0 ;
20799 PyObject * obj3 = 0 ;
20800 PyObject * obj4 = 0 ;
20801 char *kwnames[] = {
20802 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20803 };
20804
20805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20807 if (SWIG_arg_fail(1)) SWIG_fail;
20808 {
20809 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20810 if (SWIG_arg_fail(2)) SWIG_fail;
20811 }
20812 if (obj2) {
20813 {
20814 arg3 = (int)(SWIG_As_int(obj2));
20815 if (SWIG_arg_fail(3)) SWIG_fail;
20816 }
20817 }
20818 if (obj3) {
20819 {
20820 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20821 if (SWIG_arg_fail(4)) SWIG_fail;
20822 }
20823 }
20824 if (obj4) {
20825 {
20826 arg5 = (int)(SWIG_As_int(obj4));
20827 if (SWIG_arg_fail(5)) SWIG_fail;
20828 }
20829 }
20830 {
20831 PyThreadState* __tstate = wxPyBeginAllowThreads();
20832 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20833
20834 wxPyEndAllowThreads(__tstate);
20835 if (PyErr_Occurred()) SWIG_fail;
20836 }
20837 {
20838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20839 }
20840 return resultobj;
20841 fail:
20842 return NULL;
20843 }
20844
20845
20846 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20847 PyObject *resultobj;
20848 wxDateTime *arg1 = (wxDateTime *) 0 ;
20849 wxDateTime::WeekDay arg2 ;
20850 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20851 int arg4 = (int) wxDateTime::Inv_Year ;
20852 bool result;
20853 PyObject * obj0 = 0 ;
20854 PyObject * obj1 = 0 ;
20855 PyObject * obj2 = 0 ;
20856 PyObject * obj3 = 0 ;
20857 char *kwnames[] = {
20858 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20859 };
20860
20861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20863 if (SWIG_arg_fail(1)) SWIG_fail;
20864 {
20865 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20866 if (SWIG_arg_fail(2)) SWIG_fail;
20867 }
20868 if (obj2) {
20869 {
20870 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20871 if (SWIG_arg_fail(3)) SWIG_fail;
20872 }
20873 }
20874 if (obj3) {
20875 {
20876 arg4 = (int)(SWIG_As_int(obj3));
20877 if (SWIG_arg_fail(4)) SWIG_fail;
20878 }
20879 }
20880 {
20881 PyThreadState* __tstate = wxPyBeginAllowThreads();
20882 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20883
20884 wxPyEndAllowThreads(__tstate);
20885 if (PyErr_Occurred()) SWIG_fail;
20886 }
20887 {
20888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20889 }
20890 return resultobj;
20891 fail:
20892 return NULL;
20893 }
20894
20895
20896 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20897 PyObject *resultobj;
20898 wxDateTime *arg1 = (wxDateTime *) 0 ;
20899 wxDateTime::WeekDay arg2 ;
20900 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20901 int arg4 = (int) wxDateTime::Inv_Year ;
20902 wxDateTime result;
20903 PyObject * obj0 = 0 ;
20904 PyObject * obj1 = 0 ;
20905 PyObject * obj2 = 0 ;
20906 PyObject * obj3 = 0 ;
20907 char *kwnames[] = {
20908 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20909 };
20910
20911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20913 if (SWIG_arg_fail(1)) SWIG_fail;
20914 {
20915 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20916 if (SWIG_arg_fail(2)) SWIG_fail;
20917 }
20918 if (obj2) {
20919 {
20920 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20921 if (SWIG_arg_fail(3)) SWIG_fail;
20922 }
20923 }
20924 if (obj3) {
20925 {
20926 arg4 = (int)(SWIG_As_int(obj3));
20927 if (SWIG_arg_fail(4)) SWIG_fail;
20928 }
20929 }
20930 {
20931 PyThreadState* __tstate = wxPyBeginAllowThreads();
20932 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20933
20934 wxPyEndAllowThreads(__tstate);
20935 if (PyErr_Occurred()) SWIG_fail;
20936 }
20937 {
20938 wxDateTime * resultptr;
20939 resultptr = new wxDateTime((wxDateTime &)(result));
20940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20941 }
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20949 PyObject *resultobj;
20950 wxDateTime *arg1 = (wxDateTime *) 0 ;
20951 int arg2 ;
20952 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20953 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20954 bool result;
20955 PyObject * obj0 = 0 ;
20956 PyObject * obj1 = 0 ;
20957 PyObject * obj2 = 0 ;
20958 PyObject * obj3 = 0 ;
20959 char *kwnames[] = {
20960 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20961 };
20962
20963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20965 if (SWIG_arg_fail(1)) SWIG_fail;
20966 {
20967 arg2 = (int)(SWIG_As_int(obj1));
20968 if (SWIG_arg_fail(2)) SWIG_fail;
20969 }
20970 if (obj2) {
20971 {
20972 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20973 if (SWIG_arg_fail(3)) SWIG_fail;
20974 }
20975 }
20976 if (obj3) {
20977 {
20978 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20979 if (SWIG_arg_fail(4)) SWIG_fail;
20980 }
20981 }
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20985
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 {
20990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20991 }
20992 return resultobj;
20993 fail:
20994 return NULL;
20995 }
20996
20997
20998 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20999 PyObject *resultobj;
21000 wxDateTime *arg1 = (wxDateTime *) 0 ;
21001 int arg2 ;
21002 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21003 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21004 wxDateTime result;
21005 PyObject * obj0 = 0 ;
21006 PyObject * obj1 = 0 ;
21007 PyObject * obj2 = 0 ;
21008 PyObject * obj3 = 0 ;
21009 char *kwnames[] = {
21010 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21011 };
21012
21013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21015 if (SWIG_arg_fail(1)) SWIG_fail;
21016 {
21017 arg2 = (int)(SWIG_As_int(obj1));
21018 if (SWIG_arg_fail(2)) SWIG_fail;
21019 }
21020 if (obj2) {
21021 {
21022 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
21023 if (SWIG_arg_fail(3)) SWIG_fail;
21024 }
21025 }
21026 if (obj3) {
21027 {
21028 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
21029 if (SWIG_arg_fail(4)) SWIG_fail;
21030 }
21031 }
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
21035
21036 wxPyEndAllowThreads(__tstate);
21037 if (PyErr_Occurred()) SWIG_fail;
21038 }
21039 {
21040 wxDateTime * resultptr;
21041 resultptr = new wxDateTime((wxDateTime &)(result));
21042 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21043 }
21044 return resultobj;
21045 fail:
21046 return NULL;
21047 }
21048
21049
21050 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21051 PyObject *resultobj;
21052 int arg1 ;
21053 int arg2 ;
21054 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21055 wxDateTime result;
21056 PyObject * obj0 = 0 ;
21057 PyObject * obj1 = 0 ;
21058 PyObject * obj2 = 0 ;
21059 char *kwnames[] = {
21060 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
21061 };
21062
21063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21064 {
21065 arg1 = (int)(SWIG_As_int(obj0));
21066 if (SWIG_arg_fail(1)) SWIG_fail;
21067 }
21068 {
21069 arg2 = (int)(SWIG_As_int(obj1));
21070 if (SWIG_arg_fail(2)) SWIG_fail;
21071 }
21072 if (obj2) {
21073 {
21074 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
21075 if (SWIG_arg_fail(3)) SWIG_fail;
21076 }
21077 }
21078 {
21079 PyThreadState* __tstate = wxPyBeginAllowThreads();
21080 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
21081
21082 wxPyEndAllowThreads(__tstate);
21083 if (PyErr_Occurred()) SWIG_fail;
21084 }
21085 {
21086 wxDateTime * resultptr;
21087 resultptr = new wxDateTime((wxDateTime &)(result));
21088 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21089 }
21090 return resultobj;
21091 fail:
21092 return NULL;
21093 }
21094
21095
21096 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21097 PyObject *resultobj;
21098 wxDateTime *arg1 = (wxDateTime *) 0 ;
21099 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21100 int arg3 = (int) wxDateTime::Inv_Year ;
21101 wxDateTime *result;
21102 PyObject * obj0 = 0 ;
21103 PyObject * obj1 = 0 ;
21104 PyObject * obj2 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "self",(char *) "month",(char *) "year", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21111 if (SWIG_arg_fail(1)) SWIG_fail;
21112 if (obj1) {
21113 {
21114 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21115 if (SWIG_arg_fail(2)) SWIG_fail;
21116 }
21117 }
21118 if (obj2) {
21119 {
21120 arg3 = (int)(SWIG_As_int(obj2));
21121 if (SWIG_arg_fail(3)) SWIG_fail;
21122 }
21123 }
21124 {
21125 PyThreadState* __tstate = wxPyBeginAllowThreads();
21126 {
21127 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
21128 result = (wxDateTime *) &_result_ref;
21129 }
21130
21131 wxPyEndAllowThreads(__tstate);
21132 if (PyErr_Occurred()) SWIG_fail;
21133 }
21134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21142 PyObject *resultobj;
21143 wxDateTime *arg1 = (wxDateTime *) 0 ;
21144 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21145 int arg3 = (int) wxDateTime::Inv_Year ;
21146 wxDateTime result;
21147 PyObject * obj0 = 0 ;
21148 PyObject * obj1 = 0 ;
21149 PyObject * obj2 = 0 ;
21150 char *kwnames[] = {
21151 (char *) "self",(char *) "month",(char *) "year", NULL
21152 };
21153
21154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21156 if (SWIG_arg_fail(1)) SWIG_fail;
21157 if (obj1) {
21158 {
21159 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21160 if (SWIG_arg_fail(2)) SWIG_fail;
21161 }
21162 }
21163 if (obj2) {
21164 {
21165 arg3 = (int)(SWIG_As_int(obj2));
21166 if (SWIG_arg_fail(3)) SWIG_fail;
21167 }
21168 }
21169 {
21170 PyThreadState* __tstate = wxPyBeginAllowThreads();
21171 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21172
21173 wxPyEndAllowThreads(__tstate);
21174 if (PyErr_Occurred()) SWIG_fail;
21175 }
21176 {
21177 wxDateTime * resultptr;
21178 resultptr = new wxDateTime((wxDateTime &)(result));
21179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21180 }
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21188 PyObject *resultobj;
21189 wxDateTime *arg1 = (wxDateTime *) 0 ;
21190 int arg2 ;
21191 wxDateTime *result;
21192 PyObject * obj0 = 0 ;
21193 PyObject * obj1 = 0 ;
21194 char *kwnames[] = {
21195 (char *) "self",(char *) "yday", NULL
21196 };
21197
21198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21200 if (SWIG_arg_fail(1)) SWIG_fail;
21201 {
21202 arg2 = (int)(SWIG_As_int(obj1));
21203 if (SWIG_arg_fail(2)) SWIG_fail;
21204 }
21205 {
21206 PyThreadState* __tstate = wxPyBeginAllowThreads();
21207 {
21208 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21209 result = (wxDateTime *) &_result_ref;
21210 }
21211
21212 wxPyEndAllowThreads(__tstate);
21213 if (PyErr_Occurred()) SWIG_fail;
21214 }
21215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21216 return resultobj;
21217 fail:
21218 return NULL;
21219 }
21220
21221
21222 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21223 PyObject *resultobj;
21224 wxDateTime *arg1 = (wxDateTime *) 0 ;
21225 int arg2 ;
21226 wxDateTime result;
21227 PyObject * obj0 = 0 ;
21228 PyObject * obj1 = 0 ;
21229 char *kwnames[] = {
21230 (char *) "self",(char *) "yday", NULL
21231 };
21232
21233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21235 if (SWIG_arg_fail(1)) SWIG_fail;
21236 {
21237 arg2 = (int)(SWIG_As_int(obj1));
21238 if (SWIG_arg_fail(2)) SWIG_fail;
21239 }
21240 {
21241 PyThreadState* __tstate = wxPyBeginAllowThreads();
21242 result = (arg1)->GetYearDay(arg2);
21243
21244 wxPyEndAllowThreads(__tstate);
21245 if (PyErr_Occurred()) SWIG_fail;
21246 }
21247 {
21248 wxDateTime * resultptr;
21249 resultptr = new wxDateTime((wxDateTime &)(result));
21250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21251 }
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21259 PyObject *resultobj;
21260 wxDateTime *arg1 = (wxDateTime *) 0 ;
21261 double result;
21262 PyObject * obj0 = 0 ;
21263 char *kwnames[] = {
21264 (char *) "self", NULL
21265 };
21266
21267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21269 if (SWIG_arg_fail(1)) SWIG_fail;
21270 {
21271 PyThreadState* __tstate = wxPyBeginAllowThreads();
21272 result = (double)(arg1)->GetJulianDayNumber();
21273
21274 wxPyEndAllowThreads(__tstate);
21275 if (PyErr_Occurred()) SWIG_fail;
21276 }
21277 {
21278 resultobj = SWIG_From_double((double)(result));
21279 }
21280 return resultobj;
21281 fail:
21282 return NULL;
21283 }
21284
21285
21286 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21287 PyObject *resultobj;
21288 wxDateTime *arg1 = (wxDateTime *) 0 ;
21289 double result;
21290 PyObject * obj0 = 0 ;
21291 char *kwnames[] = {
21292 (char *) "self", NULL
21293 };
21294
21295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21297 if (SWIG_arg_fail(1)) SWIG_fail;
21298 {
21299 PyThreadState* __tstate = wxPyBeginAllowThreads();
21300 result = (double)(arg1)->GetJDN();
21301
21302 wxPyEndAllowThreads(__tstate);
21303 if (PyErr_Occurred()) SWIG_fail;
21304 }
21305 {
21306 resultobj = SWIG_From_double((double)(result));
21307 }
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21315 PyObject *resultobj;
21316 wxDateTime *arg1 = (wxDateTime *) 0 ;
21317 double result;
21318 PyObject * obj0 = 0 ;
21319 char *kwnames[] = {
21320 (char *) "self", NULL
21321 };
21322
21323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21325 if (SWIG_arg_fail(1)) SWIG_fail;
21326 {
21327 PyThreadState* __tstate = wxPyBeginAllowThreads();
21328 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21329
21330 wxPyEndAllowThreads(__tstate);
21331 if (PyErr_Occurred()) SWIG_fail;
21332 }
21333 {
21334 resultobj = SWIG_From_double((double)(result));
21335 }
21336 return resultobj;
21337 fail:
21338 return NULL;
21339 }
21340
21341
21342 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21343 PyObject *resultobj;
21344 wxDateTime *arg1 = (wxDateTime *) 0 ;
21345 double result;
21346 PyObject * obj0 = 0 ;
21347 char *kwnames[] = {
21348 (char *) "self", NULL
21349 };
21350
21351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21353 if (SWIG_arg_fail(1)) SWIG_fail;
21354 {
21355 PyThreadState* __tstate = wxPyBeginAllowThreads();
21356 result = (double)(arg1)->GetMJD();
21357
21358 wxPyEndAllowThreads(__tstate);
21359 if (PyErr_Occurred()) SWIG_fail;
21360 }
21361 {
21362 resultobj = SWIG_From_double((double)(result));
21363 }
21364 return resultobj;
21365 fail:
21366 return NULL;
21367 }
21368
21369
21370 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21371 PyObject *resultobj;
21372 wxDateTime *arg1 = (wxDateTime *) 0 ;
21373 double result;
21374 PyObject * obj0 = 0 ;
21375 char *kwnames[] = {
21376 (char *) "self", NULL
21377 };
21378
21379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21381 if (SWIG_arg_fail(1)) SWIG_fail;
21382 {
21383 PyThreadState* __tstate = wxPyBeginAllowThreads();
21384 result = (double)(arg1)->GetRataDie();
21385
21386 wxPyEndAllowThreads(__tstate);
21387 if (PyErr_Occurred()) SWIG_fail;
21388 }
21389 {
21390 resultobj = SWIG_From_double((double)(result));
21391 }
21392 return resultobj;
21393 fail:
21394 return NULL;
21395 }
21396
21397
21398 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21399 PyObject *resultobj;
21400 wxDateTime *arg1 = (wxDateTime *) 0 ;
21401 wxDateTime::TimeZone *arg2 = 0 ;
21402 bool arg3 = (bool) false ;
21403 wxDateTime result;
21404 bool temp2 = false ;
21405 PyObject * obj0 = 0 ;
21406 PyObject * obj1 = 0 ;
21407 PyObject * obj2 = 0 ;
21408 char *kwnames[] = {
21409 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21410 };
21411
21412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21414 if (SWIG_arg_fail(1)) SWIG_fail;
21415 {
21416 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21417 temp2 = true;
21418 }
21419 if (obj2) {
21420 {
21421 arg3 = (bool)(SWIG_As_bool(obj2));
21422 if (SWIG_arg_fail(3)) SWIG_fail;
21423 }
21424 }
21425 {
21426 PyThreadState* __tstate = wxPyBeginAllowThreads();
21427 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21428
21429 wxPyEndAllowThreads(__tstate);
21430 if (PyErr_Occurred()) SWIG_fail;
21431 }
21432 {
21433 wxDateTime * resultptr;
21434 resultptr = new wxDateTime((wxDateTime &)(result));
21435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21436 }
21437 {
21438 if (temp2) delete arg2;
21439 }
21440 return resultobj;
21441 fail:
21442 {
21443 if (temp2) delete arg2;
21444 }
21445 return NULL;
21446 }
21447
21448
21449 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21450 PyObject *resultobj;
21451 wxDateTime *arg1 = (wxDateTime *) 0 ;
21452 wxDateTime::TimeZone *arg2 = 0 ;
21453 bool arg3 = (bool) false ;
21454 wxDateTime *result;
21455 bool temp2 = false ;
21456 PyObject * obj0 = 0 ;
21457 PyObject * obj1 = 0 ;
21458 PyObject * obj2 = 0 ;
21459 char *kwnames[] = {
21460 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21461 };
21462
21463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21465 if (SWIG_arg_fail(1)) SWIG_fail;
21466 {
21467 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21468 temp2 = true;
21469 }
21470 if (obj2) {
21471 {
21472 arg3 = (bool)(SWIG_As_bool(obj2));
21473 if (SWIG_arg_fail(3)) SWIG_fail;
21474 }
21475 }
21476 {
21477 PyThreadState* __tstate = wxPyBeginAllowThreads();
21478 {
21479 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21480 result = (wxDateTime *) &_result_ref;
21481 }
21482
21483 wxPyEndAllowThreads(__tstate);
21484 if (PyErr_Occurred()) SWIG_fail;
21485 }
21486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21487 {
21488 if (temp2) delete arg2;
21489 }
21490 return resultobj;
21491 fail:
21492 {
21493 if (temp2) delete arg2;
21494 }
21495 return NULL;
21496 }
21497
21498
21499 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21500 PyObject *resultobj;
21501 wxDateTime *arg1 = (wxDateTime *) 0 ;
21502 bool arg2 = (bool) false ;
21503 wxDateTime result;
21504 PyObject * obj0 = 0 ;
21505 PyObject * obj1 = 0 ;
21506 char *kwnames[] = {
21507 (char *) "self",(char *) "noDST", NULL
21508 };
21509
21510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21512 if (SWIG_arg_fail(1)) SWIG_fail;
21513 if (obj1) {
21514 {
21515 arg2 = (bool)(SWIG_As_bool(obj1));
21516 if (SWIG_arg_fail(2)) SWIG_fail;
21517 }
21518 }
21519 {
21520 PyThreadState* __tstate = wxPyBeginAllowThreads();
21521 result = (arg1)->ToGMT(arg2);
21522
21523 wxPyEndAllowThreads(__tstate);
21524 if (PyErr_Occurred()) SWIG_fail;
21525 }
21526 {
21527 wxDateTime * resultptr;
21528 resultptr = new wxDateTime((wxDateTime &)(result));
21529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21530 }
21531 return resultobj;
21532 fail:
21533 return NULL;
21534 }
21535
21536
21537 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21538 PyObject *resultobj;
21539 wxDateTime *arg1 = (wxDateTime *) 0 ;
21540 bool arg2 = (bool) false ;
21541 wxDateTime *result;
21542 PyObject * obj0 = 0 ;
21543 PyObject * obj1 = 0 ;
21544 char *kwnames[] = {
21545 (char *) "self",(char *) "noDST", NULL
21546 };
21547
21548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21550 if (SWIG_arg_fail(1)) SWIG_fail;
21551 if (obj1) {
21552 {
21553 arg2 = (bool)(SWIG_As_bool(obj1));
21554 if (SWIG_arg_fail(2)) SWIG_fail;
21555 }
21556 }
21557 {
21558 PyThreadState* __tstate = wxPyBeginAllowThreads();
21559 {
21560 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21561 result = (wxDateTime *) &_result_ref;
21562 }
21563
21564 wxPyEndAllowThreads(__tstate);
21565 if (PyErr_Occurred()) SWIG_fail;
21566 }
21567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21568 return resultobj;
21569 fail:
21570 return NULL;
21571 }
21572
21573
21574 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21575 PyObject *resultobj;
21576 wxDateTime *arg1 = (wxDateTime *) 0 ;
21577 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21578 int result;
21579 PyObject * obj0 = 0 ;
21580 PyObject * obj1 = 0 ;
21581 char *kwnames[] = {
21582 (char *) "self",(char *) "country", NULL
21583 };
21584
21585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21587 if (SWIG_arg_fail(1)) SWIG_fail;
21588 if (obj1) {
21589 {
21590 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21591 if (SWIG_arg_fail(2)) SWIG_fail;
21592 }
21593 }
21594 {
21595 PyThreadState* __tstate = wxPyBeginAllowThreads();
21596 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21597
21598 wxPyEndAllowThreads(__tstate);
21599 if (PyErr_Occurred()) SWIG_fail;
21600 }
21601 {
21602 resultobj = SWIG_From_int((int)(result));
21603 }
21604 return resultobj;
21605 fail:
21606 return NULL;
21607 }
21608
21609
21610 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21611 PyObject *resultobj;
21612 wxDateTime *arg1 = (wxDateTime *) 0 ;
21613 bool result;
21614 PyObject * obj0 = 0 ;
21615 char *kwnames[] = {
21616 (char *) "self", NULL
21617 };
21618
21619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21621 if (SWIG_arg_fail(1)) SWIG_fail;
21622 {
21623 PyThreadState* __tstate = wxPyBeginAllowThreads();
21624 result = (bool)((wxDateTime const *)arg1)->IsValid();
21625
21626 wxPyEndAllowThreads(__tstate);
21627 if (PyErr_Occurred()) SWIG_fail;
21628 }
21629 {
21630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21631 }
21632 return resultobj;
21633 fail:
21634 return NULL;
21635 }
21636
21637
21638 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21639 PyObject *resultobj;
21640 wxDateTime *arg1 = (wxDateTime *) 0 ;
21641 time_t result;
21642 PyObject * obj0 = 0 ;
21643 char *kwnames[] = {
21644 (char *) "self", NULL
21645 };
21646
21647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21649 if (SWIG_arg_fail(1)) SWIG_fail;
21650 {
21651 PyThreadState* __tstate = wxPyBeginAllowThreads();
21652 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21653
21654 wxPyEndAllowThreads(__tstate);
21655 if (PyErr_Occurred()) SWIG_fail;
21656 }
21657 {
21658 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21659 }
21660 return resultobj;
21661 fail:
21662 return NULL;
21663 }
21664
21665
21666 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21667 PyObject *resultobj;
21668 wxDateTime *arg1 = (wxDateTime *) 0 ;
21669 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21670 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21671 int result;
21672 bool temp2 = false ;
21673 PyObject * obj0 = 0 ;
21674 PyObject * obj1 = 0 ;
21675 char *kwnames[] = {
21676 (char *) "self",(char *) "tz", NULL
21677 };
21678
21679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21681 if (SWIG_arg_fail(1)) SWIG_fail;
21682 if (obj1) {
21683 {
21684 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21685 temp2 = true;
21686 }
21687 }
21688 {
21689 PyThreadState* __tstate = wxPyBeginAllowThreads();
21690 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21691
21692 wxPyEndAllowThreads(__tstate);
21693 if (PyErr_Occurred()) SWIG_fail;
21694 }
21695 {
21696 resultobj = SWIG_From_int((int)(result));
21697 }
21698 {
21699 if (temp2) delete arg2;
21700 }
21701 return resultobj;
21702 fail:
21703 {
21704 if (temp2) delete arg2;
21705 }
21706 return NULL;
21707 }
21708
21709
21710 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21711 PyObject *resultobj;
21712 wxDateTime *arg1 = (wxDateTime *) 0 ;
21713 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21714 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21715 wxDateTime::Month result;
21716 bool temp2 = false ;
21717 PyObject * obj0 = 0 ;
21718 PyObject * obj1 = 0 ;
21719 char *kwnames[] = {
21720 (char *) "self",(char *) "tz", NULL
21721 };
21722
21723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21725 if (SWIG_arg_fail(1)) SWIG_fail;
21726 if (obj1) {
21727 {
21728 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21729 temp2 = true;
21730 }
21731 }
21732 {
21733 PyThreadState* __tstate = wxPyBeginAllowThreads();
21734 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21735
21736 wxPyEndAllowThreads(__tstate);
21737 if (PyErr_Occurred()) SWIG_fail;
21738 }
21739 resultobj = SWIG_From_int((result));
21740 {
21741 if (temp2) delete arg2;
21742 }
21743 return resultobj;
21744 fail:
21745 {
21746 if (temp2) delete arg2;
21747 }
21748 return NULL;
21749 }
21750
21751
21752 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21753 PyObject *resultobj;
21754 wxDateTime *arg1 = (wxDateTime *) 0 ;
21755 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21756 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21757 int result;
21758 bool temp2 = false ;
21759 PyObject * obj0 = 0 ;
21760 PyObject * obj1 = 0 ;
21761 char *kwnames[] = {
21762 (char *) "self",(char *) "tz", NULL
21763 };
21764
21765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21767 if (SWIG_arg_fail(1)) SWIG_fail;
21768 if (obj1) {
21769 {
21770 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21771 temp2 = true;
21772 }
21773 }
21774 {
21775 PyThreadState* __tstate = wxPyBeginAllowThreads();
21776 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21777
21778 wxPyEndAllowThreads(__tstate);
21779 if (PyErr_Occurred()) SWIG_fail;
21780 }
21781 {
21782 resultobj = SWIG_From_int((int)(result));
21783 }
21784 {
21785 if (temp2) delete arg2;
21786 }
21787 return resultobj;
21788 fail:
21789 {
21790 if (temp2) delete arg2;
21791 }
21792 return NULL;
21793 }
21794
21795
21796 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21797 PyObject *resultobj;
21798 wxDateTime *arg1 = (wxDateTime *) 0 ;
21799 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21800 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21801 wxDateTime::WeekDay result;
21802 bool temp2 = false ;
21803 PyObject * obj0 = 0 ;
21804 PyObject * obj1 = 0 ;
21805 char *kwnames[] = {
21806 (char *) "self",(char *) "tz", NULL
21807 };
21808
21809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21811 if (SWIG_arg_fail(1)) SWIG_fail;
21812 if (obj1) {
21813 {
21814 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21815 temp2 = true;
21816 }
21817 }
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21821
21822 wxPyEndAllowThreads(__tstate);
21823 if (PyErr_Occurred()) SWIG_fail;
21824 }
21825 resultobj = SWIG_From_int((result));
21826 {
21827 if (temp2) delete arg2;
21828 }
21829 return resultobj;
21830 fail:
21831 {
21832 if (temp2) delete arg2;
21833 }
21834 return NULL;
21835 }
21836
21837
21838 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21839 PyObject *resultobj;
21840 wxDateTime *arg1 = (wxDateTime *) 0 ;
21841 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21842 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21843 int result;
21844 bool temp2 = false ;
21845 PyObject * obj0 = 0 ;
21846 PyObject * obj1 = 0 ;
21847 char *kwnames[] = {
21848 (char *) "self",(char *) "tz", NULL
21849 };
21850
21851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21853 if (SWIG_arg_fail(1)) SWIG_fail;
21854 if (obj1) {
21855 {
21856 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21857 temp2 = true;
21858 }
21859 }
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21863
21864 wxPyEndAllowThreads(__tstate);
21865 if (PyErr_Occurred()) SWIG_fail;
21866 }
21867 {
21868 resultobj = SWIG_From_int((int)(result));
21869 }
21870 {
21871 if (temp2) delete arg2;
21872 }
21873 return resultobj;
21874 fail:
21875 {
21876 if (temp2) delete arg2;
21877 }
21878 return NULL;
21879 }
21880
21881
21882 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21883 PyObject *resultobj;
21884 wxDateTime *arg1 = (wxDateTime *) 0 ;
21885 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21886 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21887 int result;
21888 bool temp2 = false ;
21889 PyObject * obj0 = 0 ;
21890 PyObject * obj1 = 0 ;
21891 char *kwnames[] = {
21892 (char *) "self",(char *) "tz", NULL
21893 };
21894
21895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21897 if (SWIG_arg_fail(1)) SWIG_fail;
21898 if (obj1) {
21899 {
21900 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21901 temp2 = true;
21902 }
21903 }
21904 {
21905 PyThreadState* __tstate = wxPyBeginAllowThreads();
21906 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21907
21908 wxPyEndAllowThreads(__tstate);
21909 if (PyErr_Occurred()) SWIG_fail;
21910 }
21911 {
21912 resultobj = SWIG_From_int((int)(result));
21913 }
21914 {
21915 if (temp2) delete arg2;
21916 }
21917 return resultobj;
21918 fail:
21919 {
21920 if (temp2) delete arg2;
21921 }
21922 return NULL;
21923 }
21924
21925
21926 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21927 PyObject *resultobj;
21928 wxDateTime *arg1 = (wxDateTime *) 0 ;
21929 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21930 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21931 int result;
21932 bool temp2 = false ;
21933 PyObject * obj0 = 0 ;
21934 PyObject * obj1 = 0 ;
21935 char *kwnames[] = {
21936 (char *) "self",(char *) "tz", NULL
21937 };
21938
21939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21941 if (SWIG_arg_fail(1)) SWIG_fail;
21942 if (obj1) {
21943 {
21944 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21945 temp2 = true;
21946 }
21947 }
21948 {
21949 PyThreadState* __tstate = wxPyBeginAllowThreads();
21950 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21951
21952 wxPyEndAllowThreads(__tstate);
21953 if (PyErr_Occurred()) SWIG_fail;
21954 }
21955 {
21956 resultobj = SWIG_From_int((int)(result));
21957 }
21958 {
21959 if (temp2) delete arg2;
21960 }
21961 return resultobj;
21962 fail:
21963 {
21964 if (temp2) delete arg2;
21965 }
21966 return NULL;
21967 }
21968
21969
21970 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21971 PyObject *resultobj;
21972 wxDateTime *arg1 = (wxDateTime *) 0 ;
21973 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21974 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21975 int result;
21976 bool temp2 = false ;
21977 PyObject * obj0 = 0 ;
21978 PyObject * obj1 = 0 ;
21979 char *kwnames[] = {
21980 (char *) "self",(char *) "tz", NULL
21981 };
21982
21983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21985 if (SWIG_arg_fail(1)) SWIG_fail;
21986 if (obj1) {
21987 {
21988 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21989 temp2 = true;
21990 }
21991 }
21992 {
21993 PyThreadState* __tstate = wxPyBeginAllowThreads();
21994 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21995
21996 wxPyEndAllowThreads(__tstate);
21997 if (PyErr_Occurred()) SWIG_fail;
21998 }
21999 {
22000 resultobj = SWIG_From_int((int)(result));
22001 }
22002 {
22003 if (temp2) delete arg2;
22004 }
22005 return resultobj;
22006 fail:
22007 {
22008 if (temp2) delete arg2;
22009 }
22010 return NULL;
22011 }
22012
22013
22014 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
22015 PyObject *resultobj;
22016 wxDateTime *arg1 = (wxDateTime *) 0 ;
22017 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22018 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22019 int result;
22020 bool temp2 = false ;
22021 PyObject * obj0 = 0 ;
22022 PyObject * obj1 = 0 ;
22023 char *kwnames[] = {
22024 (char *) "self",(char *) "tz", NULL
22025 };
22026
22027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
22028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22029 if (SWIG_arg_fail(1)) SWIG_fail;
22030 if (obj1) {
22031 {
22032 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22033 temp2 = true;
22034 }
22035 }
22036 {
22037 PyThreadState* __tstate = wxPyBeginAllowThreads();
22038 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
22039
22040 wxPyEndAllowThreads(__tstate);
22041 if (PyErr_Occurred()) SWIG_fail;
22042 }
22043 {
22044 resultobj = SWIG_From_int((int)(result));
22045 }
22046 {
22047 if (temp2) delete arg2;
22048 }
22049 return resultobj;
22050 fail:
22051 {
22052 if (temp2) delete arg2;
22053 }
22054 return NULL;
22055 }
22056
22057
22058 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
22059 PyObject *resultobj;
22060 wxDateTime *arg1 = (wxDateTime *) 0 ;
22061 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22062 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22063 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22064 int result;
22065 bool temp3 = false ;
22066 PyObject * obj0 = 0 ;
22067 PyObject * obj1 = 0 ;
22068 PyObject * obj2 = 0 ;
22069 char *kwnames[] = {
22070 (char *) "self",(char *) "flags",(char *) "tz", NULL
22071 };
22072
22073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
22074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22075 if (SWIG_arg_fail(1)) SWIG_fail;
22076 if (obj1) {
22077 {
22078 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22079 if (SWIG_arg_fail(2)) SWIG_fail;
22080 }
22081 }
22082 if (obj2) {
22083 {
22084 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22085 temp3 = true;
22086 }
22087 }
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22091
22092 wxPyEndAllowThreads(__tstate);
22093 if (PyErr_Occurred()) SWIG_fail;
22094 }
22095 {
22096 resultobj = SWIG_From_int((int)(result));
22097 }
22098 {
22099 if (temp3) delete arg3;
22100 }
22101 return resultobj;
22102 fail:
22103 {
22104 if (temp3) delete arg3;
22105 }
22106 return NULL;
22107 }
22108
22109
22110 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22111 PyObject *resultobj;
22112 wxDateTime *arg1 = (wxDateTime *) 0 ;
22113 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22114 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22115 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22116 int result;
22117 bool temp3 = false ;
22118 PyObject * obj0 = 0 ;
22119 PyObject * obj1 = 0 ;
22120 PyObject * obj2 = 0 ;
22121 char *kwnames[] = {
22122 (char *) "self",(char *) "flags",(char *) "tz", NULL
22123 };
22124
22125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22127 if (SWIG_arg_fail(1)) SWIG_fail;
22128 if (obj1) {
22129 {
22130 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22131 if (SWIG_arg_fail(2)) SWIG_fail;
22132 }
22133 }
22134 if (obj2) {
22135 {
22136 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22137 temp3 = true;
22138 }
22139 }
22140 {
22141 PyThreadState* __tstate = wxPyBeginAllowThreads();
22142 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22143
22144 wxPyEndAllowThreads(__tstate);
22145 if (PyErr_Occurred()) SWIG_fail;
22146 }
22147 {
22148 resultobj = SWIG_From_int((int)(result));
22149 }
22150 {
22151 if (temp3) delete arg3;
22152 }
22153 return resultobj;
22154 fail:
22155 {
22156 if (temp3) delete arg3;
22157 }
22158 return NULL;
22159 }
22160
22161
22162 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22163 PyObject *resultobj;
22164 wxDateTime *arg1 = (wxDateTime *) 0 ;
22165 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22166 bool result;
22167 PyObject * obj0 = 0 ;
22168 PyObject * obj1 = 0 ;
22169 char *kwnames[] = {
22170 (char *) "self",(char *) "country", NULL
22171 };
22172
22173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22175 if (SWIG_arg_fail(1)) SWIG_fail;
22176 if (obj1) {
22177 {
22178 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22179 if (SWIG_arg_fail(2)) SWIG_fail;
22180 }
22181 }
22182 {
22183 PyThreadState* __tstate = wxPyBeginAllowThreads();
22184 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22185
22186 wxPyEndAllowThreads(__tstate);
22187 if (PyErr_Occurred()) SWIG_fail;
22188 }
22189 {
22190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22191 }
22192 return resultobj;
22193 fail:
22194 return NULL;
22195 }
22196
22197
22198 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22199 PyObject *resultobj;
22200 wxDateTime *arg1 = (wxDateTime *) 0 ;
22201 wxDateTime *arg2 = 0 ;
22202 bool result;
22203 PyObject * obj0 = 0 ;
22204 PyObject * obj1 = 0 ;
22205 char *kwnames[] = {
22206 (char *) "self",(char *) "datetime", NULL
22207 };
22208
22209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22211 if (SWIG_arg_fail(1)) SWIG_fail;
22212 {
22213 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22214 if (SWIG_arg_fail(2)) SWIG_fail;
22215 if (arg2 == NULL) {
22216 SWIG_null_ref("wxDateTime");
22217 }
22218 if (SWIG_arg_fail(2)) SWIG_fail;
22219 }
22220 {
22221 PyThreadState* __tstate = wxPyBeginAllowThreads();
22222 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22223
22224 wxPyEndAllowThreads(__tstate);
22225 if (PyErr_Occurred()) SWIG_fail;
22226 }
22227 {
22228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22229 }
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22237 PyObject *resultobj;
22238 wxDateTime *arg1 = (wxDateTime *) 0 ;
22239 wxDateTime *arg2 = 0 ;
22240 bool result;
22241 PyObject * obj0 = 0 ;
22242 PyObject * obj1 = 0 ;
22243 char *kwnames[] = {
22244 (char *) "self",(char *) "datetime", NULL
22245 };
22246
22247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22249 if (SWIG_arg_fail(1)) SWIG_fail;
22250 {
22251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22252 if (SWIG_arg_fail(2)) SWIG_fail;
22253 if (arg2 == NULL) {
22254 SWIG_null_ref("wxDateTime");
22255 }
22256 if (SWIG_arg_fail(2)) SWIG_fail;
22257 }
22258 {
22259 PyThreadState* __tstate = wxPyBeginAllowThreads();
22260 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22261
22262 wxPyEndAllowThreads(__tstate);
22263 if (PyErr_Occurred()) SWIG_fail;
22264 }
22265 {
22266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22267 }
22268 return resultobj;
22269 fail:
22270 return NULL;
22271 }
22272
22273
22274 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22275 PyObject *resultobj;
22276 wxDateTime *arg1 = (wxDateTime *) 0 ;
22277 wxDateTime *arg2 = 0 ;
22278 bool result;
22279 PyObject * obj0 = 0 ;
22280 PyObject * obj1 = 0 ;
22281 char *kwnames[] = {
22282 (char *) "self",(char *) "datetime", NULL
22283 };
22284
22285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22287 if (SWIG_arg_fail(1)) SWIG_fail;
22288 {
22289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22290 if (SWIG_arg_fail(2)) SWIG_fail;
22291 if (arg2 == NULL) {
22292 SWIG_null_ref("wxDateTime");
22293 }
22294 if (SWIG_arg_fail(2)) SWIG_fail;
22295 }
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22299
22300 wxPyEndAllowThreads(__tstate);
22301 if (PyErr_Occurred()) SWIG_fail;
22302 }
22303 {
22304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22305 }
22306 return resultobj;
22307 fail:
22308 return NULL;
22309 }
22310
22311
22312 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22313 PyObject *resultobj;
22314 wxDateTime *arg1 = (wxDateTime *) 0 ;
22315 wxDateTime *arg2 = 0 ;
22316 wxDateTime *arg3 = 0 ;
22317 bool result;
22318 PyObject * obj0 = 0 ;
22319 PyObject * obj1 = 0 ;
22320 PyObject * obj2 = 0 ;
22321 char *kwnames[] = {
22322 (char *) "self",(char *) "t1",(char *) "t2", NULL
22323 };
22324
22325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22327 if (SWIG_arg_fail(1)) SWIG_fail;
22328 {
22329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22330 if (SWIG_arg_fail(2)) SWIG_fail;
22331 if (arg2 == NULL) {
22332 SWIG_null_ref("wxDateTime");
22333 }
22334 if (SWIG_arg_fail(2)) SWIG_fail;
22335 }
22336 {
22337 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22338 if (SWIG_arg_fail(3)) SWIG_fail;
22339 if (arg3 == NULL) {
22340 SWIG_null_ref("wxDateTime");
22341 }
22342 if (SWIG_arg_fail(3)) SWIG_fail;
22343 }
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22347
22348 wxPyEndAllowThreads(__tstate);
22349 if (PyErr_Occurred()) SWIG_fail;
22350 }
22351 {
22352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22353 }
22354 return resultobj;
22355 fail:
22356 return NULL;
22357 }
22358
22359
22360 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22361 PyObject *resultobj;
22362 wxDateTime *arg1 = (wxDateTime *) 0 ;
22363 wxDateTime *arg2 = 0 ;
22364 wxDateTime *arg3 = 0 ;
22365 bool result;
22366 PyObject * obj0 = 0 ;
22367 PyObject * obj1 = 0 ;
22368 PyObject * obj2 = 0 ;
22369 char *kwnames[] = {
22370 (char *) "self",(char *) "t1",(char *) "t2", NULL
22371 };
22372
22373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22375 if (SWIG_arg_fail(1)) SWIG_fail;
22376 {
22377 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22378 if (SWIG_arg_fail(2)) SWIG_fail;
22379 if (arg2 == NULL) {
22380 SWIG_null_ref("wxDateTime");
22381 }
22382 if (SWIG_arg_fail(2)) SWIG_fail;
22383 }
22384 {
22385 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22386 if (SWIG_arg_fail(3)) SWIG_fail;
22387 if (arg3 == NULL) {
22388 SWIG_null_ref("wxDateTime");
22389 }
22390 if (SWIG_arg_fail(3)) SWIG_fail;
22391 }
22392 {
22393 PyThreadState* __tstate = wxPyBeginAllowThreads();
22394 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22395
22396 wxPyEndAllowThreads(__tstate);
22397 if (PyErr_Occurred()) SWIG_fail;
22398 }
22399 {
22400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22401 }
22402 return resultobj;
22403 fail:
22404 return NULL;
22405 }
22406
22407
22408 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22409 PyObject *resultobj;
22410 wxDateTime *arg1 = (wxDateTime *) 0 ;
22411 wxDateTime *arg2 = 0 ;
22412 bool result;
22413 PyObject * obj0 = 0 ;
22414 PyObject * obj1 = 0 ;
22415 char *kwnames[] = {
22416 (char *) "self",(char *) "dt", NULL
22417 };
22418
22419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22421 if (SWIG_arg_fail(1)) SWIG_fail;
22422 {
22423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22424 if (SWIG_arg_fail(2)) SWIG_fail;
22425 if (arg2 == NULL) {
22426 SWIG_null_ref("wxDateTime");
22427 }
22428 if (SWIG_arg_fail(2)) SWIG_fail;
22429 }
22430 {
22431 PyThreadState* __tstate = wxPyBeginAllowThreads();
22432 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22433
22434 wxPyEndAllowThreads(__tstate);
22435 if (PyErr_Occurred()) SWIG_fail;
22436 }
22437 {
22438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22439 }
22440 return resultobj;
22441 fail:
22442 return NULL;
22443 }
22444
22445
22446 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22447 PyObject *resultobj;
22448 wxDateTime *arg1 = (wxDateTime *) 0 ;
22449 wxDateTime *arg2 = 0 ;
22450 bool result;
22451 PyObject * obj0 = 0 ;
22452 PyObject * obj1 = 0 ;
22453 char *kwnames[] = {
22454 (char *) "self",(char *) "dt", NULL
22455 };
22456
22457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22459 if (SWIG_arg_fail(1)) SWIG_fail;
22460 {
22461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22462 if (SWIG_arg_fail(2)) SWIG_fail;
22463 if (arg2 == NULL) {
22464 SWIG_null_ref("wxDateTime");
22465 }
22466 if (SWIG_arg_fail(2)) SWIG_fail;
22467 }
22468 {
22469 PyThreadState* __tstate = wxPyBeginAllowThreads();
22470 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22471
22472 wxPyEndAllowThreads(__tstate);
22473 if (PyErr_Occurred()) SWIG_fail;
22474 }
22475 {
22476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22477 }
22478 return resultobj;
22479 fail:
22480 return NULL;
22481 }
22482
22483
22484 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22485 PyObject *resultobj;
22486 wxDateTime *arg1 = (wxDateTime *) 0 ;
22487 wxDateTime *arg2 = 0 ;
22488 wxTimeSpan *arg3 = 0 ;
22489 bool result;
22490 PyObject * obj0 = 0 ;
22491 PyObject * obj1 = 0 ;
22492 PyObject * obj2 = 0 ;
22493 char *kwnames[] = {
22494 (char *) "self",(char *) "dt",(char *) "ts", NULL
22495 };
22496
22497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22499 if (SWIG_arg_fail(1)) SWIG_fail;
22500 {
22501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22502 if (SWIG_arg_fail(2)) SWIG_fail;
22503 if (arg2 == NULL) {
22504 SWIG_null_ref("wxDateTime");
22505 }
22506 if (SWIG_arg_fail(2)) SWIG_fail;
22507 }
22508 {
22509 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22510 if (SWIG_arg_fail(3)) SWIG_fail;
22511 if (arg3 == NULL) {
22512 SWIG_null_ref("wxTimeSpan");
22513 }
22514 if (SWIG_arg_fail(3)) SWIG_fail;
22515 }
22516 {
22517 PyThreadState* __tstate = wxPyBeginAllowThreads();
22518 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22519
22520 wxPyEndAllowThreads(__tstate);
22521 if (PyErr_Occurred()) SWIG_fail;
22522 }
22523 {
22524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22525 }
22526 return resultobj;
22527 fail:
22528 return NULL;
22529 }
22530
22531
22532 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22533 PyObject *resultobj;
22534 wxDateTime *arg1 = (wxDateTime *) 0 ;
22535 wxTimeSpan *arg2 = 0 ;
22536 wxDateTime *result;
22537 PyObject * obj0 = 0 ;
22538 PyObject * obj1 = 0 ;
22539 char *kwnames[] = {
22540 (char *) "self",(char *) "diff", NULL
22541 };
22542
22543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22545 if (SWIG_arg_fail(1)) SWIG_fail;
22546 {
22547 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22548 if (SWIG_arg_fail(2)) SWIG_fail;
22549 if (arg2 == NULL) {
22550 SWIG_null_ref("wxTimeSpan");
22551 }
22552 if (SWIG_arg_fail(2)) SWIG_fail;
22553 }
22554 {
22555 PyThreadState* __tstate = wxPyBeginAllowThreads();
22556 {
22557 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22558 result = (wxDateTime *) &_result_ref;
22559 }
22560
22561 wxPyEndAllowThreads(__tstate);
22562 if (PyErr_Occurred()) SWIG_fail;
22563 }
22564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22565 return resultobj;
22566 fail:
22567 return NULL;
22568 }
22569
22570
22571 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22572 PyObject *resultobj;
22573 wxDateTime *arg1 = (wxDateTime *) 0 ;
22574 wxDateSpan *arg2 = 0 ;
22575 wxDateTime *result;
22576 PyObject * obj0 = 0 ;
22577 PyObject * obj1 = 0 ;
22578 char *kwnames[] = {
22579 (char *) "self",(char *) "diff", NULL
22580 };
22581
22582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22584 if (SWIG_arg_fail(1)) SWIG_fail;
22585 {
22586 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22587 if (SWIG_arg_fail(2)) SWIG_fail;
22588 if (arg2 == NULL) {
22589 SWIG_null_ref("wxDateSpan");
22590 }
22591 if (SWIG_arg_fail(2)) SWIG_fail;
22592 }
22593 {
22594 PyThreadState* __tstate = wxPyBeginAllowThreads();
22595 {
22596 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22597 result = (wxDateTime *) &_result_ref;
22598 }
22599
22600 wxPyEndAllowThreads(__tstate);
22601 if (PyErr_Occurred()) SWIG_fail;
22602 }
22603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22604 return resultobj;
22605 fail:
22606 return NULL;
22607 }
22608
22609
22610 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22611 PyObject *resultobj;
22612 wxDateTime *arg1 = (wxDateTime *) 0 ;
22613 wxTimeSpan *arg2 = 0 ;
22614 wxDateTime *result;
22615 PyObject * obj0 = 0 ;
22616 PyObject * obj1 = 0 ;
22617 char *kwnames[] = {
22618 (char *) "self",(char *) "diff", NULL
22619 };
22620
22621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22623 if (SWIG_arg_fail(1)) SWIG_fail;
22624 {
22625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22626 if (SWIG_arg_fail(2)) SWIG_fail;
22627 if (arg2 == NULL) {
22628 SWIG_null_ref("wxTimeSpan");
22629 }
22630 if (SWIG_arg_fail(2)) SWIG_fail;
22631 }
22632 {
22633 PyThreadState* __tstate = wxPyBeginAllowThreads();
22634 {
22635 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22636 result = (wxDateTime *) &_result_ref;
22637 }
22638
22639 wxPyEndAllowThreads(__tstate);
22640 if (PyErr_Occurred()) SWIG_fail;
22641 }
22642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj;
22651 wxDateTime *arg1 = (wxDateTime *) 0 ;
22652 wxDateSpan *arg2 = 0 ;
22653 wxDateTime *result;
22654 PyObject * obj0 = 0 ;
22655 PyObject * obj1 = 0 ;
22656 char *kwnames[] = {
22657 (char *) "self",(char *) "diff", NULL
22658 };
22659
22660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22662 if (SWIG_arg_fail(1)) SWIG_fail;
22663 {
22664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22665 if (SWIG_arg_fail(2)) SWIG_fail;
22666 if (arg2 == NULL) {
22667 SWIG_null_ref("wxDateSpan");
22668 }
22669 if (SWIG_arg_fail(2)) SWIG_fail;
22670 }
22671 {
22672 PyThreadState* __tstate = wxPyBeginAllowThreads();
22673 {
22674 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22675 result = (wxDateTime *) &_result_ref;
22676 }
22677
22678 wxPyEndAllowThreads(__tstate);
22679 if (PyErr_Occurred()) SWIG_fail;
22680 }
22681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22682 return resultobj;
22683 fail:
22684 return NULL;
22685 }
22686
22687
22688 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22689 PyObject *resultobj;
22690 wxDateTime *arg1 = (wxDateTime *) 0 ;
22691 wxDateTime *arg2 = 0 ;
22692 wxTimeSpan result;
22693 PyObject * obj0 = 0 ;
22694 PyObject * obj1 = 0 ;
22695 char *kwnames[] = {
22696 (char *) "self",(char *) "dt", NULL
22697 };
22698
22699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22701 if (SWIG_arg_fail(1)) SWIG_fail;
22702 {
22703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22704 if (SWIG_arg_fail(2)) SWIG_fail;
22705 if (arg2 == NULL) {
22706 SWIG_null_ref("wxDateTime");
22707 }
22708 if (SWIG_arg_fail(2)) SWIG_fail;
22709 }
22710 {
22711 PyThreadState* __tstate = wxPyBeginAllowThreads();
22712 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22713
22714 wxPyEndAllowThreads(__tstate);
22715 if (PyErr_Occurred()) SWIG_fail;
22716 }
22717 {
22718 wxTimeSpan * resultptr;
22719 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22720 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22721 }
22722 return resultobj;
22723 fail:
22724 return NULL;
22725 }
22726
22727
22728 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22729 PyObject *resultobj;
22730 wxDateTime *arg1 = (wxDateTime *) 0 ;
22731 wxTimeSpan *arg2 = 0 ;
22732 wxDateTime *result;
22733 PyObject * obj0 = 0 ;
22734 PyObject * obj1 = 0 ;
22735
22736 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22738 if (SWIG_arg_fail(1)) SWIG_fail;
22739 {
22740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22741 if (SWIG_arg_fail(2)) SWIG_fail;
22742 if (arg2 == NULL) {
22743 SWIG_null_ref("wxTimeSpan");
22744 }
22745 if (SWIG_arg_fail(2)) SWIG_fail;
22746 }
22747 {
22748 PyThreadState* __tstate = wxPyBeginAllowThreads();
22749 {
22750 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22751 result = (wxDateTime *) &_result_ref;
22752 }
22753
22754 wxPyEndAllowThreads(__tstate);
22755 if (PyErr_Occurred()) SWIG_fail;
22756 }
22757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22758 return resultobj;
22759 fail:
22760 return NULL;
22761 }
22762
22763
22764 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22765 PyObject *resultobj;
22766 wxDateTime *arg1 = (wxDateTime *) 0 ;
22767 wxDateSpan *arg2 = 0 ;
22768 wxDateTime *result;
22769 PyObject * obj0 = 0 ;
22770 PyObject * obj1 = 0 ;
22771
22772 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22774 if (SWIG_arg_fail(1)) SWIG_fail;
22775 {
22776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22777 if (SWIG_arg_fail(2)) SWIG_fail;
22778 if (arg2 == NULL) {
22779 SWIG_null_ref("wxDateSpan");
22780 }
22781 if (SWIG_arg_fail(2)) SWIG_fail;
22782 }
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 {
22786 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22787 result = (wxDateTime *) &_result_ref;
22788 }
22789
22790 wxPyEndAllowThreads(__tstate);
22791 if (PyErr_Occurred()) SWIG_fail;
22792 }
22793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22794 return resultobj;
22795 fail:
22796 return NULL;
22797 }
22798
22799
22800 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22801 int argc;
22802 PyObject *argv[3];
22803 int ii;
22804
22805 argc = PyObject_Length(args);
22806 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22807 argv[ii] = PyTuple_GetItem(args,ii);
22808 }
22809 if (argc == 2) {
22810 int _v;
22811 {
22812 void *ptr;
22813 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22814 _v = 0;
22815 PyErr_Clear();
22816 } else {
22817 _v = 1;
22818 }
22819 }
22820 if (_v) {
22821 {
22822 void *ptr = 0;
22823 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22824 _v = 0;
22825 PyErr_Clear();
22826 } else {
22827 _v = (ptr != 0);
22828 }
22829 }
22830 if (_v) {
22831 return _wrap_DateTime___iadd____SWIG_0(self,args);
22832 }
22833 }
22834 }
22835 if (argc == 2) {
22836 int _v;
22837 {
22838 void *ptr;
22839 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22840 _v = 0;
22841 PyErr_Clear();
22842 } else {
22843 _v = 1;
22844 }
22845 }
22846 if (_v) {
22847 {
22848 void *ptr = 0;
22849 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22850 _v = 0;
22851 PyErr_Clear();
22852 } else {
22853 _v = (ptr != 0);
22854 }
22855 }
22856 if (_v) {
22857 return _wrap_DateTime___iadd____SWIG_1(self,args);
22858 }
22859 }
22860 }
22861
22862 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22863 return NULL;
22864 }
22865
22866
22867 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22868 PyObject *resultobj;
22869 wxDateTime *arg1 = (wxDateTime *) 0 ;
22870 wxTimeSpan *arg2 = 0 ;
22871 wxDateTime *result;
22872 PyObject * obj0 = 0 ;
22873 PyObject * obj1 = 0 ;
22874
22875 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22877 if (SWIG_arg_fail(1)) SWIG_fail;
22878 {
22879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22880 if (SWIG_arg_fail(2)) SWIG_fail;
22881 if (arg2 == NULL) {
22882 SWIG_null_ref("wxTimeSpan");
22883 }
22884 if (SWIG_arg_fail(2)) SWIG_fail;
22885 }
22886 {
22887 PyThreadState* __tstate = wxPyBeginAllowThreads();
22888 {
22889 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22890 result = (wxDateTime *) &_result_ref;
22891 }
22892
22893 wxPyEndAllowThreads(__tstate);
22894 if (PyErr_Occurred()) SWIG_fail;
22895 }
22896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22897 return resultobj;
22898 fail:
22899 return NULL;
22900 }
22901
22902
22903 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22904 PyObject *resultobj;
22905 wxDateTime *arg1 = (wxDateTime *) 0 ;
22906 wxDateSpan *arg2 = 0 ;
22907 wxDateTime *result;
22908 PyObject * obj0 = 0 ;
22909 PyObject * obj1 = 0 ;
22910
22911 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22913 if (SWIG_arg_fail(1)) SWIG_fail;
22914 {
22915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22916 if (SWIG_arg_fail(2)) SWIG_fail;
22917 if (arg2 == NULL) {
22918 SWIG_null_ref("wxDateSpan");
22919 }
22920 if (SWIG_arg_fail(2)) SWIG_fail;
22921 }
22922 {
22923 PyThreadState* __tstate = wxPyBeginAllowThreads();
22924 {
22925 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22926 result = (wxDateTime *) &_result_ref;
22927 }
22928
22929 wxPyEndAllowThreads(__tstate);
22930 if (PyErr_Occurred()) SWIG_fail;
22931 }
22932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22933 return resultobj;
22934 fail:
22935 return NULL;
22936 }
22937
22938
22939 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22940 int argc;
22941 PyObject *argv[3];
22942 int ii;
22943
22944 argc = PyObject_Length(args);
22945 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22946 argv[ii] = PyTuple_GetItem(args,ii);
22947 }
22948 if (argc == 2) {
22949 int _v;
22950 {
22951 void *ptr;
22952 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22953 _v = 0;
22954 PyErr_Clear();
22955 } else {
22956 _v = 1;
22957 }
22958 }
22959 if (_v) {
22960 {
22961 void *ptr = 0;
22962 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22963 _v = 0;
22964 PyErr_Clear();
22965 } else {
22966 _v = (ptr != 0);
22967 }
22968 }
22969 if (_v) {
22970 return _wrap_DateTime___isub____SWIG_0(self,args);
22971 }
22972 }
22973 }
22974 if (argc == 2) {
22975 int _v;
22976 {
22977 void *ptr;
22978 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22979 _v = 0;
22980 PyErr_Clear();
22981 } else {
22982 _v = 1;
22983 }
22984 }
22985 if (_v) {
22986 {
22987 void *ptr = 0;
22988 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22989 _v = 0;
22990 PyErr_Clear();
22991 } else {
22992 _v = (ptr != 0);
22993 }
22994 }
22995 if (_v) {
22996 return _wrap_DateTime___isub____SWIG_1(self,args);
22997 }
22998 }
22999 }
23000
23001 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
23002 return NULL;
23003 }
23004
23005
23006 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
23007 PyObject *resultobj;
23008 wxDateTime *arg1 = (wxDateTime *) 0 ;
23009 wxTimeSpan *arg2 = 0 ;
23010 wxDateTime result;
23011 PyObject * obj0 = 0 ;
23012 PyObject * obj1 = 0 ;
23013
23014 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
23015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23016 if (SWIG_arg_fail(1)) SWIG_fail;
23017 {
23018 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23019 if (SWIG_arg_fail(2)) SWIG_fail;
23020 if (arg2 == NULL) {
23021 SWIG_null_ref("wxTimeSpan");
23022 }
23023 if (SWIG_arg_fail(2)) SWIG_fail;
23024 }
23025 {
23026 PyThreadState* __tstate = wxPyBeginAllowThreads();
23027 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
23028
23029 wxPyEndAllowThreads(__tstate);
23030 if (PyErr_Occurred()) SWIG_fail;
23031 }
23032 {
23033 wxDateTime * resultptr;
23034 resultptr = new wxDateTime((wxDateTime &)(result));
23035 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23036 }
23037 return resultobj;
23038 fail:
23039 return NULL;
23040 }
23041
23042
23043 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
23044 PyObject *resultobj;
23045 wxDateTime *arg1 = (wxDateTime *) 0 ;
23046 wxDateSpan *arg2 = 0 ;
23047 wxDateTime result;
23048 PyObject * obj0 = 0 ;
23049 PyObject * obj1 = 0 ;
23050
23051 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
23052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23053 if (SWIG_arg_fail(1)) SWIG_fail;
23054 {
23055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23056 if (SWIG_arg_fail(2)) SWIG_fail;
23057 if (arg2 == NULL) {
23058 SWIG_null_ref("wxDateSpan");
23059 }
23060 if (SWIG_arg_fail(2)) SWIG_fail;
23061 }
23062 {
23063 PyThreadState* __tstate = wxPyBeginAllowThreads();
23064 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
23065
23066 wxPyEndAllowThreads(__tstate);
23067 if (PyErr_Occurred()) SWIG_fail;
23068 }
23069 {
23070 wxDateTime * resultptr;
23071 resultptr = new wxDateTime((wxDateTime &)(result));
23072 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23073 }
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
23081 int argc;
23082 PyObject *argv[3];
23083 int ii;
23084
23085 argc = PyObject_Length(args);
23086 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23087 argv[ii] = PyTuple_GetItem(args,ii);
23088 }
23089 if (argc == 2) {
23090 int _v;
23091 {
23092 void *ptr;
23093 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23094 _v = 0;
23095 PyErr_Clear();
23096 } else {
23097 _v = 1;
23098 }
23099 }
23100 if (_v) {
23101 {
23102 void *ptr = 0;
23103 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23104 _v = 0;
23105 PyErr_Clear();
23106 } else {
23107 _v = (ptr != 0);
23108 }
23109 }
23110 if (_v) {
23111 return _wrap_DateTime___add____SWIG_0(self,args);
23112 }
23113 }
23114 }
23115 if (argc == 2) {
23116 int _v;
23117 {
23118 void *ptr;
23119 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23120 _v = 0;
23121 PyErr_Clear();
23122 } else {
23123 _v = 1;
23124 }
23125 }
23126 if (_v) {
23127 {
23128 void *ptr = 0;
23129 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23130 _v = 0;
23131 PyErr_Clear();
23132 } else {
23133 _v = (ptr != 0);
23134 }
23135 }
23136 if (_v) {
23137 return _wrap_DateTime___add____SWIG_1(self,args);
23138 }
23139 }
23140 }
23141
23142 Py_INCREF(Py_NotImplemented);
23143 return Py_NotImplemented;
23144 }
23145
23146
23147 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23148 PyObject *resultobj;
23149 wxDateTime *arg1 = (wxDateTime *) 0 ;
23150 wxDateTime *arg2 = 0 ;
23151 wxTimeSpan result;
23152 PyObject * obj0 = 0 ;
23153 PyObject * obj1 = 0 ;
23154
23155 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23157 if (SWIG_arg_fail(1)) SWIG_fail;
23158 {
23159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23160 if (SWIG_arg_fail(2)) SWIG_fail;
23161 if (arg2 == NULL) {
23162 SWIG_null_ref("wxDateTime");
23163 }
23164 if (SWIG_arg_fail(2)) SWIG_fail;
23165 }
23166 {
23167 PyThreadState* __tstate = wxPyBeginAllowThreads();
23168 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23169
23170 wxPyEndAllowThreads(__tstate);
23171 if (PyErr_Occurred()) SWIG_fail;
23172 }
23173 {
23174 wxTimeSpan * resultptr;
23175 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23176 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23177 }
23178 return resultobj;
23179 fail:
23180 return NULL;
23181 }
23182
23183
23184 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23185 PyObject *resultobj;
23186 wxDateTime *arg1 = (wxDateTime *) 0 ;
23187 wxTimeSpan *arg2 = 0 ;
23188 wxDateTime result;
23189 PyObject * obj0 = 0 ;
23190 PyObject * obj1 = 0 ;
23191
23192 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23194 if (SWIG_arg_fail(1)) SWIG_fail;
23195 {
23196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23197 if (SWIG_arg_fail(2)) SWIG_fail;
23198 if (arg2 == NULL) {
23199 SWIG_null_ref("wxTimeSpan");
23200 }
23201 if (SWIG_arg_fail(2)) SWIG_fail;
23202 }
23203 {
23204 PyThreadState* __tstate = wxPyBeginAllowThreads();
23205 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23206
23207 wxPyEndAllowThreads(__tstate);
23208 if (PyErr_Occurred()) SWIG_fail;
23209 }
23210 {
23211 wxDateTime * resultptr;
23212 resultptr = new wxDateTime((wxDateTime &)(result));
23213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23214 }
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23222 PyObject *resultobj;
23223 wxDateTime *arg1 = (wxDateTime *) 0 ;
23224 wxDateSpan *arg2 = 0 ;
23225 wxDateTime result;
23226 PyObject * obj0 = 0 ;
23227 PyObject * obj1 = 0 ;
23228
23229 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23231 if (SWIG_arg_fail(1)) SWIG_fail;
23232 {
23233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23234 if (SWIG_arg_fail(2)) SWIG_fail;
23235 if (arg2 == NULL) {
23236 SWIG_null_ref("wxDateSpan");
23237 }
23238 if (SWIG_arg_fail(2)) SWIG_fail;
23239 }
23240 {
23241 PyThreadState* __tstate = wxPyBeginAllowThreads();
23242 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23243
23244 wxPyEndAllowThreads(__tstate);
23245 if (PyErr_Occurred()) SWIG_fail;
23246 }
23247 {
23248 wxDateTime * resultptr;
23249 resultptr = new wxDateTime((wxDateTime &)(result));
23250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23251 }
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23259 int argc;
23260 PyObject *argv[3];
23261 int ii;
23262
23263 argc = PyObject_Length(args);
23264 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23265 argv[ii] = PyTuple_GetItem(args,ii);
23266 }
23267 if (argc == 2) {
23268 int _v;
23269 {
23270 void *ptr;
23271 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23272 _v = 0;
23273 PyErr_Clear();
23274 } else {
23275 _v = 1;
23276 }
23277 }
23278 if (_v) {
23279 {
23280 void *ptr = 0;
23281 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23282 _v = 0;
23283 PyErr_Clear();
23284 } else {
23285 _v = (ptr != 0);
23286 }
23287 }
23288 if (_v) {
23289 return _wrap_DateTime___sub____SWIG_0(self,args);
23290 }
23291 }
23292 }
23293 if (argc == 2) {
23294 int _v;
23295 {
23296 void *ptr;
23297 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23298 _v = 0;
23299 PyErr_Clear();
23300 } else {
23301 _v = 1;
23302 }
23303 }
23304 if (_v) {
23305 {
23306 void *ptr = 0;
23307 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23308 _v = 0;
23309 PyErr_Clear();
23310 } else {
23311 _v = (ptr != 0);
23312 }
23313 }
23314 if (_v) {
23315 return _wrap_DateTime___sub____SWIG_1(self,args);
23316 }
23317 }
23318 }
23319 if (argc == 2) {
23320 int _v;
23321 {
23322 void *ptr;
23323 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23324 _v = 0;
23325 PyErr_Clear();
23326 } else {
23327 _v = 1;
23328 }
23329 }
23330 if (_v) {
23331 {
23332 void *ptr = 0;
23333 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23334 _v = 0;
23335 PyErr_Clear();
23336 } else {
23337 _v = (ptr != 0);
23338 }
23339 }
23340 if (_v) {
23341 return _wrap_DateTime___sub____SWIG_2(self,args);
23342 }
23343 }
23344 }
23345
23346 Py_INCREF(Py_NotImplemented);
23347 return Py_NotImplemented;
23348 }
23349
23350
23351 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23352 PyObject *resultobj;
23353 wxDateTime *arg1 = (wxDateTime *) 0 ;
23354 wxDateTime *arg2 = (wxDateTime *) 0 ;
23355 bool result;
23356 PyObject * obj0 = 0 ;
23357 PyObject * obj1 = 0 ;
23358 char *kwnames[] = {
23359 (char *) "self",(char *) "other", NULL
23360 };
23361
23362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23364 if (SWIG_arg_fail(1)) SWIG_fail;
23365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23366 if (SWIG_arg_fail(2)) SWIG_fail;
23367 {
23368 PyThreadState* __tstate = wxPyBeginAllowThreads();
23369 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23370
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 {
23375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23376 }
23377 return resultobj;
23378 fail:
23379 return NULL;
23380 }
23381
23382
23383 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj;
23385 wxDateTime *arg1 = (wxDateTime *) 0 ;
23386 wxDateTime *arg2 = (wxDateTime *) 0 ;
23387 bool result;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char *kwnames[] = {
23391 (char *) "self",(char *) "other", NULL
23392 };
23393
23394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23396 if (SWIG_arg_fail(1)) SWIG_fail;
23397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23398 if (SWIG_arg_fail(2)) SWIG_fail;
23399 {
23400 PyThreadState* __tstate = wxPyBeginAllowThreads();
23401 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23402
23403 wxPyEndAllowThreads(__tstate);
23404 if (PyErr_Occurred()) SWIG_fail;
23405 }
23406 {
23407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23408 }
23409 return resultobj;
23410 fail:
23411 return NULL;
23412 }
23413
23414
23415 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23416 PyObject *resultobj;
23417 wxDateTime *arg1 = (wxDateTime *) 0 ;
23418 wxDateTime *arg2 = (wxDateTime *) 0 ;
23419 bool result;
23420 PyObject * obj0 = 0 ;
23421 PyObject * obj1 = 0 ;
23422 char *kwnames[] = {
23423 (char *) "self",(char *) "other", NULL
23424 };
23425
23426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23428 if (SWIG_arg_fail(1)) SWIG_fail;
23429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23430 if (SWIG_arg_fail(2)) SWIG_fail;
23431 {
23432 PyThreadState* __tstate = wxPyBeginAllowThreads();
23433 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23434
23435 wxPyEndAllowThreads(__tstate);
23436 if (PyErr_Occurred()) SWIG_fail;
23437 }
23438 {
23439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23440 }
23441 return resultobj;
23442 fail:
23443 return NULL;
23444 }
23445
23446
23447 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23448 PyObject *resultobj;
23449 wxDateTime *arg1 = (wxDateTime *) 0 ;
23450 wxDateTime *arg2 = (wxDateTime *) 0 ;
23451 bool result;
23452 PyObject * obj0 = 0 ;
23453 PyObject * obj1 = 0 ;
23454 char *kwnames[] = {
23455 (char *) "self",(char *) "other", NULL
23456 };
23457
23458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23460 if (SWIG_arg_fail(1)) SWIG_fail;
23461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23462 if (SWIG_arg_fail(2)) SWIG_fail;
23463 {
23464 PyThreadState* __tstate = wxPyBeginAllowThreads();
23465 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23466
23467 wxPyEndAllowThreads(__tstate);
23468 if (PyErr_Occurred()) SWIG_fail;
23469 }
23470 {
23471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23472 }
23473 return resultobj;
23474 fail:
23475 return NULL;
23476 }
23477
23478
23479 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23480 PyObject *resultobj;
23481 wxDateTime *arg1 = (wxDateTime *) 0 ;
23482 wxDateTime *arg2 = (wxDateTime *) 0 ;
23483 bool result;
23484 PyObject * obj0 = 0 ;
23485 PyObject * obj1 = 0 ;
23486 char *kwnames[] = {
23487 (char *) "self",(char *) "other", NULL
23488 };
23489
23490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23492 if (SWIG_arg_fail(1)) SWIG_fail;
23493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23494 if (SWIG_arg_fail(2)) SWIG_fail;
23495 {
23496 PyThreadState* __tstate = wxPyBeginAllowThreads();
23497 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23498
23499 wxPyEndAllowThreads(__tstate);
23500 if (PyErr_Occurred()) SWIG_fail;
23501 }
23502 {
23503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23504 }
23505 return resultobj;
23506 fail:
23507 return NULL;
23508 }
23509
23510
23511 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23512 PyObject *resultobj;
23513 wxDateTime *arg1 = (wxDateTime *) 0 ;
23514 wxDateTime *arg2 = (wxDateTime *) 0 ;
23515 bool result;
23516 PyObject * obj0 = 0 ;
23517 PyObject * obj1 = 0 ;
23518 char *kwnames[] = {
23519 (char *) "self",(char *) "other", NULL
23520 };
23521
23522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23524 if (SWIG_arg_fail(1)) SWIG_fail;
23525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23526 if (SWIG_arg_fail(2)) SWIG_fail;
23527 {
23528 PyThreadState* __tstate = wxPyBeginAllowThreads();
23529 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23530
23531 wxPyEndAllowThreads(__tstate);
23532 if (PyErr_Occurred()) SWIG_fail;
23533 }
23534 {
23535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23536 }
23537 return resultobj;
23538 fail:
23539 return NULL;
23540 }
23541
23542
23543 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23544 PyObject *resultobj;
23545 wxDateTime *arg1 = (wxDateTime *) 0 ;
23546 wxString *arg2 = 0 ;
23547 int result;
23548 bool temp2 = false ;
23549 PyObject * obj0 = 0 ;
23550 PyObject * obj1 = 0 ;
23551 char *kwnames[] = {
23552 (char *) "self",(char *) "date", NULL
23553 };
23554
23555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23557 if (SWIG_arg_fail(1)) SWIG_fail;
23558 {
23559 arg2 = wxString_in_helper(obj1);
23560 if (arg2 == NULL) SWIG_fail;
23561 temp2 = true;
23562 }
23563 {
23564 PyThreadState* __tstate = wxPyBeginAllowThreads();
23565 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23566
23567 wxPyEndAllowThreads(__tstate);
23568 if (PyErr_Occurred()) SWIG_fail;
23569 }
23570 {
23571 resultobj = SWIG_From_int((int)(result));
23572 }
23573 {
23574 if (temp2)
23575 delete arg2;
23576 }
23577 return resultobj;
23578 fail:
23579 {
23580 if (temp2)
23581 delete arg2;
23582 }
23583 return NULL;
23584 }
23585
23586
23587 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23588 PyObject *resultobj;
23589 wxDateTime *arg1 = (wxDateTime *) 0 ;
23590 wxString *arg2 = 0 ;
23591 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23592 wxString *arg3 = (wxString *) &arg3_defvalue ;
23593 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23594 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23595 int result;
23596 bool temp2 = false ;
23597 bool temp3 = false ;
23598 PyObject * obj0 = 0 ;
23599 PyObject * obj1 = 0 ;
23600 PyObject * obj2 = 0 ;
23601 PyObject * obj3 = 0 ;
23602 char *kwnames[] = {
23603 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23604 };
23605
23606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23608 if (SWIG_arg_fail(1)) SWIG_fail;
23609 {
23610 arg2 = wxString_in_helper(obj1);
23611 if (arg2 == NULL) SWIG_fail;
23612 temp2 = true;
23613 }
23614 if (obj2) {
23615 {
23616 arg3 = wxString_in_helper(obj2);
23617 if (arg3 == NULL) SWIG_fail;
23618 temp3 = true;
23619 }
23620 }
23621 if (obj3) {
23622 {
23623 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23624 if (SWIG_arg_fail(4)) SWIG_fail;
23625 if (arg4 == NULL) {
23626 SWIG_null_ref("wxDateTime");
23627 }
23628 if (SWIG_arg_fail(4)) SWIG_fail;
23629 }
23630 }
23631 {
23632 PyThreadState* __tstate = wxPyBeginAllowThreads();
23633 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23634
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 {
23639 resultobj = SWIG_From_int((int)(result));
23640 }
23641 {
23642 if (temp2)
23643 delete arg2;
23644 }
23645 {
23646 if (temp3)
23647 delete arg3;
23648 }
23649 return resultobj;
23650 fail:
23651 {
23652 if (temp2)
23653 delete arg2;
23654 }
23655 {
23656 if (temp3)
23657 delete arg3;
23658 }
23659 return NULL;
23660 }
23661
23662
23663 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23664 PyObject *resultobj;
23665 wxDateTime *arg1 = (wxDateTime *) 0 ;
23666 wxString *arg2 = 0 ;
23667 int result;
23668 bool temp2 = false ;
23669 PyObject * obj0 = 0 ;
23670 PyObject * obj1 = 0 ;
23671 char *kwnames[] = {
23672 (char *) "self",(char *) "datetime", NULL
23673 };
23674
23675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23677 if (SWIG_arg_fail(1)) SWIG_fail;
23678 {
23679 arg2 = wxString_in_helper(obj1);
23680 if (arg2 == NULL) SWIG_fail;
23681 temp2 = true;
23682 }
23683 {
23684 PyThreadState* __tstate = wxPyBeginAllowThreads();
23685 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23686
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 {
23691 resultobj = SWIG_From_int((int)(result));
23692 }
23693 {
23694 if (temp2)
23695 delete arg2;
23696 }
23697 return resultobj;
23698 fail:
23699 {
23700 if (temp2)
23701 delete arg2;
23702 }
23703 return NULL;
23704 }
23705
23706
23707 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23708 PyObject *resultobj;
23709 wxDateTime *arg1 = (wxDateTime *) 0 ;
23710 wxString *arg2 = 0 ;
23711 int result;
23712 bool temp2 = false ;
23713 PyObject * obj0 = 0 ;
23714 PyObject * obj1 = 0 ;
23715 char *kwnames[] = {
23716 (char *) "self",(char *) "date", NULL
23717 };
23718
23719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23721 if (SWIG_arg_fail(1)) SWIG_fail;
23722 {
23723 arg2 = wxString_in_helper(obj1);
23724 if (arg2 == NULL) SWIG_fail;
23725 temp2 = true;
23726 }
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23730
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 {
23735 resultobj = SWIG_From_int((int)(result));
23736 }
23737 {
23738 if (temp2)
23739 delete arg2;
23740 }
23741 return resultobj;
23742 fail:
23743 {
23744 if (temp2)
23745 delete arg2;
23746 }
23747 return NULL;
23748 }
23749
23750
23751 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23752 PyObject *resultobj;
23753 wxDateTime *arg1 = (wxDateTime *) 0 ;
23754 wxString *arg2 = 0 ;
23755 int result;
23756 bool temp2 = false ;
23757 PyObject * obj0 = 0 ;
23758 PyObject * obj1 = 0 ;
23759 char *kwnames[] = {
23760 (char *) "self",(char *) "time", NULL
23761 };
23762
23763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23765 if (SWIG_arg_fail(1)) SWIG_fail;
23766 {
23767 arg2 = wxString_in_helper(obj1);
23768 if (arg2 == NULL) SWIG_fail;
23769 temp2 = true;
23770 }
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23774
23775 wxPyEndAllowThreads(__tstate);
23776 if (PyErr_Occurred()) SWIG_fail;
23777 }
23778 {
23779 resultobj = SWIG_From_int((int)(result));
23780 }
23781 {
23782 if (temp2)
23783 delete arg2;
23784 }
23785 return resultobj;
23786 fail:
23787 {
23788 if (temp2)
23789 delete arg2;
23790 }
23791 return NULL;
23792 }
23793
23794
23795 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23796 PyObject *resultobj;
23797 wxDateTime *arg1 = (wxDateTime *) 0 ;
23798 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23799 wxString *arg2 = (wxString *) &arg2_defvalue ;
23800 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23801 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23802 wxString result;
23803 bool temp2 = false ;
23804 bool temp3 = false ;
23805 PyObject * obj0 = 0 ;
23806 PyObject * obj1 = 0 ;
23807 PyObject * obj2 = 0 ;
23808 char *kwnames[] = {
23809 (char *) "self",(char *) "format",(char *) "tz", NULL
23810 };
23811
23812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23814 if (SWIG_arg_fail(1)) SWIG_fail;
23815 if (obj1) {
23816 {
23817 arg2 = wxString_in_helper(obj1);
23818 if (arg2 == NULL) SWIG_fail;
23819 temp2 = true;
23820 }
23821 }
23822 if (obj2) {
23823 {
23824 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23825 temp3 = true;
23826 }
23827 }
23828 {
23829 PyThreadState* __tstate = wxPyBeginAllowThreads();
23830 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23831
23832 wxPyEndAllowThreads(__tstate);
23833 if (PyErr_Occurred()) SWIG_fail;
23834 }
23835 {
23836 #if wxUSE_UNICODE
23837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23838 #else
23839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23840 #endif
23841 }
23842 {
23843 if (temp2)
23844 delete arg2;
23845 }
23846 {
23847 if (temp3) delete arg3;
23848 }
23849 return resultobj;
23850 fail:
23851 {
23852 if (temp2)
23853 delete arg2;
23854 }
23855 {
23856 if (temp3) delete arg3;
23857 }
23858 return NULL;
23859 }
23860
23861
23862 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23863 PyObject *resultobj;
23864 wxDateTime *arg1 = (wxDateTime *) 0 ;
23865 wxString result;
23866 PyObject * obj0 = 0 ;
23867 char *kwnames[] = {
23868 (char *) "self", NULL
23869 };
23870
23871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23873 if (SWIG_arg_fail(1)) SWIG_fail;
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 result = ((wxDateTime const *)arg1)->FormatDate();
23877
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 {
23882 #if wxUSE_UNICODE
23883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23884 #else
23885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23886 #endif
23887 }
23888 return resultobj;
23889 fail:
23890 return NULL;
23891 }
23892
23893
23894 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj;
23896 wxDateTime *arg1 = (wxDateTime *) 0 ;
23897 wxString result;
23898 PyObject * obj0 = 0 ;
23899 char *kwnames[] = {
23900 (char *) "self", NULL
23901 };
23902
23903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23905 if (SWIG_arg_fail(1)) SWIG_fail;
23906 {
23907 PyThreadState* __tstate = wxPyBeginAllowThreads();
23908 result = ((wxDateTime const *)arg1)->FormatTime();
23909
23910 wxPyEndAllowThreads(__tstate);
23911 if (PyErr_Occurred()) SWIG_fail;
23912 }
23913 {
23914 #if wxUSE_UNICODE
23915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23916 #else
23917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23918 #endif
23919 }
23920 return resultobj;
23921 fail:
23922 return NULL;
23923 }
23924
23925
23926 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23927 PyObject *resultobj;
23928 wxDateTime *arg1 = (wxDateTime *) 0 ;
23929 wxString result;
23930 PyObject * obj0 = 0 ;
23931 char *kwnames[] = {
23932 (char *) "self", NULL
23933 };
23934
23935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23937 if (SWIG_arg_fail(1)) SWIG_fail;
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 result = ((wxDateTime const *)arg1)->FormatISODate();
23941
23942 wxPyEndAllowThreads(__tstate);
23943 if (PyErr_Occurred()) SWIG_fail;
23944 }
23945 {
23946 #if wxUSE_UNICODE
23947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23948 #else
23949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23950 #endif
23951 }
23952 return resultobj;
23953 fail:
23954 return NULL;
23955 }
23956
23957
23958 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23959 PyObject *resultobj;
23960 wxDateTime *arg1 = (wxDateTime *) 0 ;
23961 wxString result;
23962 PyObject * obj0 = 0 ;
23963 char *kwnames[] = {
23964 (char *) "self", NULL
23965 };
23966
23967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23969 if (SWIG_arg_fail(1)) SWIG_fail;
23970 {
23971 PyThreadState* __tstate = wxPyBeginAllowThreads();
23972 result = ((wxDateTime const *)arg1)->FormatISOTime();
23973
23974 wxPyEndAllowThreads(__tstate);
23975 if (PyErr_Occurred()) SWIG_fail;
23976 }
23977 {
23978 #if wxUSE_UNICODE
23979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23980 #else
23981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23982 #endif
23983 }
23984 return resultobj;
23985 fail:
23986 return NULL;
23987 }
23988
23989
23990 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23991 PyObject *obj;
23992 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23993 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23994 Py_INCREF(obj);
23995 return Py_BuildValue((char *)"");
23996 }
23997 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23998 PyObject *resultobj;
23999 long arg1 ;
24000 wxTimeSpan result;
24001 PyObject * obj0 = 0 ;
24002 char *kwnames[] = {
24003 (char *) "sec", NULL
24004 };
24005
24006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
24007 {
24008 arg1 = (long)(SWIG_As_long(obj0));
24009 if (SWIG_arg_fail(1)) SWIG_fail;
24010 }
24011 {
24012 PyThreadState* __tstate = wxPyBeginAllowThreads();
24013 result = wxTimeSpan::Seconds(arg1);
24014
24015 wxPyEndAllowThreads(__tstate);
24016 if (PyErr_Occurred()) SWIG_fail;
24017 }
24018 {
24019 wxTimeSpan * resultptr;
24020 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24022 }
24023 return resultobj;
24024 fail:
24025 return NULL;
24026 }
24027
24028
24029 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
24030 PyObject *resultobj;
24031 wxTimeSpan result;
24032 char *kwnames[] = {
24033 NULL
24034 };
24035
24036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
24037 {
24038 PyThreadState* __tstate = wxPyBeginAllowThreads();
24039 result = wxTimeSpan::Second();
24040
24041 wxPyEndAllowThreads(__tstate);
24042 if (PyErr_Occurred()) SWIG_fail;
24043 }
24044 {
24045 wxTimeSpan * resultptr;
24046 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24047 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24048 }
24049 return resultobj;
24050 fail:
24051 return NULL;
24052 }
24053
24054
24055 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
24056 PyObject *resultobj;
24057 long arg1 ;
24058 wxTimeSpan result;
24059 PyObject * obj0 = 0 ;
24060 char *kwnames[] = {
24061 (char *) "min", NULL
24062 };
24063
24064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
24065 {
24066 arg1 = (long)(SWIG_As_long(obj0));
24067 if (SWIG_arg_fail(1)) SWIG_fail;
24068 }
24069 {
24070 PyThreadState* __tstate = wxPyBeginAllowThreads();
24071 result = wxTimeSpan::Minutes(arg1);
24072
24073 wxPyEndAllowThreads(__tstate);
24074 if (PyErr_Occurred()) SWIG_fail;
24075 }
24076 {
24077 wxTimeSpan * resultptr;
24078 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24079 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24080 }
24081 return resultobj;
24082 fail:
24083 return NULL;
24084 }
24085
24086
24087 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
24088 PyObject *resultobj;
24089 wxTimeSpan result;
24090 char *kwnames[] = {
24091 NULL
24092 };
24093
24094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
24095 {
24096 PyThreadState* __tstate = wxPyBeginAllowThreads();
24097 result = wxTimeSpan::Minute();
24098
24099 wxPyEndAllowThreads(__tstate);
24100 if (PyErr_Occurred()) SWIG_fail;
24101 }
24102 {
24103 wxTimeSpan * resultptr;
24104 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24106 }
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24114 PyObject *resultobj;
24115 long arg1 ;
24116 wxTimeSpan result;
24117 PyObject * obj0 = 0 ;
24118 char *kwnames[] = {
24119 (char *) "hours", NULL
24120 };
24121
24122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24123 {
24124 arg1 = (long)(SWIG_As_long(obj0));
24125 if (SWIG_arg_fail(1)) SWIG_fail;
24126 }
24127 {
24128 PyThreadState* __tstate = wxPyBeginAllowThreads();
24129 result = wxTimeSpan::Hours(arg1);
24130
24131 wxPyEndAllowThreads(__tstate);
24132 if (PyErr_Occurred()) SWIG_fail;
24133 }
24134 {
24135 wxTimeSpan * resultptr;
24136 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24137 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24138 }
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24146 PyObject *resultobj;
24147 wxTimeSpan result;
24148 char *kwnames[] = {
24149 NULL
24150 };
24151
24152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24153 {
24154 PyThreadState* __tstate = wxPyBeginAllowThreads();
24155 result = wxTimeSpan::Hour();
24156
24157 wxPyEndAllowThreads(__tstate);
24158 if (PyErr_Occurred()) SWIG_fail;
24159 }
24160 {
24161 wxTimeSpan * resultptr;
24162 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24163 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24164 }
24165 return resultobj;
24166 fail:
24167 return NULL;
24168 }
24169
24170
24171 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24172 PyObject *resultobj;
24173 long arg1 ;
24174 wxTimeSpan result;
24175 PyObject * obj0 = 0 ;
24176 char *kwnames[] = {
24177 (char *) "days", NULL
24178 };
24179
24180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24181 {
24182 arg1 = (long)(SWIG_As_long(obj0));
24183 if (SWIG_arg_fail(1)) SWIG_fail;
24184 }
24185 {
24186 PyThreadState* __tstate = wxPyBeginAllowThreads();
24187 result = wxTimeSpan::Days(arg1);
24188
24189 wxPyEndAllowThreads(__tstate);
24190 if (PyErr_Occurred()) SWIG_fail;
24191 }
24192 {
24193 wxTimeSpan * resultptr;
24194 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24195 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24196 }
24197 return resultobj;
24198 fail:
24199 return NULL;
24200 }
24201
24202
24203 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24204 PyObject *resultobj;
24205 wxTimeSpan result;
24206 char *kwnames[] = {
24207 NULL
24208 };
24209
24210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24211 {
24212 PyThreadState* __tstate = wxPyBeginAllowThreads();
24213 result = wxTimeSpan::Day();
24214
24215 wxPyEndAllowThreads(__tstate);
24216 if (PyErr_Occurred()) SWIG_fail;
24217 }
24218 {
24219 wxTimeSpan * resultptr;
24220 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24221 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24222 }
24223 return resultobj;
24224 fail:
24225 return NULL;
24226 }
24227
24228
24229 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24230 PyObject *resultobj;
24231 long arg1 ;
24232 wxTimeSpan result;
24233 PyObject * obj0 = 0 ;
24234 char *kwnames[] = {
24235 (char *) "days", NULL
24236 };
24237
24238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24239 {
24240 arg1 = (long)(SWIG_As_long(obj0));
24241 if (SWIG_arg_fail(1)) SWIG_fail;
24242 }
24243 {
24244 PyThreadState* __tstate = wxPyBeginAllowThreads();
24245 result = wxTimeSpan::Weeks(arg1);
24246
24247 wxPyEndAllowThreads(__tstate);
24248 if (PyErr_Occurred()) SWIG_fail;
24249 }
24250 {
24251 wxTimeSpan * resultptr;
24252 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24253 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24254 }
24255 return resultobj;
24256 fail:
24257 return NULL;
24258 }
24259
24260
24261 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24262 PyObject *resultobj;
24263 wxTimeSpan result;
24264 char *kwnames[] = {
24265 NULL
24266 };
24267
24268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24269 {
24270 PyThreadState* __tstate = wxPyBeginAllowThreads();
24271 result = wxTimeSpan::Week();
24272
24273 wxPyEndAllowThreads(__tstate);
24274 if (PyErr_Occurred()) SWIG_fail;
24275 }
24276 {
24277 wxTimeSpan * resultptr;
24278 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24279 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24280 }
24281 return resultobj;
24282 fail:
24283 return NULL;
24284 }
24285
24286
24287 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24288 PyObject *resultobj;
24289 long arg1 = (long) 0 ;
24290 long arg2 = (long) 0 ;
24291 long arg3 = (long) 0 ;
24292 long arg4 = (long) 0 ;
24293 wxTimeSpan *result;
24294 PyObject * obj0 = 0 ;
24295 PyObject * obj1 = 0 ;
24296 PyObject * obj2 = 0 ;
24297 PyObject * obj3 = 0 ;
24298 char *kwnames[] = {
24299 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24300 };
24301
24302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24303 if (obj0) {
24304 {
24305 arg1 = (long)(SWIG_As_long(obj0));
24306 if (SWIG_arg_fail(1)) SWIG_fail;
24307 }
24308 }
24309 if (obj1) {
24310 {
24311 arg2 = (long)(SWIG_As_long(obj1));
24312 if (SWIG_arg_fail(2)) SWIG_fail;
24313 }
24314 }
24315 if (obj2) {
24316 {
24317 arg3 = (long)(SWIG_As_long(obj2));
24318 if (SWIG_arg_fail(3)) SWIG_fail;
24319 }
24320 }
24321 if (obj3) {
24322 {
24323 arg4 = (long)(SWIG_As_long(obj3));
24324 if (SWIG_arg_fail(4)) SWIG_fail;
24325 }
24326 }
24327 {
24328 PyThreadState* __tstate = wxPyBeginAllowThreads();
24329 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24330
24331 wxPyEndAllowThreads(__tstate);
24332 if (PyErr_Occurred()) SWIG_fail;
24333 }
24334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24335 return resultobj;
24336 fail:
24337 return NULL;
24338 }
24339
24340
24341 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24342 PyObject *resultobj;
24343 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24344 PyObject * obj0 = 0 ;
24345 char *kwnames[] = {
24346 (char *) "self", NULL
24347 };
24348
24349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24351 if (SWIG_arg_fail(1)) SWIG_fail;
24352 {
24353 PyThreadState* __tstate = wxPyBeginAllowThreads();
24354 delete arg1;
24355
24356 wxPyEndAllowThreads(__tstate);
24357 if (PyErr_Occurred()) SWIG_fail;
24358 }
24359 Py_INCREF(Py_None); resultobj = Py_None;
24360 return resultobj;
24361 fail:
24362 return NULL;
24363 }
24364
24365
24366 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24367 PyObject *resultobj;
24368 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24369 wxTimeSpan *arg2 = 0 ;
24370 wxTimeSpan *result;
24371 PyObject * obj0 = 0 ;
24372 PyObject * obj1 = 0 ;
24373 char *kwnames[] = {
24374 (char *) "self",(char *) "diff", NULL
24375 };
24376
24377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24382 if (SWIG_arg_fail(2)) SWIG_fail;
24383 if (arg2 == NULL) {
24384 SWIG_null_ref("wxTimeSpan");
24385 }
24386 if (SWIG_arg_fail(2)) SWIG_fail;
24387 }
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 {
24391 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24392 result = (wxTimeSpan *) &_result_ref;
24393 }
24394
24395 wxPyEndAllowThreads(__tstate);
24396 if (PyErr_Occurred()) SWIG_fail;
24397 }
24398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24399 return resultobj;
24400 fail:
24401 return NULL;
24402 }
24403
24404
24405 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24406 PyObject *resultobj;
24407 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24408 wxTimeSpan *arg2 = 0 ;
24409 wxTimeSpan *result;
24410 PyObject * obj0 = 0 ;
24411 PyObject * obj1 = 0 ;
24412 char *kwnames[] = {
24413 (char *) "self",(char *) "diff", NULL
24414 };
24415
24416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24418 if (SWIG_arg_fail(1)) SWIG_fail;
24419 {
24420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24421 if (SWIG_arg_fail(2)) SWIG_fail;
24422 if (arg2 == NULL) {
24423 SWIG_null_ref("wxTimeSpan");
24424 }
24425 if (SWIG_arg_fail(2)) SWIG_fail;
24426 }
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 {
24430 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24431 result = (wxTimeSpan *) &_result_ref;
24432 }
24433
24434 wxPyEndAllowThreads(__tstate);
24435 if (PyErr_Occurred()) SWIG_fail;
24436 }
24437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24438 return resultobj;
24439 fail:
24440 return NULL;
24441 }
24442
24443
24444 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24445 PyObject *resultobj;
24446 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24447 int arg2 ;
24448 wxTimeSpan *result;
24449 PyObject * obj0 = 0 ;
24450 PyObject * obj1 = 0 ;
24451 char *kwnames[] = {
24452 (char *) "self",(char *) "n", NULL
24453 };
24454
24455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24457 if (SWIG_arg_fail(1)) SWIG_fail;
24458 {
24459 arg2 = (int)(SWIG_As_int(obj1));
24460 if (SWIG_arg_fail(2)) SWIG_fail;
24461 }
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 {
24465 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24466 result = (wxTimeSpan *) &_result_ref;
24467 }
24468
24469 wxPyEndAllowThreads(__tstate);
24470 if (PyErr_Occurred()) SWIG_fail;
24471 }
24472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24473 return resultobj;
24474 fail:
24475 return NULL;
24476 }
24477
24478
24479 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24480 PyObject *resultobj;
24481 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24482 wxTimeSpan *result;
24483 PyObject * obj0 = 0 ;
24484 char *kwnames[] = {
24485 (char *) "self", NULL
24486 };
24487
24488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24490 if (SWIG_arg_fail(1)) SWIG_fail;
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 {
24494 wxTimeSpan &_result_ref = (arg1)->Neg();
24495 result = (wxTimeSpan *) &_result_ref;
24496 }
24497
24498 wxPyEndAllowThreads(__tstate);
24499 if (PyErr_Occurred()) SWIG_fail;
24500 }
24501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24502 return resultobj;
24503 fail:
24504 return NULL;
24505 }
24506
24507
24508 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24509 PyObject *resultobj;
24510 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24511 wxTimeSpan result;
24512 PyObject * obj0 = 0 ;
24513 char *kwnames[] = {
24514 (char *) "self", NULL
24515 };
24516
24517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24519 if (SWIG_arg_fail(1)) SWIG_fail;
24520 {
24521 PyThreadState* __tstate = wxPyBeginAllowThreads();
24522 result = ((wxTimeSpan const *)arg1)->Abs();
24523
24524 wxPyEndAllowThreads(__tstate);
24525 if (PyErr_Occurred()) SWIG_fail;
24526 }
24527 {
24528 wxTimeSpan * resultptr;
24529 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24531 }
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj;
24540 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24541 wxTimeSpan *arg2 = 0 ;
24542 wxTimeSpan *result;
24543 PyObject * obj0 = 0 ;
24544 PyObject * obj1 = 0 ;
24545 char *kwnames[] = {
24546 (char *) "self",(char *) "diff", NULL
24547 };
24548
24549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24551 if (SWIG_arg_fail(1)) SWIG_fail;
24552 {
24553 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24554 if (SWIG_arg_fail(2)) SWIG_fail;
24555 if (arg2 == NULL) {
24556 SWIG_null_ref("wxTimeSpan");
24557 }
24558 if (SWIG_arg_fail(2)) SWIG_fail;
24559 }
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 {
24563 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24564 result = (wxTimeSpan *) &_result_ref;
24565 }
24566
24567 wxPyEndAllowThreads(__tstate);
24568 if (PyErr_Occurred()) SWIG_fail;
24569 }
24570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24571 return resultobj;
24572 fail:
24573 return NULL;
24574 }
24575
24576
24577 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24578 PyObject *resultobj;
24579 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24580 wxTimeSpan *arg2 = 0 ;
24581 wxTimeSpan *result;
24582 PyObject * obj0 = 0 ;
24583 PyObject * obj1 = 0 ;
24584 char *kwnames[] = {
24585 (char *) "self",(char *) "diff", NULL
24586 };
24587
24588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24590 if (SWIG_arg_fail(1)) SWIG_fail;
24591 {
24592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24593 if (SWIG_arg_fail(2)) SWIG_fail;
24594 if (arg2 == NULL) {
24595 SWIG_null_ref("wxTimeSpan");
24596 }
24597 if (SWIG_arg_fail(2)) SWIG_fail;
24598 }
24599 {
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 {
24602 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24603 result = (wxTimeSpan *) &_result_ref;
24604 }
24605
24606 wxPyEndAllowThreads(__tstate);
24607 if (PyErr_Occurred()) SWIG_fail;
24608 }
24609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24610 return resultobj;
24611 fail:
24612 return NULL;
24613 }
24614
24615
24616 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj;
24618 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24619 int arg2 ;
24620 wxTimeSpan *result;
24621 PyObject * obj0 = 0 ;
24622 PyObject * obj1 = 0 ;
24623 char *kwnames[] = {
24624 (char *) "self",(char *) "n", NULL
24625 };
24626
24627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24629 if (SWIG_arg_fail(1)) SWIG_fail;
24630 {
24631 arg2 = (int)(SWIG_As_int(obj1));
24632 if (SWIG_arg_fail(2)) SWIG_fail;
24633 }
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 {
24637 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24638 result = (wxTimeSpan *) &_result_ref;
24639 }
24640
24641 wxPyEndAllowThreads(__tstate);
24642 if (PyErr_Occurred()) SWIG_fail;
24643 }
24644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24645 return resultobj;
24646 fail:
24647 return NULL;
24648 }
24649
24650
24651 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24652 PyObject *resultobj;
24653 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24654 wxTimeSpan *result;
24655 PyObject * obj0 = 0 ;
24656 char *kwnames[] = {
24657 (char *) "self", NULL
24658 };
24659
24660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
24665 {
24666 wxTimeSpan &_result_ref = (arg1)->operator -();
24667 result = (wxTimeSpan *) &_result_ref;
24668 }
24669
24670 wxPyEndAllowThreads(__tstate);
24671 if (PyErr_Occurred()) SWIG_fail;
24672 }
24673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24674 return resultobj;
24675 fail:
24676 return NULL;
24677 }
24678
24679
24680 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24681 PyObject *resultobj;
24682 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24683 wxTimeSpan *arg2 = 0 ;
24684 wxTimeSpan result;
24685 PyObject * obj0 = 0 ;
24686 PyObject * obj1 = 0 ;
24687 char *kwnames[] = {
24688 (char *) "self",(char *) "other", NULL
24689 };
24690
24691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24693 if (SWIG_arg_fail(1)) SWIG_fail;
24694 {
24695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24696 if (SWIG_arg_fail(2)) SWIG_fail;
24697 if (arg2 == NULL) {
24698 SWIG_null_ref("wxTimeSpan");
24699 }
24700 if (SWIG_arg_fail(2)) SWIG_fail;
24701 }
24702 {
24703 PyThreadState* __tstate = wxPyBeginAllowThreads();
24704 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24705
24706 wxPyEndAllowThreads(__tstate);
24707 if (PyErr_Occurred()) SWIG_fail;
24708 }
24709 {
24710 wxTimeSpan * resultptr;
24711 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24713 }
24714 return resultobj;
24715 fail:
24716 return NULL;
24717 }
24718
24719
24720 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24721 PyObject *resultobj;
24722 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24723 wxTimeSpan *arg2 = 0 ;
24724 wxTimeSpan result;
24725 PyObject * obj0 = 0 ;
24726 PyObject * obj1 = 0 ;
24727 char *kwnames[] = {
24728 (char *) "self",(char *) "other", NULL
24729 };
24730
24731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24733 if (SWIG_arg_fail(1)) SWIG_fail;
24734 {
24735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24736 if (SWIG_arg_fail(2)) SWIG_fail;
24737 if (arg2 == NULL) {
24738 SWIG_null_ref("wxTimeSpan");
24739 }
24740 if (SWIG_arg_fail(2)) SWIG_fail;
24741 }
24742 {
24743 PyThreadState* __tstate = wxPyBeginAllowThreads();
24744 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24745
24746 wxPyEndAllowThreads(__tstate);
24747 if (PyErr_Occurred()) SWIG_fail;
24748 }
24749 {
24750 wxTimeSpan * resultptr;
24751 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24752 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24753 }
24754 return resultobj;
24755 fail:
24756 return NULL;
24757 }
24758
24759
24760 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24761 PyObject *resultobj;
24762 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24763 int arg2 ;
24764 wxTimeSpan result;
24765 PyObject * obj0 = 0 ;
24766 PyObject * obj1 = 0 ;
24767 char *kwnames[] = {
24768 (char *) "self",(char *) "n", NULL
24769 };
24770
24771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24773 if (SWIG_arg_fail(1)) SWIG_fail;
24774 {
24775 arg2 = (int)(SWIG_As_int(obj1));
24776 if (SWIG_arg_fail(2)) SWIG_fail;
24777 }
24778 {
24779 PyThreadState* __tstate = wxPyBeginAllowThreads();
24780 result = wxTimeSpan___mul__(arg1,arg2);
24781
24782 wxPyEndAllowThreads(__tstate);
24783 if (PyErr_Occurred()) SWIG_fail;
24784 }
24785 {
24786 wxTimeSpan * resultptr;
24787 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24789 }
24790 return resultobj;
24791 fail:
24792 return NULL;
24793 }
24794
24795
24796 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24797 PyObject *resultobj;
24798 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24799 int arg2 ;
24800 wxTimeSpan result;
24801 PyObject * obj0 = 0 ;
24802 PyObject * obj1 = 0 ;
24803 char *kwnames[] = {
24804 (char *) "self",(char *) "n", NULL
24805 };
24806
24807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24809 if (SWIG_arg_fail(1)) SWIG_fail;
24810 {
24811 arg2 = (int)(SWIG_As_int(obj1));
24812 if (SWIG_arg_fail(2)) SWIG_fail;
24813 }
24814 {
24815 PyThreadState* __tstate = wxPyBeginAllowThreads();
24816 result = wxTimeSpan___rmul__(arg1,arg2);
24817
24818 wxPyEndAllowThreads(__tstate);
24819 if (PyErr_Occurred()) SWIG_fail;
24820 }
24821 {
24822 wxTimeSpan * resultptr;
24823 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24825 }
24826 return resultobj;
24827 fail:
24828 return NULL;
24829 }
24830
24831
24832 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24833 PyObject *resultobj;
24834 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24835 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24836 bool result;
24837 PyObject * obj0 = 0 ;
24838 PyObject * obj1 = 0 ;
24839 char *kwnames[] = {
24840 (char *) "self",(char *) "other", NULL
24841 };
24842
24843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24845 if (SWIG_arg_fail(1)) SWIG_fail;
24846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24847 if (SWIG_arg_fail(2)) SWIG_fail;
24848 {
24849 PyThreadState* __tstate = wxPyBeginAllowThreads();
24850 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24851
24852 wxPyEndAllowThreads(__tstate);
24853 if (PyErr_Occurred()) SWIG_fail;
24854 }
24855 {
24856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24857 }
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24865 PyObject *resultobj;
24866 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24867 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24868 bool result;
24869 PyObject * obj0 = 0 ;
24870 PyObject * obj1 = 0 ;
24871 char *kwnames[] = {
24872 (char *) "self",(char *) "other", NULL
24873 };
24874
24875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24877 if (SWIG_arg_fail(1)) SWIG_fail;
24878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24879 if (SWIG_arg_fail(2)) SWIG_fail;
24880 {
24881 PyThreadState* __tstate = wxPyBeginAllowThreads();
24882 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24883
24884 wxPyEndAllowThreads(__tstate);
24885 if (PyErr_Occurred()) SWIG_fail;
24886 }
24887 {
24888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24889 }
24890 return resultobj;
24891 fail:
24892 return NULL;
24893 }
24894
24895
24896 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24897 PyObject *resultobj;
24898 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24899 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24900 bool result;
24901 PyObject * obj0 = 0 ;
24902 PyObject * obj1 = 0 ;
24903 char *kwnames[] = {
24904 (char *) "self",(char *) "other", NULL
24905 };
24906
24907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24909 if (SWIG_arg_fail(1)) SWIG_fail;
24910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24911 if (SWIG_arg_fail(2)) SWIG_fail;
24912 {
24913 PyThreadState* __tstate = wxPyBeginAllowThreads();
24914 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24915
24916 wxPyEndAllowThreads(__tstate);
24917 if (PyErr_Occurred()) SWIG_fail;
24918 }
24919 {
24920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24921 }
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj;
24930 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24931 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24932 bool result;
24933 PyObject * obj0 = 0 ;
24934 PyObject * obj1 = 0 ;
24935 char *kwnames[] = {
24936 (char *) "self",(char *) "other", NULL
24937 };
24938
24939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24941 if (SWIG_arg_fail(1)) SWIG_fail;
24942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24943 if (SWIG_arg_fail(2)) SWIG_fail;
24944 {
24945 PyThreadState* __tstate = wxPyBeginAllowThreads();
24946 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24947
24948 wxPyEndAllowThreads(__tstate);
24949 if (PyErr_Occurred()) SWIG_fail;
24950 }
24951 {
24952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24953 }
24954 return resultobj;
24955 fail:
24956 return NULL;
24957 }
24958
24959
24960 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24961 PyObject *resultobj;
24962 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24963 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24964 bool result;
24965 PyObject * obj0 = 0 ;
24966 PyObject * obj1 = 0 ;
24967 char *kwnames[] = {
24968 (char *) "self",(char *) "other", NULL
24969 };
24970
24971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24973 if (SWIG_arg_fail(1)) SWIG_fail;
24974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24975 if (SWIG_arg_fail(2)) SWIG_fail;
24976 {
24977 PyThreadState* __tstate = wxPyBeginAllowThreads();
24978 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24979
24980 wxPyEndAllowThreads(__tstate);
24981 if (PyErr_Occurred()) SWIG_fail;
24982 }
24983 {
24984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24985 }
24986 return resultobj;
24987 fail:
24988 return NULL;
24989 }
24990
24991
24992 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24993 PyObject *resultobj;
24994 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24995 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24996 bool result;
24997 PyObject * obj0 = 0 ;
24998 PyObject * obj1 = 0 ;
24999 char *kwnames[] = {
25000 (char *) "self",(char *) "other", NULL
25001 };
25002
25003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25005 if (SWIG_arg_fail(1)) SWIG_fail;
25006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25007 if (SWIG_arg_fail(2)) SWIG_fail;
25008 {
25009 PyThreadState* __tstate = wxPyBeginAllowThreads();
25010 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
25011
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 {
25016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25017 }
25018 return resultobj;
25019 fail:
25020 return NULL;
25021 }
25022
25023
25024 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
25025 PyObject *resultobj;
25026 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25027 bool result;
25028 PyObject * obj0 = 0 ;
25029 char *kwnames[] = {
25030 (char *) "self", NULL
25031 };
25032
25033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
25034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25035 if (SWIG_arg_fail(1)) SWIG_fail;
25036 {
25037 PyThreadState* __tstate = wxPyBeginAllowThreads();
25038 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
25039
25040 wxPyEndAllowThreads(__tstate);
25041 if (PyErr_Occurred()) SWIG_fail;
25042 }
25043 {
25044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25045 }
25046 return resultobj;
25047 fail:
25048 return NULL;
25049 }
25050
25051
25052 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
25053 PyObject *resultobj;
25054 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25055 bool result;
25056 PyObject * obj0 = 0 ;
25057 char *kwnames[] = {
25058 (char *) "self", NULL
25059 };
25060
25061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
25062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25063 if (SWIG_arg_fail(1)) SWIG_fail;
25064 {
25065 PyThreadState* __tstate = wxPyBeginAllowThreads();
25066 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
25067
25068 wxPyEndAllowThreads(__tstate);
25069 if (PyErr_Occurred()) SWIG_fail;
25070 }
25071 {
25072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25073 }
25074 return resultobj;
25075 fail:
25076 return NULL;
25077 }
25078
25079
25080 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
25081 PyObject *resultobj;
25082 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25083 bool result;
25084 PyObject * obj0 = 0 ;
25085 char *kwnames[] = {
25086 (char *) "self", NULL
25087 };
25088
25089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
25090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25091 if (SWIG_arg_fail(1)) SWIG_fail;
25092 {
25093 PyThreadState* __tstate = wxPyBeginAllowThreads();
25094 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
25095
25096 wxPyEndAllowThreads(__tstate);
25097 if (PyErr_Occurred()) SWIG_fail;
25098 }
25099 {
25100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25101 }
25102 return resultobj;
25103 fail:
25104 return NULL;
25105 }
25106
25107
25108 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
25109 PyObject *resultobj;
25110 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25111 wxTimeSpan *arg2 = 0 ;
25112 bool result;
25113 PyObject * obj0 = 0 ;
25114 PyObject * obj1 = 0 ;
25115 char *kwnames[] = {
25116 (char *) "self",(char *) "ts", NULL
25117 };
25118
25119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25121 if (SWIG_arg_fail(1)) SWIG_fail;
25122 {
25123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25124 if (SWIG_arg_fail(2)) SWIG_fail;
25125 if (arg2 == NULL) {
25126 SWIG_null_ref("wxTimeSpan");
25127 }
25128 if (SWIG_arg_fail(2)) SWIG_fail;
25129 }
25130 {
25131 PyThreadState* __tstate = wxPyBeginAllowThreads();
25132 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25133
25134 wxPyEndAllowThreads(__tstate);
25135 if (PyErr_Occurred()) SWIG_fail;
25136 }
25137 {
25138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25139 }
25140 return resultobj;
25141 fail:
25142 return NULL;
25143 }
25144
25145
25146 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25147 PyObject *resultobj;
25148 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25149 wxTimeSpan *arg2 = 0 ;
25150 bool result;
25151 PyObject * obj0 = 0 ;
25152 PyObject * obj1 = 0 ;
25153 char *kwnames[] = {
25154 (char *) "self",(char *) "ts", NULL
25155 };
25156
25157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25159 if (SWIG_arg_fail(1)) SWIG_fail;
25160 {
25161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25162 if (SWIG_arg_fail(2)) SWIG_fail;
25163 if (arg2 == NULL) {
25164 SWIG_null_ref("wxTimeSpan");
25165 }
25166 if (SWIG_arg_fail(2)) SWIG_fail;
25167 }
25168 {
25169 PyThreadState* __tstate = wxPyBeginAllowThreads();
25170 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25171
25172 wxPyEndAllowThreads(__tstate);
25173 if (PyErr_Occurred()) SWIG_fail;
25174 }
25175 {
25176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25177 }
25178 return resultobj;
25179 fail:
25180 return NULL;
25181 }
25182
25183
25184 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25185 PyObject *resultobj;
25186 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25187 wxTimeSpan *arg2 = 0 ;
25188 bool result;
25189 PyObject * obj0 = 0 ;
25190 PyObject * obj1 = 0 ;
25191 char *kwnames[] = {
25192 (char *) "self",(char *) "t", NULL
25193 };
25194
25195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25197 if (SWIG_arg_fail(1)) SWIG_fail;
25198 {
25199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25200 if (SWIG_arg_fail(2)) SWIG_fail;
25201 if (arg2 == NULL) {
25202 SWIG_null_ref("wxTimeSpan");
25203 }
25204 if (SWIG_arg_fail(2)) SWIG_fail;
25205 }
25206 {
25207 PyThreadState* __tstate = wxPyBeginAllowThreads();
25208 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25209
25210 wxPyEndAllowThreads(__tstate);
25211 if (PyErr_Occurred()) SWIG_fail;
25212 }
25213 {
25214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25215 }
25216 return resultobj;
25217 fail:
25218 return NULL;
25219 }
25220
25221
25222 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25223 PyObject *resultobj;
25224 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25225 int result;
25226 PyObject * obj0 = 0 ;
25227 char *kwnames[] = {
25228 (char *) "self", NULL
25229 };
25230
25231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25233 if (SWIG_arg_fail(1)) SWIG_fail;
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25237
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 {
25242 resultobj = SWIG_From_int((int)(result));
25243 }
25244 return resultobj;
25245 fail:
25246 return NULL;
25247 }
25248
25249
25250 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25251 PyObject *resultobj;
25252 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25253 int result;
25254 PyObject * obj0 = 0 ;
25255 char *kwnames[] = {
25256 (char *) "self", NULL
25257 };
25258
25259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25261 if (SWIG_arg_fail(1)) SWIG_fail;
25262 {
25263 PyThreadState* __tstate = wxPyBeginAllowThreads();
25264 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25265
25266 wxPyEndAllowThreads(__tstate);
25267 if (PyErr_Occurred()) SWIG_fail;
25268 }
25269 {
25270 resultobj = SWIG_From_int((int)(result));
25271 }
25272 return resultobj;
25273 fail:
25274 return NULL;
25275 }
25276
25277
25278 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25279 PyObject *resultobj;
25280 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25281 int result;
25282 PyObject * obj0 = 0 ;
25283 char *kwnames[] = {
25284 (char *) "self", NULL
25285 };
25286
25287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25289 if (SWIG_arg_fail(1)) SWIG_fail;
25290 {
25291 PyThreadState* __tstate = wxPyBeginAllowThreads();
25292 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25293
25294 wxPyEndAllowThreads(__tstate);
25295 if (PyErr_Occurred()) SWIG_fail;
25296 }
25297 {
25298 resultobj = SWIG_From_int((int)(result));
25299 }
25300 return resultobj;
25301 fail:
25302 return NULL;
25303 }
25304
25305
25306 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25307 PyObject *resultobj;
25308 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25309 int result;
25310 PyObject * obj0 = 0 ;
25311 char *kwnames[] = {
25312 (char *) "self", NULL
25313 };
25314
25315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25317 if (SWIG_arg_fail(1)) SWIG_fail;
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25321
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 {
25326 resultobj = SWIG_From_int((int)(result));
25327 }
25328 return resultobj;
25329 fail:
25330 return NULL;
25331 }
25332
25333
25334 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25335 PyObject *resultobj;
25336 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25337 wxLongLong result;
25338 PyObject * obj0 = 0 ;
25339 char *kwnames[] = {
25340 (char *) "self", NULL
25341 };
25342
25343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25345 if (SWIG_arg_fail(1)) SWIG_fail;
25346 {
25347 PyThreadState* __tstate = wxPyBeginAllowThreads();
25348 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25349
25350 wxPyEndAllowThreads(__tstate);
25351 if (PyErr_Occurred()) SWIG_fail;
25352 }
25353 {
25354 PyObject *hi, *lo, *shifter, *shifted;
25355 hi = PyLong_FromLong( (&result)->GetHi() );
25356 lo = PyLong_FromLong( (&result)->GetLo() );
25357 shifter = PyLong_FromLong(32);
25358 shifted = PyNumber_Lshift(hi, shifter);
25359 resultobj = PyNumber_Or(shifted, lo);
25360 Py_DECREF(hi);
25361 Py_DECREF(lo);
25362 Py_DECREF(shifter);
25363 Py_DECREF(shifted);
25364 }
25365 return resultobj;
25366 fail:
25367 return NULL;
25368 }
25369
25370
25371 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25372 PyObject *resultobj;
25373 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25374 wxLongLong result;
25375 PyObject * obj0 = 0 ;
25376 char *kwnames[] = {
25377 (char *) "self", NULL
25378 };
25379
25380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25382 if (SWIG_arg_fail(1)) SWIG_fail;
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25386
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 {
25391 PyObject *hi, *lo, *shifter, *shifted;
25392 hi = PyLong_FromLong( (&result)->GetHi() );
25393 lo = PyLong_FromLong( (&result)->GetLo() );
25394 shifter = PyLong_FromLong(32);
25395 shifted = PyNumber_Lshift(hi, shifter);
25396 resultobj = PyNumber_Or(shifted, lo);
25397 Py_DECREF(hi);
25398 Py_DECREF(lo);
25399 Py_DECREF(shifter);
25400 Py_DECREF(shifted);
25401 }
25402 return resultobj;
25403 fail:
25404 return NULL;
25405 }
25406
25407
25408 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25409 PyObject *resultobj;
25410 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25411 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25412 wxString *arg2 = (wxString *) &arg2_defvalue ;
25413 wxString result;
25414 bool temp2 = false ;
25415 PyObject * obj0 = 0 ;
25416 PyObject * obj1 = 0 ;
25417 char *kwnames[] = {
25418 (char *) "self",(char *) "format", NULL
25419 };
25420
25421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25423 if (SWIG_arg_fail(1)) SWIG_fail;
25424 if (obj1) {
25425 {
25426 arg2 = wxString_in_helper(obj1);
25427 if (arg2 == NULL) SWIG_fail;
25428 temp2 = true;
25429 }
25430 }
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25434
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 {
25439 #if wxUSE_UNICODE
25440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25441 #else
25442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25443 #endif
25444 }
25445 {
25446 if (temp2)
25447 delete arg2;
25448 }
25449 return resultobj;
25450 fail:
25451 {
25452 if (temp2)
25453 delete arg2;
25454 }
25455 return NULL;
25456 }
25457
25458
25459 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25460 PyObject *obj;
25461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25462 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25463 Py_INCREF(obj);
25464 return Py_BuildValue((char *)"");
25465 }
25466 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25467 PyObject *resultobj;
25468 int arg1 = (int) 0 ;
25469 int arg2 = (int) 0 ;
25470 int arg3 = (int) 0 ;
25471 int arg4 = (int) 0 ;
25472 wxDateSpan *result;
25473 PyObject * obj0 = 0 ;
25474 PyObject * obj1 = 0 ;
25475 PyObject * obj2 = 0 ;
25476 PyObject * obj3 = 0 ;
25477 char *kwnames[] = {
25478 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25479 };
25480
25481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25482 if (obj0) {
25483 {
25484 arg1 = (int)(SWIG_As_int(obj0));
25485 if (SWIG_arg_fail(1)) SWIG_fail;
25486 }
25487 }
25488 if (obj1) {
25489 {
25490 arg2 = (int)(SWIG_As_int(obj1));
25491 if (SWIG_arg_fail(2)) SWIG_fail;
25492 }
25493 }
25494 if (obj2) {
25495 {
25496 arg3 = (int)(SWIG_As_int(obj2));
25497 if (SWIG_arg_fail(3)) SWIG_fail;
25498 }
25499 }
25500 if (obj3) {
25501 {
25502 arg4 = (int)(SWIG_As_int(obj3));
25503 if (SWIG_arg_fail(4)) SWIG_fail;
25504 }
25505 }
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25509
25510 wxPyEndAllowThreads(__tstate);
25511 if (PyErr_Occurred()) SWIG_fail;
25512 }
25513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25514 return resultobj;
25515 fail:
25516 return NULL;
25517 }
25518
25519
25520 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25521 PyObject *resultobj;
25522 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25523 PyObject * obj0 = 0 ;
25524 char *kwnames[] = {
25525 (char *) "self", NULL
25526 };
25527
25528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25530 if (SWIG_arg_fail(1)) SWIG_fail;
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 delete arg1;
25534
25535 wxPyEndAllowThreads(__tstate);
25536 if (PyErr_Occurred()) SWIG_fail;
25537 }
25538 Py_INCREF(Py_None); resultobj = Py_None;
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25546 PyObject *resultobj;
25547 int arg1 ;
25548 wxDateSpan result;
25549 PyObject * obj0 = 0 ;
25550 char *kwnames[] = {
25551 (char *) "days", NULL
25552 };
25553
25554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25555 {
25556 arg1 = (int)(SWIG_As_int(obj0));
25557 if (SWIG_arg_fail(1)) SWIG_fail;
25558 }
25559 {
25560 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 result = wxDateSpan::Days(arg1);
25562
25563 wxPyEndAllowThreads(__tstate);
25564 if (PyErr_Occurred()) SWIG_fail;
25565 }
25566 {
25567 wxDateSpan * resultptr;
25568 resultptr = new wxDateSpan((wxDateSpan &)(result));
25569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25570 }
25571 return resultobj;
25572 fail:
25573 return NULL;
25574 }
25575
25576
25577 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25578 PyObject *resultobj;
25579 wxDateSpan result;
25580 char *kwnames[] = {
25581 NULL
25582 };
25583
25584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25585 {
25586 PyThreadState* __tstate = wxPyBeginAllowThreads();
25587 result = wxDateSpan::Day();
25588
25589 wxPyEndAllowThreads(__tstate);
25590 if (PyErr_Occurred()) SWIG_fail;
25591 }
25592 {
25593 wxDateSpan * resultptr;
25594 resultptr = new wxDateSpan((wxDateSpan &)(result));
25595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25596 }
25597 return resultobj;
25598 fail:
25599 return NULL;
25600 }
25601
25602
25603 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25604 PyObject *resultobj;
25605 int arg1 ;
25606 wxDateSpan result;
25607 PyObject * obj0 = 0 ;
25608 char *kwnames[] = {
25609 (char *) "weeks", NULL
25610 };
25611
25612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25613 {
25614 arg1 = (int)(SWIG_As_int(obj0));
25615 if (SWIG_arg_fail(1)) SWIG_fail;
25616 }
25617 {
25618 PyThreadState* __tstate = wxPyBeginAllowThreads();
25619 result = wxDateSpan::Weeks(arg1);
25620
25621 wxPyEndAllowThreads(__tstate);
25622 if (PyErr_Occurred()) SWIG_fail;
25623 }
25624 {
25625 wxDateSpan * resultptr;
25626 resultptr = new wxDateSpan((wxDateSpan &)(result));
25627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25628 }
25629 return resultobj;
25630 fail:
25631 return NULL;
25632 }
25633
25634
25635 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25636 PyObject *resultobj;
25637 wxDateSpan result;
25638 char *kwnames[] = {
25639 NULL
25640 };
25641
25642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 result = wxDateSpan::Week();
25646
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 {
25651 wxDateSpan * resultptr;
25652 resultptr = new wxDateSpan((wxDateSpan &)(result));
25653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25654 }
25655 return resultobj;
25656 fail:
25657 return NULL;
25658 }
25659
25660
25661 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25662 PyObject *resultobj;
25663 int arg1 ;
25664 wxDateSpan result;
25665 PyObject * obj0 = 0 ;
25666 char *kwnames[] = {
25667 (char *) "mon", NULL
25668 };
25669
25670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25671 {
25672 arg1 = (int)(SWIG_As_int(obj0));
25673 if (SWIG_arg_fail(1)) SWIG_fail;
25674 }
25675 {
25676 PyThreadState* __tstate = wxPyBeginAllowThreads();
25677 result = wxDateSpan::Months(arg1);
25678
25679 wxPyEndAllowThreads(__tstate);
25680 if (PyErr_Occurred()) SWIG_fail;
25681 }
25682 {
25683 wxDateSpan * resultptr;
25684 resultptr = new wxDateSpan((wxDateSpan &)(result));
25685 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25686 }
25687 return resultobj;
25688 fail:
25689 return NULL;
25690 }
25691
25692
25693 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25694 PyObject *resultobj;
25695 wxDateSpan result;
25696 char *kwnames[] = {
25697 NULL
25698 };
25699
25700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25701 {
25702 PyThreadState* __tstate = wxPyBeginAllowThreads();
25703 result = wxDateSpan::Month();
25704
25705 wxPyEndAllowThreads(__tstate);
25706 if (PyErr_Occurred()) SWIG_fail;
25707 }
25708 {
25709 wxDateSpan * resultptr;
25710 resultptr = new wxDateSpan((wxDateSpan &)(result));
25711 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25712 }
25713 return resultobj;
25714 fail:
25715 return NULL;
25716 }
25717
25718
25719 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25720 PyObject *resultobj;
25721 int arg1 ;
25722 wxDateSpan result;
25723 PyObject * obj0 = 0 ;
25724 char *kwnames[] = {
25725 (char *) "years", NULL
25726 };
25727
25728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25729 {
25730 arg1 = (int)(SWIG_As_int(obj0));
25731 if (SWIG_arg_fail(1)) SWIG_fail;
25732 }
25733 {
25734 PyThreadState* __tstate = wxPyBeginAllowThreads();
25735 result = wxDateSpan::Years(arg1);
25736
25737 wxPyEndAllowThreads(__tstate);
25738 if (PyErr_Occurred()) SWIG_fail;
25739 }
25740 {
25741 wxDateSpan * resultptr;
25742 resultptr = new wxDateSpan((wxDateSpan &)(result));
25743 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25744 }
25745 return resultobj;
25746 fail:
25747 return NULL;
25748 }
25749
25750
25751 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25752 PyObject *resultobj;
25753 wxDateSpan result;
25754 char *kwnames[] = {
25755 NULL
25756 };
25757
25758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25759 {
25760 PyThreadState* __tstate = wxPyBeginAllowThreads();
25761 result = wxDateSpan::Year();
25762
25763 wxPyEndAllowThreads(__tstate);
25764 if (PyErr_Occurred()) SWIG_fail;
25765 }
25766 {
25767 wxDateSpan * resultptr;
25768 resultptr = new wxDateSpan((wxDateSpan &)(result));
25769 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25770 }
25771 return resultobj;
25772 fail:
25773 return NULL;
25774 }
25775
25776
25777 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25778 PyObject *resultobj;
25779 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25780 int arg2 ;
25781 wxDateSpan *result;
25782 PyObject * obj0 = 0 ;
25783 PyObject * obj1 = 0 ;
25784 char *kwnames[] = {
25785 (char *) "self",(char *) "n", NULL
25786 };
25787
25788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25790 if (SWIG_arg_fail(1)) SWIG_fail;
25791 {
25792 arg2 = (int)(SWIG_As_int(obj1));
25793 if (SWIG_arg_fail(2)) SWIG_fail;
25794 }
25795 {
25796 PyThreadState* __tstate = wxPyBeginAllowThreads();
25797 {
25798 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25799 result = (wxDateSpan *) &_result_ref;
25800 }
25801
25802 wxPyEndAllowThreads(__tstate);
25803 if (PyErr_Occurred()) SWIG_fail;
25804 }
25805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25813 PyObject *resultobj;
25814 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25815 int arg2 ;
25816 wxDateSpan *result;
25817 PyObject * obj0 = 0 ;
25818 PyObject * obj1 = 0 ;
25819 char *kwnames[] = {
25820 (char *) "self",(char *) "n", NULL
25821 };
25822
25823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25825 if (SWIG_arg_fail(1)) SWIG_fail;
25826 {
25827 arg2 = (int)(SWIG_As_int(obj1));
25828 if (SWIG_arg_fail(2)) SWIG_fail;
25829 }
25830 {
25831 PyThreadState* __tstate = wxPyBeginAllowThreads();
25832 {
25833 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25834 result = (wxDateSpan *) &_result_ref;
25835 }
25836
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25841 return resultobj;
25842 fail:
25843 return NULL;
25844 }
25845
25846
25847 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25848 PyObject *resultobj;
25849 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25850 int arg2 ;
25851 wxDateSpan *result;
25852 PyObject * obj0 = 0 ;
25853 PyObject * obj1 = 0 ;
25854 char *kwnames[] = {
25855 (char *) "self",(char *) "n", NULL
25856 };
25857
25858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25860 if (SWIG_arg_fail(1)) SWIG_fail;
25861 {
25862 arg2 = (int)(SWIG_As_int(obj1));
25863 if (SWIG_arg_fail(2)) SWIG_fail;
25864 }
25865 {
25866 PyThreadState* __tstate = wxPyBeginAllowThreads();
25867 {
25868 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25869 result = (wxDateSpan *) &_result_ref;
25870 }
25871
25872 wxPyEndAllowThreads(__tstate);
25873 if (PyErr_Occurred()) SWIG_fail;
25874 }
25875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25876 return resultobj;
25877 fail:
25878 return NULL;
25879 }
25880
25881
25882 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25883 PyObject *resultobj;
25884 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25885 int arg2 ;
25886 wxDateSpan *result;
25887 PyObject * obj0 = 0 ;
25888 PyObject * obj1 = 0 ;
25889 char *kwnames[] = {
25890 (char *) "self",(char *) "n", NULL
25891 };
25892
25893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25895 if (SWIG_arg_fail(1)) SWIG_fail;
25896 {
25897 arg2 = (int)(SWIG_As_int(obj1));
25898 if (SWIG_arg_fail(2)) SWIG_fail;
25899 }
25900 {
25901 PyThreadState* __tstate = wxPyBeginAllowThreads();
25902 {
25903 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25904 result = (wxDateSpan *) &_result_ref;
25905 }
25906
25907 wxPyEndAllowThreads(__tstate);
25908 if (PyErr_Occurred()) SWIG_fail;
25909 }
25910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25911 return resultobj;
25912 fail:
25913 return NULL;
25914 }
25915
25916
25917 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25918 PyObject *resultobj;
25919 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25920 int result;
25921 PyObject * obj0 = 0 ;
25922 char *kwnames[] = {
25923 (char *) "self", NULL
25924 };
25925
25926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25928 if (SWIG_arg_fail(1)) SWIG_fail;
25929 {
25930 PyThreadState* __tstate = wxPyBeginAllowThreads();
25931 result = (int)((wxDateSpan const *)arg1)->GetYears();
25932
25933 wxPyEndAllowThreads(__tstate);
25934 if (PyErr_Occurred()) SWIG_fail;
25935 }
25936 {
25937 resultobj = SWIG_From_int((int)(result));
25938 }
25939 return resultobj;
25940 fail:
25941 return NULL;
25942 }
25943
25944
25945 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25946 PyObject *resultobj;
25947 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25948 int result;
25949 PyObject * obj0 = 0 ;
25950 char *kwnames[] = {
25951 (char *) "self", NULL
25952 };
25953
25954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25956 if (SWIG_arg_fail(1)) SWIG_fail;
25957 {
25958 PyThreadState* __tstate = wxPyBeginAllowThreads();
25959 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25960
25961 wxPyEndAllowThreads(__tstate);
25962 if (PyErr_Occurred()) SWIG_fail;
25963 }
25964 {
25965 resultobj = SWIG_From_int((int)(result));
25966 }
25967 return resultobj;
25968 fail:
25969 return NULL;
25970 }
25971
25972
25973 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25974 PyObject *resultobj;
25975 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25976 int result;
25977 PyObject * obj0 = 0 ;
25978 char *kwnames[] = {
25979 (char *) "self", NULL
25980 };
25981
25982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25984 if (SWIG_arg_fail(1)) SWIG_fail;
25985 {
25986 PyThreadState* __tstate = wxPyBeginAllowThreads();
25987 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25988
25989 wxPyEndAllowThreads(__tstate);
25990 if (PyErr_Occurred()) SWIG_fail;
25991 }
25992 {
25993 resultobj = SWIG_From_int((int)(result));
25994 }
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj;
26003 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26004 int result;
26005 PyObject * obj0 = 0 ;
26006 char *kwnames[] = {
26007 (char *) "self", NULL
26008 };
26009
26010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
26011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26012 if (SWIG_arg_fail(1)) SWIG_fail;
26013 {
26014 PyThreadState* __tstate = wxPyBeginAllowThreads();
26015 result = (int)((wxDateSpan const *)arg1)->GetDays();
26016
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 {
26021 resultobj = SWIG_From_int((int)(result));
26022 }
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
26030 PyObject *resultobj;
26031 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26032 int result;
26033 PyObject * obj0 = 0 ;
26034 char *kwnames[] = {
26035 (char *) "self", NULL
26036 };
26037
26038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
26039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26040 if (SWIG_arg_fail(1)) SWIG_fail;
26041 {
26042 PyThreadState* __tstate = wxPyBeginAllowThreads();
26043 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
26044
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 {
26049 resultobj = SWIG_From_int((int)(result));
26050 }
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
26058 PyObject *resultobj;
26059 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26060 wxDateSpan *arg2 = 0 ;
26061 wxDateSpan *result;
26062 PyObject * obj0 = 0 ;
26063 PyObject * obj1 = 0 ;
26064 char *kwnames[] = {
26065 (char *) "self",(char *) "other", NULL
26066 };
26067
26068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
26069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26070 if (SWIG_arg_fail(1)) SWIG_fail;
26071 {
26072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26073 if (SWIG_arg_fail(2)) SWIG_fail;
26074 if (arg2 == NULL) {
26075 SWIG_null_ref("wxDateSpan");
26076 }
26077 if (SWIG_arg_fail(2)) SWIG_fail;
26078 }
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 {
26082 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26083 result = (wxDateSpan *) &_result_ref;
26084 }
26085
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26090 return resultobj;
26091 fail:
26092 return NULL;
26093 }
26094
26095
26096 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
26097 PyObject *resultobj;
26098 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26099 wxDateSpan *arg2 = 0 ;
26100 wxDateSpan *result;
26101 PyObject * obj0 = 0 ;
26102 PyObject * obj1 = 0 ;
26103 char *kwnames[] = {
26104 (char *) "self",(char *) "other", NULL
26105 };
26106
26107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
26108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26109 if (SWIG_arg_fail(1)) SWIG_fail;
26110 {
26111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26112 if (SWIG_arg_fail(2)) SWIG_fail;
26113 if (arg2 == NULL) {
26114 SWIG_null_ref("wxDateSpan");
26115 }
26116 if (SWIG_arg_fail(2)) SWIG_fail;
26117 }
26118 {
26119 PyThreadState* __tstate = wxPyBeginAllowThreads();
26120 {
26121 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26122 result = (wxDateSpan *) &_result_ref;
26123 }
26124
26125 wxPyEndAllowThreads(__tstate);
26126 if (PyErr_Occurred()) SWIG_fail;
26127 }
26128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26129 return resultobj;
26130 fail:
26131 return NULL;
26132 }
26133
26134
26135 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26136 PyObject *resultobj;
26137 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26138 wxDateSpan *result;
26139 PyObject * obj0 = 0 ;
26140 char *kwnames[] = {
26141 (char *) "self", NULL
26142 };
26143
26144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26146 if (SWIG_arg_fail(1)) SWIG_fail;
26147 {
26148 PyThreadState* __tstate = wxPyBeginAllowThreads();
26149 {
26150 wxDateSpan &_result_ref = (arg1)->Neg();
26151 result = (wxDateSpan *) &_result_ref;
26152 }
26153
26154 wxPyEndAllowThreads(__tstate);
26155 if (PyErr_Occurred()) SWIG_fail;
26156 }
26157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26158 return resultobj;
26159 fail:
26160 return NULL;
26161 }
26162
26163
26164 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26165 PyObject *resultobj;
26166 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26167 int arg2 ;
26168 wxDateSpan *result;
26169 PyObject * obj0 = 0 ;
26170 PyObject * obj1 = 0 ;
26171 char *kwnames[] = {
26172 (char *) "self",(char *) "factor", NULL
26173 };
26174
26175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
26180 if (SWIG_arg_fail(2)) SWIG_fail;
26181 }
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 {
26185 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26186 result = (wxDateSpan *) &_result_ref;
26187 }
26188
26189 wxPyEndAllowThreads(__tstate);
26190 if (PyErr_Occurred()) SWIG_fail;
26191 }
26192 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26193 return resultobj;
26194 fail:
26195 return NULL;
26196 }
26197
26198
26199 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26200 PyObject *resultobj;
26201 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26202 wxDateSpan *arg2 = 0 ;
26203 wxDateSpan *result;
26204 PyObject * obj0 = 0 ;
26205 PyObject * obj1 = 0 ;
26206 char *kwnames[] = {
26207 (char *) "self",(char *) "other", NULL
26208 };
26209
26210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26212 if (SWIG_arg_fail(1)) SWIG_fail;
26213 {
26214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26215 if (SWIG_arg_fail(2)) SWIG_fail;
26216 if (arg2 == NULL) {
26217 SWIG_null_ref("wxDateSpan");
26218 }
26219 if (SWIG_arg_fail(2)) SWIG_fail;
26220 }
26221 {
26222 PyThreadState* __tstate = wxPyBeginAllowThreads();
26223 {
26224 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26225 result = (wxDateSpan *) &_result_ref;
26226 }
26227
26228 wxPyEndAllowThreads(__tstate);
26229 if (PyErr_Occurred()) SWIG_fail;
26230 }
26231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26239 PyObject *resultobj;
26240 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26241 wxDateSpan *arg2 = 0 ;
26242 wxDateSpan *result;
26243 PyObject * obj0 = 0 ;
26244 PyObject * obj1 = 0 ;
26245 char *kwnames[] = {
26246 (char *) "self",(char *) "other", NULL
26247 };
26248
26249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26251 if (SWIG_arg_fail(1)) SWIG_fail;
26252 {
26253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26254 if (SWIG_arg_fail(2)) SWIG_fail;
26255 if (arg2 == NULL) {
26256 SWIG_null_ref("wxDateSpan");
26257 }
26258 if (SWIG_arg_fail(2)) SWIG_fail;
26259 }
26260 {
26261 PyThreadState* __tstate = wxPyBeginAllowThreads();
26262 {
26263 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26264 result = (wxDateSpan *) &_result_ref;
26265 }
26266
26267 wxPyEndAllowThreads(__tstate);
26268 if (PyErr_Occurred()) SWIG_fail;
26269 }
26270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26271 return resultobj;
26272 fail:
26273 return NULL;
26274 }
26275
26276
26277 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26278 PyObject *resultobj;
26279 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26280 wxDateSpan *result;
26281 PyObject * obj0 = 0 ;
26282 char *kwnames[] = {
26283 (char *) "self", NULL
26284 };
26285
26286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26288 if (SWIG_arg_fail(1)) SWIG_fail;
26289 {
26290 PyThreadState* __tstate = wxPyBeginAllowThreads();
26291 {
26292 wxDateSpan &_result_ref = (arg1)->operator -();
26293 result = (wxDateSpan *) &_result_ref;
26294 }
26295
26296 wxPyEndAllowThreads(__tstate);
26297 if (PyErr_Occurred()) SWIG_fail;
26298 }
26299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26300 return resultobj;
26301 fail:
26302 return NULL;
26303 }
26304
26305
26306 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26307 PyObject *resultobj;
26308 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26309 int arg2 ;
26310 wxDateSpan *result;
26311 PyObject * obj0 = 0 ;
26312 PyObject * obj1 = 0 ;
26313 char *kwnames[] = {
26314 (char *) "self",(char *) "factor", NULL
26315 };
26316
26317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26319 if (SWIG_arg_fail(1)) SWIG_fail;
26320 {
26321 arg2 = (int)(SWIG_As_int(obj1));
26322 if (SWIG_arg_fail(2)) SWIG_fail;
26323 }
26324 {
26325 PyThreadState* __tstate = wxPyBeginAllowThreads();
26326 {
26327 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26328 result = (wxDateSpan *) &_result_ref;
26329 }
26330
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj;
26343 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26344 wxDateSpan *arg2 = 0 ;
26345 wxDateSpan result;
26346 PyObject * obj0 = 0 ;
26347 PyObject * obj1 = 0 ;
26348 char *kwnames[] = {
26349 (char *) "self",(char *) "other", NULL
26350 };
26351
26352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26354 if (SWIG_arg_fail(1)) SWIG_fail;
26355 {
26356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26357 if (SWIG_arg_fail(2)) SWIG_fail;
26358 if (arg2 == NULL) {
26359 SWIG_null_ref("wxDateSpan");
26360 }
26361 if (SWIG_arg_fail(2)) SWIG_fail;
26362 }
26363 {
26364 PyThreadState* __tstate = wxPyBeginAllowThreads();
26365 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26366
26367 wxPyEndAllowThreads(__tstate);
26368 if (PyErr_Occurred()) SWIG_fail;
26369 }
26370 {
26371 wxDateSpan * resultptr;
26372 resultptr = new wxDateSpan((wxDateSpan &)(result));
26373 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26374 }
26375 return resultobj;
26376 fail:
26377 return NULL;
26378 }
26379
26380
26381 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26382 PyObject *resultobj;
26383 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26384 wxDateSpan *arg2 = 0 ;
26385 wxDateSpan result;
26386 PyObject * obj0 = 0 ;
26387 PyObject * obj1 = 0 ;
26388 char *kwnames[] = {
26389 (char *) "self",(char *) "other", NULL
26390 };
26391
26392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26394 if (SWIG_arg_fail(1)) SWIG_fail;
26395 {
26396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26397 if (SWIG_arg_fail(2)) SWIG_fail;
26398 if (arg2 == NULL) {
26399 SWIG_null_ref("wxDateSpan");
26400 }
26401 if (SWIG_arg_fail(2)) SWIG_fail;
26402 }
26403 {
26404 PyThreadState* __tstate = wxPyBeginAllowThreads();
26405 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26406
26407 wxPyEndAllowThreads(__tstate);
26408 if (PyErr_Occurred()) SWIG_fail;
26409 }
26410 {
26411 wxDateSpan * resultptr;
26412 resultptr = new wxDateSpan((wxDateSpan &)(result));
26413 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26414 }
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26422 PyObject *resultobj;
26423 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26424 int arg2 ;
26425 wxDateSpan result;
26426 PyObject * obj0 = 0 ;
26427 PyObject * obj1 = 0 ;
26428 char *kwnames[] = {
26429 (char *) "self",(char *) "n", NULL
26430 };
26431
26432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26434 if (SWIG_arg_fail(1)) SWIG_fail;
26435 {
26436 arg2 = (int)(SWIG_As_int(obj1));
26437 if (SWIG_arg_fail(2)) SWIG_fail;
26438 }
26439 {
26440 PyThreadState* __tstate = wxPyBeginAllowThreads();
26441 result = wxDateSpan___mul__(arg1,arg2);
26442
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 {
26447 wxDateSpan * resultptr;
26448 resultptr = new wxDateSpan((wxDateSpan &)(result));
26449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26450 }
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj;
26459 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26460 int arg2 ;
26461 wxDateSpan result;
26462 PyObject * obj0 = 0 ;
26463 PyObject * obj1 = 0 ;
26464 char *kwnames[] = {
26465 (char *) "self",(char *) "n", NULL
26466 };
26467
26468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26470 if (SWIG_arg_fail(1)) SWIG_fail;
26471 {
26472 arg2 = (int)(SWIG_As_int(obj1));
26473 if (SWIG_arg_fail(2)) SWIG_fail;
26474 }
26475 {
26476 PyThreadState* __tstate = wxPyBeginAllowThreads();
26477 result = wxDateSpan___rmul__(arg1,arg2);
26478
26479 wxPyEndAllowThreads(__tstate);
26480 if (PyErr_Occurred()) SWIG_fail;
26481 }
26482 {
26483 wxDateSpan * resultptr;
26484 resultptr = new wxDateSpan((wxDateSpan &)(result));
26485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26486 }
26487 return resultobj;
26488 fail:
26489 return NULL;
26490 }
26491
26492
26493 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26494 PyObject *resultobj;
26495 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26496 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26497 bool result;
26498 PyObject * obj0 = 0 ;
26499 PyObject * obj1 = 0 ;
26500 char *kwnames[] = {
26501 (char *) "self",(char *) "other", NULL
26502 };
26503
26504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26506 if (SWIG_arg_fail(1)) SWIG_fail;
26507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26508 if (SWIG_arg_fail(2)) SWIG_fail;
26509 {
26510 PyThreadState* __tstate = wxPyBeginAllowThreads();
26511 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26512
26513 wxPyEndAllowThreads(__tstate);
26514 if (PyErr_Occurred()) SWIG_fail;
26515 }
26516 {
26517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26518 }
26519 return resultobj;
26520 fail:
26521 return NULL;
26522 }
26523
26524
26525 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26526 PyObject *resultobj;
26527 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26528 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26529 bool result;
26530 PyObject * obj0 = 0 ;
26531 PyObject * obj1 = 0 ;
26532 char *kwnames[] = {
26533 (char *) "self",(char *) "other", NULL
26534 };
26535
26536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26538 if (SWIG_arg_fail(1)) SWIG_fail;
26539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26540 if (SWIG_arg_fail(2)) SWIG_fail;
26541 {
26542 PyThreadState* __tstate = wxPyBeginAllowThreads();
26543 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26544
26545 wxPyEndAllowThreads(__tstate);
26546 if (PyErr_Occurred()) SWIG_fail;
26547 }
26548 {
26549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26550 }
26551 return resultobj;
26552 fail:
26553 return NULL;
26554 }
26555
26556
26557 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26558 PyObject *obj;
26559 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26560 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26561 Py_INCREF(obj);
26562 return Py_BuildValue((char *)"");
26563 }
26564 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26565 PyObject *resultobj;
26566 long result;
26567 char *kwnames[] = {
26568 NULL
26569 };
26570
26571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26572 {
26573 PyThreadState* __tstate = wxPyBeginAllowThreads();
26574 result = (long)wxGetLocalTime();
26575
26576 wxPyEndAllowThreads(__tstate);
26577 if (PyErr_Occurred()) SWIG_fail;
26578 }
26579 {
26580 resultobj = SWIG_From_long((long)(result));
26581 }
26582 return resultobj;
26583 fail:
26584 return NULL;
26585 }
26586
26587
26588 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26589 PyObject *resultobj;
26590 long result;
26591 char *kwnames[] = {
26592 NULL
26593 };
26594
26595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26596 {
26597 PyThreadState* __tstate = wxPyBeginAllowThreads();
26598 result = (long)wxGetUTCTime();
26599
26600 wxPyEndAllowThreads(__tstate);
26601 if (PyErr_Occurred()) SWIG_fail;
26602 }
26603 {
26604 resultobj = SWIG_From_long((long)(result));
26605 }
26606 return resultobj;
26607 fail:
26608 return NULL;
26609 }
26610
26611
26612 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26613 PyObject *resultobj;
26614 long result;
26615 char *kwnames[] = {
26616 NULL
26617 };
26618
26619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26620 {
26621 PyThreadState* __tstate = wxPyBeginAllowThreads();
26622 result = (long)wxGetCurrentTime();
26623
26624 wxPyEndAllowThreads(__tstate);
26625 if (PyErr_Occurred()) SWIG_fail;
26626 }
26627 {
26628 resultobj = SWIG_From_long((long)(result));
26629 }
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26637 PyObject *resultobj;
26638 wxLongLong result;
26639 char *kwnames[] = {
26640 NULL
26641 };
26642
26643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26644 {
26645 PyThreadState* __tstate = wxPyBeginAllowThreads();
26646 result = wxGetLocalTimeMillis();
26647
26648 wxPyEndAllowThreads(__tstate);
26649 if (PyErr_Occurred()) SWIG_fail;
26650 }
26651 {
26652 PyObject *hi, *lo, *shifter, *shifted;
26653 hi = PyLong_FromLong( (&result)->GetHi() );
26654 lo = PyLong_FromLong( (&result)->GetLo() );
26655 shifter = PyLong_FromLong(32);
26656 shifted = PyNumber_Lshift(hi, shifter);
26657 resultobj = PyNumber_Or(shifted, lo);
26658 Py_DECREF(hi);
26659 Py_DECREF(lo);
26660 Py_DECREF(shifter);
26661 Py_DECREF(shifted);
26662 }
26663 return resultobj;
26664 fail:
26665 return NULL;
26666 }
26667
26668
26669 static int _wrap_DefaultDateTime_set(PyObject *) {
26670 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26671 return 1;
26672 }
26673
26674
26675 static PyObject *_wrap_DefaultDateTime_get(void) {
26676 PyObject *pyobj;
26677
26678 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26679 return pyobj;
26680 }
26681
26682
26683 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26684 PyObject *resultobj;
26685 wxDataFormatId arg1 ;
26686 wxDataFormat *result;
26687 PyObject * obj0 = 0 ;
26688 char *kwnames[] = {
26689 (char *) "type", NULL
26690 };
26691
26692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26693 {
26694 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26695 if (SWIG_arg_fail(1)) SWIG_fail;
26696 }
26697 {
26698 PyThreadState* __tstate = wxPyBeginAllowThreads();
26699 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26700
26701 wxPyEndAllowThreads(__tstate);
26702 if (PyErr_Occurred()) SWIG_fail;
26703 }
26704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26705 return resultobj;
26706 fail:
26707 return NULL;
26708 }
26709
26710
26711 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26712 PyObject *resultobj;
26713 wxString *arg1 = 0 ;
26714 wxDataFormat *result;
26715 bool temp1 = false ;
26716 PyObject * obj0 = 0 ;
26717 char *kwnames[] = {
26718 (char *) "format", NULL
26719 };
26720
26721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26722 {
26723 arg1 = wxString_in_helper(obj0);
26724 if (arg1 == NULL) SWIG_fail;
26725 temp1 = true;
26726 }
26727 {
26728 PyThreadState* __tstate = wxPyBeginAllowThreads();
26729 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26730
26731 wxPyEndAllowThreads(__tstate);
26732 if (PyErr_Occurred()) SWIG_fail;
26733 }
26734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26735 {
26736 if (temp1)
26737 delete arg1;
26738 }
26739 return resultobj;
26740 fail:
26741 {
26742 if (temp1)
26743 delete arg1;
26744 }
26745 return NULL;
26746 }
26747
26748
26749 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj;
26751 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26752 PyObject * obj0 = 0 ;
26753 char *kwnames[] = {
26754 (char *) "self", NULL
26755 };
26756
26757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26759 if (SWIG_arg_fail(1)) SWIG_fail;
26760 {
26761 PyThreadState* __tstate = wxPyBeginAllowThreads();
26762 delete arg1;
26763
26764 wxPyEndAllowThreads(__tstate);
26765 if (PyErr_Occurred()) SWIG_fail;
26766 }
26767 Py_INCREF(Py_None); resultobj = Py_None;
26768 return resultobj;
26769 fail:
26770 return NULL;
26771 }
26772
26773
26774 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26775 PyObject *resultobj;
26776 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26777 wxDataFormatId arg2 ;
26778 bool result;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781
26782 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26784 if (SWIG_arg_fail(1)) SWIG_fail;
26785 {
26786 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26787 if (SWIG_arg_fail(2)) SWIG_fail;
26788 }
26789 {
26790 PyThreadState* __tstate = wxPyBeginAllowThreads();
26791 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26792
26793 wxPyEndAllowThreads(__tstate);
26794 if (PyErr_Occurred()) SWIG_fail;
26795 }
26796 {
26797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26798 }
26799 return resultobj;
26800 fail:
26801 return NULL;
26802 }
26803
26804
26805 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26806 PyObject *resultobj;
26807 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26808 wxDataFormatId arg2 ;
26809 bool result;
26810 PyObject * obj0 = 0 ;
26811 PyObject * obj1 = 0 ;
26812
26813 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26815 if (SWIG_arg_fail(1)) SWIG_fail;
26816 {
26817 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26818 if (SWIG_arg_fail(2)) SWIG_fail;
26819 }
26820 {
26821 PyThreadState* __tstate = wxPyBeginAllowThreads();
26822 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26823
26824 wxPyEndAllowThreads(__tstate);
26825 if (PyErr_Occurred()) SWIG_fail;
26826 }
26827 {
26828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26829 }
26830 return resultobj;
26831 fail:
26832 return NULL;
26833 }
26834
26835
26836 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26837 PyObject *resultobj;
26838 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26839 wxDataFormat *arg2 = 0 ;
26840 bool result;
26841 PyObject * obj0 = 0 ;
26842 PyObject * obj1 = 0 ;
26843
26844 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26846 if (SWIG_arg_fail(1)) SWIG_fail;
26847 {
26848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26849 if (SWIG_arg_fail(2)) SWIG_fail;
26850 if (arg2 == NULL) {
26851 SWIG_null_ref("wxDataFormat");
26852 }
26853 if (SWIG_arg_fail(2)) SWIG_fail;
26854 }
26855 {
26856 PyThreadState* __tstate = wxPyBeginAllowThreads();
26857 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26858
26859 wxPyEndAllowThreads(__tstate);
26860 if (PyErr_Occurred()) SWIG_fail;
26861 }
26862 {
26863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26864 }
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26872 int argc;
26873 PyObject *argv[3];
26874 int ii;
26875
26876 argc = PyObject_Length(args);
26877 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26878 argv[ii] = PyTuple_GetItem(args,ii);
26879 }
26880 if (argc == 2) {
26881 int _v;
26882 {
26883 void *ptr;
26884 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26885 _v = 0;
26886 PyErr_Clear();
26887 } else {
26888 _v = 1;
26889 }
26890 }
26891 if (_v) {
26892 {
26893 void *ptr = 0;
26894 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26895 _v = 0;
26896 PyErr_Clear();
26897 } else {
26898 _v = (ptr != 0);
26899 }
26900 }
26901 if (_v) {
26902 return _wrap_DataFormat___eq____SWIG_1(self,args);
26903 }
26904 }
26905 }
26906 if (argc == 2) {
26907 int _v;
26908 {
26909 void *ptr;
26910 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26911 _v = 0;
26912 PyErr_Clear();
26913 } else {
26914 _v = 1;
26915 }
26916 }
26917 if (_v) {
26918 _v = SWIG_Check_int(argv[1]);
26919 if (_v) {
26920 return _wrap_DataFormat___eq____SWIG_0(self,args);
26921 }
26922 }
26923 }
26924
26925 Py_INCREF(Py_NotImplemented);
26926 return Py_NotImplemented;
26927 }
26928
26929
26930 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26931 PyObject *resultobj;
26932 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26933 wxDataFormat *arg2 = 0 ;
26934 bool result;
26935 PyObject * obj0 = 0 ;
26936 PyObject * obj1 = 0 ;
26937
26938 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26940 if (SWIG_arg_fail(1)) SWIG_fail;
26941 {
26942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26943 if (SWIG_arg_fail(2)) SWIG_fail;
26944 if (arg2 == NULL) {
26945 SWIG_null_ref("wxDataFormat");
26946 }
26947 if (SWIG_arg_fail(2)) SWIG_fail;
26948 }
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26952
26953 wxPyEndAllowThreads(__tstate);
26954 if (PyErr_Occurred()) SWIG_fail;
26955 }
26956 {
26957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26958 }
26959 return resultobj;
26960 fail:
26961 return NULL;
26962 }
26963
26964
26965 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26966 int argc;
26967 PyObject *argv[3];
26968 int ii;
26969
26970 argc = PyObject_Length(args);
26971 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26972 argv[ii] = PyTuple_GetItem(args,ii);
26973 }
26974 if (argc == 2) {
26975 int _v;
26976 {
26977 void *ptr;
26978 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26979 _v = 0;
26980 PyErr_Clear();
26981 } else {
26982 _v = 1;
26983 }
26984 }
26985 if (_v) {
26986 {
26987 void *ptr = 0;
26988 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26989 _v = 0;
26990 PyErr_Clear();
26991 } else {
26992 _v = (ptr != 0);
26993 }
26994 }
26995 if (_v) {
26996 return _wrap_DataFormat___ne____SWIG_1(self,args);
26997 }
26998 }
26999 }
27000 if (argc == 2) {
27001 int _v;
27002 {
27003 void *ptr;
27004 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27005 _v = 0;
27006 PyErr_Clear();
27007 } else {
27008 _v = 1;
27009 }
27010 }
27011 if (_v) {
27012 _v = SWIG_Check_int(argv[1]);
27013 if (_v) {
27014 return _wrap_DataFormat___ne____SWIG_0(self,args);
27015 }
27016 }
27017 }
27018
27019 Py_INCREF(Py_NotImplemented);
27020 return Py_NotImplemented;
27021 }
27022
27023
27024 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
27025 PyObject *resultobj;
27026 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27027 wxDataFormatId arg2 ;
27028 PyObject * obj0 = 0 ;
27029 PyObject * obj1 = 0 ;
27030 char *kwnames[] = {
27031 (char *) "self",(char *) "format", NULL
27032 };
27033
27034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
27035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27036 if (SWIG_arg_fail(1)) SWIG_fail;
27037 {
27038 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
27039 if (SWIG_arg_fail(2)) SWIG_fail;
27040 }
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 (arg1)->SetType((wxDataFormatId )arg2);
27044
27045 wxPyEndAllowThreads(__tstate);
27046 if (PyErr_Occurred()) SWIG_fail;
27047 }
27048 Py_INCREF(Py_None); resultobj = Py_None;
27049 return resultobj;
27050 fail:
27051 return NULL;
27052 }
27053
27054
27055 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
27056 PyObject *resultobj;
27057 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27058 wxDataFormatId result;
27059 PyObject * obj0 = 0 ;
27060 char *kwnames[] = {
27061 (char *) "self", NULL
27062 };
27063
27064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
27065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27066 if (SWIG_arg_fail(1)) SWIG_fail;
27067 {
27068 PyThreadState* __tstate = wxPyBeginAllowThreads();
27069 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
27070
27071 wxPyEndAllowThreads(__tstate);
27072 if (PyErr_Occurred()) SWIG_fail;
27073 }
27074 resultobj = SWIG_From_int((result));
27075 return resultobj;
27076 fail:
27077 return NULL;
27078 }
27079
27080
27081 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
27082 PyObject *resultobj;
27083 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27084 wxString result;
27085 PyObject * obj0 = 0 ;
27086 char *kwnames[] = {
27087 (char *) "self", NULL
27088 };
27089
27090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
27091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27092 if (SWIG_arg_fail(1)) SWIG_fail;
27093 {
27094 PyThreadState* __tstate = wxPyBeginAllowThreads();
27095 result = ((wxDataFormat const *)arg1)->GetId();
27096
27097 wxPyEndAllowThreads(__tstate);
27098 if (PyErr_Occurred()) SWIG_fail;
27099 }
27100 {
27101 #if wxUSE_UNICODE
27102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27103 #else
27104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27105 #endif
27106 }
27107 return resultobj;
27108 fail:
27109 return NULL;
27110 }
27111
27112
27113 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27114 PyObject *resultobj;
27115 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27116 wxString *arg2 = 0 ;
27117 bool temp2 = false ;
27118 PyObject * obj0 = 0 ;
27119 PyObject * obj1 = 0 ;
27120 char *kwnames[] = {
27121 (char *) "self",(char *) "format", NULL
27122 };
27123
27124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27126 if (SWIG_arg_fail(1)) SWIG_fail;
27127 {
27128 arg2 = wxString_in_helper(obj1);
27129 if (arg2 == NULL) SWIG_fail;
27130 temp2 = true;
27131 }
27132 {
27133 PyThreadState* __tstate = wxPyBeginAllowThreads();
27134 (arg1)->SetId((wxString const &)*arg2);
27135
27136 wxPyEndAllowThreads(__tstate);
27137 if (PyErr_Occurred()) SWIG_fail;
27138 }
27139 Py_INCREF(Py_None); resultobj = Py_None;
27140 {
27141 if (temp2)
27142 delete arg2;
27143 }
27144 return resultobj;
27145 fail:
27146 {
27147 if (temp2)
27148 delete arg2;
27149 }
27150 return NULL;
27151 }
27152
27153
27154 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27155 PyObject *obj;
27156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27157 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27158 Py_INCREF(obj);
27159 return Py_BuildValue((char *)"");
27160 }
27161 static int _wrap_FormatInvalid_set(PyObject *) {
27162 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27163 return 1;
27164 }
27165
27166
27167 static PyObject *_wrap_FormatInvalid_get(void) {
27168 PyObject *pyobj;
27169
27170 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27171 return pyobj;
27172 }
27173
27174
27175 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27176 PyObject *resultobj;
27177 wxDataObject *arg1 = (wxDataObject *) 0 ;
27178 PyObject * obj0 = 0 ;
27179 char *kwnames[] = {
27180 (char *) "self", NULL
27181 };
27182
27183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27185 if (SWIG_arg_fail(1)) SWIG_fail;
27186 {
27187 PyThreadState* __tstate = wxPyBeginAllowThreads();
27188 delete arg1;
27189
27190 wxPyEndAllowThreads(__tstate);
27191 if (PyErr_Occurred()) SWIG_fail;
27192 }
27193 Py_INCREF(Py_None); resultobj = Py_None;
27194 return resultobj;
27195 fail:
27196 return NULL;
27197 }
27198
27199
27200 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27201 PyObject *resultobj;
27202 wxDataObject *arg1 = (wxDataObject *) 0 ;
27203 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27204 SwigValueWrapper<wxDataFormat > result;
27205 PyObject * obj0 = 0 ;
27206 PyObject * obj1 = 0 ;
27207 char *kwnames[] = {
27208 (char *) "self",(char *) "dir", NULL
27209 };
27210
27211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27213 if (SWIG_arg_fail(1)) SWIG_fail;
27214 if (obj1) {
27215 {
27216 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27217 if (SWIG_arg_fail(2)) SWIG_fail;
27218 }
27219 }
27220 {
27221 PyThreadState* __tstate = wxPyBeginAllowThreads();
27222 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27223
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 {
27228 wxDataFormat * resultptr;
27229 resultptr = new wxDataFormat((wxDataFormat &)(result));
27230 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27231 }
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27239 PyObject *resultobj;
27240 wxDataObject *arg1 = (wxDataObject *) 0 ;
27241 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27242 size_t result;
27243 PyObject * obj0 = 0 ;
27244 PyObject * obj1 = 0 ;
27245 char *kwnames[] = {
27246 (char *) "self",(char *) "dir", NULL
27247 };
27248
27249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27251 if (SWIG_arg_fail(1)) SWIG_fail;
27252 if (obj1) {
27253 {
27254 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27255 if (SWIG_arg_fail(2)) SWIG_fail;
27256 }
27257 }
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27261
27262 wxPyEndAllowThreads(__tstate);
27263 if (PyErr_Occurred()) SWIG_fail;
27264 }
27265 {
27266 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27267 }
27268 return resultobj;
27269 fail:
27270 return NULL;
27271 }
27272
27273
27274 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27275 PyObject *resultobj;
27276 wxDataObject *arg1 = (wxDataObject *) 0 ;
27277 wxDataFormat *arg2 = 0 ;
27278 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27279 bool result;
27280 PyObject * obj0 = 0 ;
27281 PyObject * obj1 = 0 ;
27282 PyObject * obj2 = 0 ;
27283 char *kwnames[] = {
27284 (char *) "self",(char *) "format",(char *) "dir", NULL
27285 };
27286
27287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27289 if (SWIG_arg_fail(1)) SWIG_fail;
27290 {
27291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27292 if (SWIG_arg_fail(2)) SWIG_fail;
27293 if (arg2 == NULL) {
27294 SWIG_null_ref("wxDataFormat");
27295 }
27296 if (SWIG_arg_fail(2)) SWIG_fail;
27297 }
27298 if (obj2) {
27299 {
27300 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27301 if (SWIG_arg_fail(3)) SWIG_fail;
27302 }
27303 }
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27307
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 {
27312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27313 }
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27321 PyObject *resultobj;
27322 wxDataObject *arg1 = (wxDataObject *) 0 ;
27323 wxDataFormat *arg2 = 0 ;
27324 size_t result;
27325 PyObject * obj0 = 0 ;
27326 PyObject * obj1 = 0 ;
27327 char *kwnames[] = {
27328 (char *) "self",(char *) "format", NULL
27329 };
27330
27331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27333 if (SWIG_arg_fail(1)) SWIG_fail;
27334 {
27335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27336 if (SWIG_arg_fail(2)) SWIG_fail;
27337 if (arg2 == NULL) {
27338 SWIG_null_ref("wxDataFormat");
27339 }
27340 if (SWIG_arg_fail(2)) SWIG_fail;
27341 }
27342 {
27343 PyThreadState* __tstate = wxPyBeginAllowThreads();
27344 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27345
27346 wxPyEndAllowThreads(__tstate);
27347 if (PyErr_Occurred()) SWIG_fail;
27348 }
27349 {
27350 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27351 }
27352 return resultobj;
27353 fail:
27354 return NULL;
27355 }
27356
27357
27358 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27359 PyObject *resultobj;
27360 wxDataObject *arg1 = (wxDataObject *) 0 ;
27361 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27362 PyObject *result;
27363 PyObject * obj0 = 0 ;
27364 PyObject * obj1 = 0 ;
27365 char *kwnames[] = {
27366 (char *) "self",(char *) "dir", NULL
27367 };
27368
27369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27371 if (SWIG_arg_fail(1)) SWIG_fail;
27372 if (obj1) {
27373 {
27374 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27375 if (SWIG_arg_fail(2)) SWIG_fail;
27376 }
27377 }
27378 {
27379 PyThreadState* __tstate = wxPyBeginAllowThreads();
27380 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27381
27382 wxPyEndAllowThreads(__tstate);
27383 if (PyErr_Occurred()) SWIG_fail;
27384 }
27385 resultobj = result;
27386 return resultobj;
27387 fail:
27388 return NULL;
27389 }
27390
27391
27392 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27393 PyObject *resultobj;
27394 wxDataObject *arg1 = (wxDataObject *) 0 ;
27395 wxDataFormat *arg2 = 0 ;
27396 PyObject *result;
27397 PyObject * obj0 = 0 ;
27398 PyObject * obj1 = 0 ;
27399 char *kwnames[] = {
27400 (char *) "self",(char *) "format", NULL
27401 };
27402
27403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27405 if (SWIG_arg_fail(1)) SWIG_fail;
27406 {
27407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27408 if (SWIG_arg_fail(2)) SWIG_fail;
27409 if (arg2 == NULL) {
27410 SWIG_null_ref("wxDataFormat");
27411 }
27412 if (SWIG_arg_fail(2)) SWIG_fail;
27413 }
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27417
27418 wxPyEndAllowThreads(__tstate);
27419 if (PyErr_Occurred()) SWIG_fail;
27420 }
27421 resultobj = result;
27422 return resultobj;
27423 fail:
27424 return NULL;
27425 }
27426
27427
27428 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27429 PyObject *resultobj;
27430 wxDataObject *arg1 = (wxDataObject *) 0 ;
27431 wxDataFormat *arg2 = 0 ;
27432 PyObject *arg3 = (PyObject *) 0 ;
27433 bool result;
27434 PyObject * obj0 = 0 ;
27435 PyObject * obj1 = 0 ;
27436 PyObject * obj2 = 0 ;
27437 char *kwnames[] = {
27438 (char *) "self",(char *) "format",(char *) "data", NULL
27439 };
27440
27441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27443 if (SWIG_arg_fail(1)) SWIG_fail;
27444 {
27445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27446 if (SWIG_arg_fail(2)) SWIG_fail;
27447 if (arg2 == NULL) {
27448 SWIG_null_ref("wxDataFormat");
27449 }
27450 if (SWIG_arg_fail(2)) SWIG_fail;
27451 }
27452 arg3 = obj2;
27453 {
27454 PyThreadState* __tstate = wxPyBeginAllowThreads();
27455 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27456
27457 wxPyEndAllowThreads(__tstate);
27458 if (PyErr_Occurred()) SWIG_fail;
27459 }
27460 {
27461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27462 }
27463 return resultobj;
27464 fail:
27465 return NULL;
27466 }
27467
27468
27469 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27470 PyObject *obj;
27471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27472 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27473 Py_INCREF(obj);
27474 return Py_BuildValue((char *)"");
27475 }
27476 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27477 PyObject *resultobj;
27478 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27479 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27480 wxDataObjectSimple *result;
27481 PyObject * obj0 = 0 ;
27482 char *kwnames[] = {
27483 (char *) "format", NULL
27484 };
27485
27486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27487 if (obj0) {
27488 {
27489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27490 if (SWIG_arg_fail(1)) SWIG_fail;
27491 if (arg1 == NULL) {
27492 SWIG_null_ref("wxDataFormat");
27493 }
27494 if (SWIG_arg_fail(1)) SWIG_fail;
27495 }
27496 }
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27500
27501 wxPyEndAllowThreads(__tstate);
27502 if (PyErr_Occurred()) SWIG_fail;
27503 }
27504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27512 PyObject *resultobj;
27513 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27514 wxDataFormat *result;
27515 PyObject * obj0 = 0 ;
27516 char *kwnames[] = {
27517 (char *) "self", NULL
27518 };
27519
27520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27522 if (SWIG_arg_fail(1)) SWIG_fail;
27523 {
27524 PyThreadState* __tstate = wxPyBeginAllowThreads();
27525 {
27526 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27527 result = (wxDataFormat *) &_result_ref;
27528 }
27529
27530 wxPyEndAllowThreads(__tstate);
27531 if (PyErr_Occurred()) SWIG_fail;
27532 }
27533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27534 return resultobj;
27535 fail:
27536 return NULL;
27537 }
27538
27539
27540 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27541 PyObject *resultobj;
27542 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27543 wxDataFormat *arg2 = 0 ;
27544 PyObject * obj0 = 0 ;
27545 PyObject * obj1 = 0 ;
27546 char *kwnames[] = {
27547 (char *) "self",(char *) "format", NULL
27548 };
27549
27550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27552 if (SWIG_arg_fail(1)) SWIG_fail;
27553 {
27554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27555 if (SWIG_arg_fail(2)) SWIG_fail;
27556 if (arg2 == NULL) {
27557 SWIG_null_ref("wxDataFormat");
27558 }
27559 if (SWIG_arg_fail(2)) SWIG_fail;
27560 }
27561 {
27562 PyThreadState* __tstate = wxPyBeginAllowThreads();
27563 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27564
27565 wxPyEndAllowThreads(__tstate);
27566 if (PyErr_Occurred()) SWIG_fail;
27567 }
27568 Py_INCREF(Py_None); resultobj = Py_None;
27569 return resultobj;
27570 fail:
27571 return NULL;
27572 }
27573
27574
27575 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27576 PyObject *resultobj;
27577 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27578 size_t result;
27579 PyObject * obj0 = 0 ;
27580 char *kwnames[] = {
27581 (char *) "self", NULL
27582 };
27583
27584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27586 if (SWIG_arg_fail(1)) SWIG_fail;
27587 {
27588 PyThreadState* __tstate = wxPyBeginAllowThreads();
27589 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27590
27591 wxPyEndAllowThreads(__tstate);
27592 if (PyErr_Occurred()) SWIG_fail;
27593 }
27594 {
27595 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27596 }
27597 return resultobj;
27598 fail:
27599 return NULL;
27600 }
27601
27602
27603 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27604 PyObject *resultobj;
27605 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27606 PyObject *result;
27607 PyObject * obj0 = 0 ;
27608 char *kwnames[] = {
27609 (char *) "self", NULL
27610 };
27611
27612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27614 if (SWIG_arg_fail(1)) SWIG_fail;
27615 {
27616 PyThreadState* __tstate = wxPyBeginAllowThreads();
27617 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27618
27619 wxPyEndAllowThreads(__tstate);
27620 if (PyErr_Occurred()) SWIG_fail;
27621 }
27622 resultobj = result;
27623 return resultobj;
27624 fail:
27625 return NULL;
27626 }
27627
27628
27629 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27630 PyObject *resultobj;
27631 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27632 PyObject *arg2 = (PyObject *) 0 ;
27633 bool result;
27634 PyObject * obj0 = 0 ;
27635 PyObject * obj1 = 0 ;
27636 char *kwnames[] = {
27637 (char *) "self",(char *) "data", NULL
27638 };
27639
27640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27642 if (SWIG_arg_fail(1)) SWIG_fail;
27643 arg2 = obj1;
27644 {
27645 PyThreadState* __tstate = wxPyBeginAllowThreads();
27646 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27647
27648 wxPyEndAllowThreads(__tstate);
27649 if (PyErr_Occurred()) SWIG_fail;
27650 }
27651 {
27652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27653 }
27654 return resultobj;
27655 fail:
27656 return NULL;
27657 }
27658
27659
27660 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27661 PyObject *obj;
27662 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27663 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27664 Py_INCREF(obj);
27665 return Py_BuildValue((char *)"");
27666 }
27667 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27668 PyObject *resultobj;
27669 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27670 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27671 wxPyDataObjectSimple *result;
27672 PyObject * obj0 = 0 ;
27673 char *kwnames[] = {
27674 (char *) "format", NULL
27675 };
27676
27677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27678 if (obj0) {
27679 {
27680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27681 if (SWIG_arg_fail(1)) SWIG_fail;
27682 if (arg1 == NULL) {
27683 SWIG_null_ref("wxDataFormat");
27684 }
27685 if (SWIG_arg_fail(1)) SWIG_fail;
27686 }
27687 }
27688 {
27689 PyThreadState* __tstate = wxPyBeginAllowThreads();
27690 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27691
27692 wxPyEndAllowThreads(__tstate);
27693 if (PyErr_Occurred()) SWIG_fail;
27694 }
27695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27696 return resultobj;
27697 fail:
27698 return NULL;
27699 }
27700
27701
27702 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27703 PyObject *resultobj;
27704 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27705 PyObject *arg2 = (PyObject *) 0 ;
27706 PyObject *arg3 = (PyObject *) 0 ;
27707 PyObject * obj0 = 0 ;
27708 PyObject * obj1 = 0 ;
27709 PyObject * obj2 = 0 ;
27710 char *kwnames[] = {
27711 (char *) "self",(char *) "self",(char *) "_class", NULL
27712 };
27713
27714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27716 if (SWIG_arg_fail(1)) SWIG_fail;
27717 arg2 = obj1;
27718 arg3 = obj2;
27719 {
27720 PyThreadState* __tstate = wxPyBeginAllowThreads();
27721 (arg1)->_setCallbackInfo(arg2,arg3);
27722
27723 wxPyEndAllowThreads(__tstate);
27724 if (PyErr_Occurred()) SWIG_fail;
27725 }
27726 Py_INCREF(Py_None); resultobj = Py_None;
27727 return resultobj;
27728 fail:
27729 return NULL;
27730 }
27731
27732
27733 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27734 PyObject *obj;
27735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27736 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27737 Py_INCREF(obj);
27738 return Py_BuildValue((char *)"");
27739 }
27740 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27741 PyObject *resultobj;
27742 wxDataObjectComposite *result;
27743 char *kwnames[] = {
27744 NULL
27745 };
27746
27747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27748 {
27749 PyThreadState* __tstate = wxPyBeginAllowThreads();
27750 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27751
27752 wxPyEndAllowThreads(__tstate);
27753 if (PyErr_Occurred()) SWIG_fail;
27754 }
27755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27756 return resultobj;
27757 fail:
27758 return NULL;
27759 }
27760
27761
27762 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27763 PyObject *resultobj;
27764 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27765 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27766 bool arg3 = (bool) false ;
27767 PyObject * obj0 = 0 ;
27768 PyObject * obj1 = 0 ;
27769 PyObject * obj2 = 0 ;
27770 char *kwnames[] = {
27771 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27772 };
27773
27774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27776 if (SWIG_arg_fail(1)) SWIG_fail;
27777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27778 if (SWIG_arg_fail(2)) SWIG_fail;
27779 if (obj2) {
27780 {
27781 arg3 = (bool)(SWIG_As_bool(obj2));
27782 if (SWIG_arg_fail(3)) SWIG_fail;
27783 }
27784 }
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 (arg1)->Add(arg2,arg3);
27788
27789 wxPyEndAllowThreads(__tstate);
27790 if (PyErr_Occurred()) SWIG_fail;
27791 }
27792 Py_INCREF(Py_None); resultobj = Py_None;
27793 return resultobj;
27794 fail:
27795 return NULL;
27796 }
27797
27798
27799 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27800 PyObject *obj;
27801 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27802 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27803 Py_INCREF(obj);
27804 return Py_BuildValue((char *)"");
27805 }
27806 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27807 PyObject *resultobj;
27808 wxString const &arg1_defvalue = wxPyEmptyString ;
27809 wxString *arg1 = (wxString *) &arg1_defvalue ;
27810 wxTextDataObject *result;
27811 bool temp1 = false ;
27812 PyObject * obj0 = 0 ;
27813 char *kwnames[] = {
27814 (char *) "text", NULL
27815 };
27816
27817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27818 if (obj0) {
27819 {
27820 arg1 = wxString_in_helper(obj0);
27821 if (arg1 == NULL) SWIG_fail;
27822 temp1 = true;
27823 }
27824 }
27825 {
27826 PyThreadState* __tstate = wxPyBeginAllowThreads();
27827 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27828
27829 wxPyEndAllowThreads(__tstate);
27830 if (PyErr_Occurred()) SWIG_fail;
27831 }
27832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27833 {
27834 if (temp1)
27835 delete arg1;
27836 }
27837 return resultobj;
27838 fail:
27839 {
27840 if (temp1)
27841 delete arg1;
27842 }
27843 return NULL;
27844 }
27845
27846
27847 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27848 PyObject *resultobj;
27849 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27850 size_t result;
27851 PyObject * obj0 = 0 ;
27852 char *kwnames[] = {
27853 (char *) "self", NULL
27854 };
27855
27856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27858 if (SWIG_arg_fail(1)) SWIG_fail;
27859 {
27860 PyThreadState* __tstate = wxPyBeginAllowThreads();
27861 result = (size_t)(arg1)->GetTextLength();
27862
27863 wxPyEndAllowThreads(__tstate);
27864 if (PyErr_Occurred()) SWIG_fail;
27865 }
27866 {
27867 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27868 }
27869 return resultobj;
27870 fail:
27871 return NULL;
27872 }
27873
27874
27875 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27876 PyObject *resultobj;
27877 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27878 wxString result;
27879 PyObject * obj0 = 0 ;
27880 char *kwnames[] = {
27881 (char *) "self", NULL
27882 };
27883
27884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27886 if (SWIG_arg_fail(1)) SWIG_fail;
27887 {
27888 PyThreadState* __tstate = wxPyBeginAllowThreads();
27889 result = (arg1)->GetText();
27890
27891 wxPyEndAllowThreads(__tstate);
27892 if (PyErr_Occurred()) SWIG_fail;
27893 }
27894 {
27895 #if wxUSE_UNICODE
27896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27897 #else
27898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27899 #endif
27900 }
27901 return resultobj;
27902 fail:
27903 return NULL;
27904 }
27905
27906
27907 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27908 PyObject *resultobj;
27909 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27910 wxString *arg2 = 0 ;
27911 bool temp2 = false ;
27912 PyObject * obj0 = 0 ;
27913 PyObject * obj1 = 0 ;
27914 char *kwnames[] = {
27915 (char *) "self",(char *) "text", NULL
27916 };
27917
27918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27920 if (SWIG_arg_fail(1)) SWIG_fail;
27921 {
27922 arg2 = wxString_in_helper(obj1);
27923 if (arg2 == NULL) SWIG_fail;
27924 temp2 = true;
27925 }
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 (arg1)->SetText((wxString const &)*arg2);
27929
27930 wxPyEndAllowThreads(__tstate);
27931 if (PyErr_Occurred()) SWIG_fail;
27932 }
27933 Py_INCREF(Py_None); resultobj = Py_None;
27934 {
27935 if (temp2)
27936 delete arg2;
27937 }
27938 return resultobj;
27939 fail:
27940 {
27941 if (temp2)
27942 delete arg2;
27943 }
27944 return NULL;
27945 }
27946
27947
27948 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27949 PyObject *obj;
27950 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27951 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27952 Py_INCREF(obj);
27953 return Py_BuildValue((char *)"");
27954 }
27955 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27956 PyObject *resultobj;
27957 wxString const &arg1_defvalue = wxPyEmptyString ;
27958 wxString *arg1 = (wxString *) &arg1_defvalue ;
27959 wxPyTextDataObject *result;
27960 bool temp1 = false ;
27961 PyObject * obj0 = 0 ;
27962 char *kwnames[] = {
27963 (char *) "text", NULL
27964 };
27965
27966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27967 if (obj0) {
27968 {
27969 arg1 = wxString_in_helper(obj0);
27970 if (arg1 == NULL) SWIG_fail;
27971 temp1 = true;
27972 }
27973 }
27974 {
27975 PyThreadState* __tstate = wxPyBeginAllowThreads();
27976 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27977
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27982 {
27983 if (temp1)
27984 delete arg1;
27985 }
27986 return resultobj;
27987 fail:
27988 {
27989 if (temp1)
27990 delete arg1;
27991 }
27992 return NULL;
27993 }
27994
27995
27996 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27997 PyObject *resultobj;
27998 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27999 PyObject *arg2 = (PyObject *) 0 ;
28000 PyObject *arg3 = (PyObject *) 0 ;
28001 PyObject * obj0 = 0 ;
28002 PyObject * obj1 = 0 ;
28003 PyObject * obj2 = 0 ;
28004 char *kwnames[] = {
28005 (char *) "self",(char *) "self",(char *) "_class", NULL
28006 };
28007
28008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28010 if (SWIG_arg_fail(1)) SWIG_fail;
28011 arg2 = obj1;
28012 arg3 = obj2;
28013 {
28014 PyThreadState* __tstate = wxPyBeginAllowThreads();
28015 (arg1)->_setCallbackInfo(arg2,arg3);
28016
28017 wxPyEndAllowThreads(__tstate);
28018 if (PyErr_Occurred()) SWIG_fail;
28019 }
28020 Py_INCREF(Py_None); resultobj = Py_None;
28021 return resultobj;
28022 fail:
28023 return NULL;
28024 }
28025
28026
28027 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
28028 PyObject *obj;
28029 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28030 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
28031 Py_INCREF(obj);
28032 return Py_BuildValue((char *)"");
28033 }
28034 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28035 PyObject *resultobj;
28036 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28037 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28038 wxBitmapDataObject *result;
28039 PyObject * obj0 = 0 ;
28040 char *kwnames[] = {
28041 (char *) "bitmap", NULL
28042 };
28043
28044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
28045 if (obj0) {
28046 {
28047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28048 if (SWIG_arg_fail(1)) SWIG_fail;
28049 if (arg1 == NULL) {
28050 SWIG_null_ref("wxBitmap");
28051 }
28052 if (SWIG_arg_fail(1)) SWIG_fail;
28053 }
28054 }
28055 {
28056 PyThreadState* __tstate = wxPyBeginAllowThreads();
28057 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
28058
28059 wxPyEndAllowThreads(__tstate);
28060 if (PyErr_Occurred()) SWIG_fail;
28061 }
28062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
28063 return resultobj;
28064 fail:
28065 return NULL;
28066 }
28067
28068
28069 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28070 PyObject *resultobj;
28071 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28072 wxBitmap result;
28073 PyObject * obj0 = 0 ;
28074 char *kwnames[] = {
28075 (char *) "self", NULL
28076 };
28077
28078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
28079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28080 if (SWIG_arg_fail(1)) SWIG_fail;
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
28084
28085 wxPyEndAllowThreads(__tstate);
28086 if (PyErr_Occurred()) SWIG_fail;
28087 }
28088 {
28089 wxBitmap * resultptr;
28090 resultptr = new wxBitmap((wxBitmap &)(result));
28091 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
28092 }
28093 return resultobj;
28094 fail:
28095 return NULL;
28096 }
28097
28098
28099 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28100 PyObject *resultobj;
28101 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28102 wxBitmap *arg2 = 0 ;
28103 PyObject * obj0 = 0 ;
28104 PyObject * obj1 = 0 ;
28105 char *kwnames[] = {
28106 (char *) "self",(char *) "bitmap", NULL
28107 };
28108
28109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
28110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28111 if (SWIG_arg_fail(1)) SWIG_fail;
28112 {
28113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28114 if (SWIG_arg_fail(2)) SWIG_fail;
28115 if (arg2 == NULL) {
28116 SWIG_null_ref("wxBitmap");
28117 }
28118 if (SWIG_arg_fail(2)) SWIG_fail;
28119 }
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28123
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 Py_INCREF(Py_None); resultobj = Py_None;
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28135 PyObject *obj;
28136 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28137 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28138 Py_INCREF(obj);
28139 return Py_BuildValue((char *)"");
28140 }
28141 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28142 PyObject *resultobj;
28143 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28144 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28145 wxPyBitmapDataObject *result;
28146 PyObject * obj0 = 0 ;
28147 char *kwnames[] = {
28148 (char *) "bitmap", NULL
28149 };
28150
28151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28152 if (obj0) {
28153 {
28154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28155 if (SWIG_arg_fail(1)) SWIG_fail;
28156 if (arg1 == NULL) {
28157 SWIG_null_ref("wxBitmap");
28158 }
28159 if (SWIG_arg_fail(1)) SWIG_fail;
28160 }
28161 }
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj;
28178 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28179 PyObject *arg2 = (PyObject *) 0 ;
28180 PyObject *arg3 = (PyObject *) 0 ;
28181 PyObject * obj0 = 0 ;
28182 PyObject * obj1 = 0 ;
28183 PyObject * obj2 = 0 ;
28184 char *kwnames[] = {
28185 (char *) "self",(char *) "self",(char *) "_class", NULL
28186 };
28187
28188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28190 if (SWIG_arg_fail(1)) SWIG_fail;
28191 arg2 = obj1;
28192 arg3 = obj2;
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 (arg1)->_setCallbackInfo(arg2,arg3);
28196
28197 wxPyEndAllowThreads(__tstate);
28198 if (PyErr_Occurred()) SWIG_fail;
28199 }
28200 Py_INCREF(Py_None); resultobj = Py_None;
28201 return resultobj;
28202 fail:
28203 return NULL;
28204 }
28205
28206
28207 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28208 PyObject *obj;
28209 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28210 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28211 Py_INCREF(obj);
28212 return Py_BuildValue((char *)"");
28213 }
28214 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28215 PyObject *resultobj;
28216 wxFileDataObject *result;
28217 char *kwnames[] = {
28218 NULL
28219 };
28220
28221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 result = (wxFileDataObject *)new wxFileDataObject();
28225
28226 wxPyEndAllowThreads(__tstate);
28227 if (PyErr_Occurred()) SWIG_fail;
28228 }
28229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28230 return resultobj;
28231 fail:
28232 return NULL;
28233 }
28234
28235
28236 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28237 PyObject *resultobj;
28238 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28239 wxArrayString *result;
28240 PyObject * obj0 = 0 ;
28241 char *kwnames[] = {
28242 (char *) "self", NULL
28243 };
28244
28245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28247 if (SWIG_arg_fail(1)) SWIG_fail;
28248 {
28249 PyThreadState* __tstate = wxPyBeginAllowThreads();
28250 {
28251 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28252 result = (wxArrayString *) &_result_ref;
28253 }
28254
28255 wxPyEndAllowThreads(__tstate);
28256 if (PyErr_Occurred()) SWIG_fail;
28257 }
28258 {
28259 resultobj = wxArrayString2PyList_helper(*result);
28260 }
28261 return resultobj;
28262 fail:
28263 return NULL;
28264 }
28265
28266
28267 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28268 PyObject *resultobj;
28269 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28270 wxString *arg2 = 0 ;
28271 bool temp2 = false ;
28272 PyObject * obj0 = 0 ;
28273 PyObject * obj1 = 0 ;
28274 char *kwnames[] = {
28275 (char *) "self",(char *) "filename", NULL
28276 };
28277
28278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28280 if (SWIG_arg_fail(1)) SWIG_fail;
28281 {
28282 arg2 = wxString_in_helper(obj1);
28283 if (arg2 == NULL) SWIG_fail;
28284 temp2 = true;
28285 }
28286 {
28287 PyThreadState* __tstate = wxPyBeginAllowThreads();
28288 (arg1)->AddFile((wxString const &)*arg2);
28289
28290 wxPyEndAllowThreads(__tstate);
28291 if (PyErr_Occurred()) SWIG_fail;
28292 }
28293 Py_INCREF(Py_None); resultobj = Py_None;
28294 {
28295 if (temp2)
28296 delete arg2;
28297 }
28298 return resultobj;
28299 fail:
28300 {
28301 if (temp2)
28302 delete arg2;
28303 }
28304 return NULL;
28305 }
28306
28307
28308 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28309 PyObject *obj;
28310 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28311 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28312 Py_INCREF(obj);
28313 return Py_BuildValue((char *)"");
28314 }
28315 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28316 PyObject *resultobj;
28317 wxDataFormat *arg1 = 0 ;
28318 wxCustomDataObject *result;
28319 PyObject * obj0 = 0 ;
28320
28321 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28322 {
28323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28324 if (SWIG_arg_fail(1)) SWIG_fail;
28325 if (arg1 == NULL) {
28326 SWIG_null_ref("wxDataFormat");
28327 }
28328 if (SWIG_arg_fail(1)) SWIG_fail;
28329 }
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28333
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28345 PyObject *resultobj;
28346 wxString *arg1 = 0 ;
28347 wxCustomDataObject *result;
28348 bool temp1 = false ;
28349 PyObject * obj0 = 0 ;
28350
28351 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28352 {
28353 arg1 = wxString_in_helper(obj0);
28354 if (arg1 == NULL) SWIG_fail;
28355 temp1 = true;
28356 }
28357 {
28358 PyThreadState* __tstate = wxPyBeginAllowThreads();
28359 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28360
28361 wxPyEndAllowThreads(__tstate);
28362 if (PyErr_Occurred()) SWIG_fail;
28363 }
28364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28365 {
28366 if (temp1)
28367 delete arg1;
28368 }
28369 return resultobj;
28370 fail:
28371 {
28372 if (temp1)
28373 delete arg1;
28374 }
28375 return NULL;
28376 }
28377
28378
28379 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28380 PyObject *resultobj;
28381 wxCustomDataObject *result;
28382
28383 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28384 {
28385 PyThreadState* __tstate = wxPyBeginAllowThreads();
28386 result = (wxCustomDataObject *)new wxCustomDataObject();
28387
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28399 int argc;
28400 PyObject *argv[2];
28401 int ii;
28402
28403 argc = PyObject_Length(args);
28404 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28405 argv[ii] = PyTuple_GetItem(args,ii);
28406 }
28407 if (argc == 0) {
28408 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28409 }
28410 if (argc == 1) {
28411 int _v;
28412 {
28413 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28414 }
28415 if (_v) {
28416 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28417 }
28418 }
28419 if (argc == 1) {
28420 int _v;
28421 {
28422 void *ptr = 0;
28423 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28424 _v = 0;
28425 PyErr_Clear();
28426 } else {
28427 _v = (ptr != 0);
28428 }
28429 }
28430 if (_v) {
28431 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28432 }
28433 }
28434
28435 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28436 return NULL;
28437 }
28438
28439
28440 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28441 PyObject *resultobj;
28442 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28443 PyObject *arg2 = (PyObject *) 0 ;
28444 bool result;
28445 PyObject * obj0 = 0 ;
28446 PyObject * obj1 = 0 ;
28447 char *kwnames[] = {
28448 (char *) "self",(char *) "data", NULL
28449 };
28450
28451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28453 if (SWIG_arg_fail(1)) SWIG_fail;
28454 arg2 = obj1;
28455 {
28456 PyThreadState* __tstate = wxPyBeginAllowThreads();
28457 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28458
28459 wxPyEndAllowThreads(__tstate);
28460 if (PyErr_Occurred()) SWIG_fail;
28461 }
28462 {
28463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28464 }
28465 return resultobj;
28466 fail:
28467 return NULL;
28468 }
28469
28470
28471 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28472 PyObject *resultobj;
28473 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28474 size_t result;
28475 PyObject * obj0 = 0 ;
28476 char *kwnames[] = {
28477 (char *) "self", NULL
28478 };
28479
28480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28482 if (SWIG_arg_fail(1)) SWIG_fail;
28483 {
28484 PyThreadState* __tstate = wxPyBeginAllowThreads();
28485 result = (size_t)(arg1)->GetSize();
28486
28487 wxPyEndAllowThreads(__tstate);
28488 if (PyErr_Occurred()) SWIG_fail;
28489 }
28490 {
28491 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28492 }
28493 return resultobj;
28494 fail:
28495 return NULL;
28496 }
28497
28498
28499 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28500 PyObject *resultobj;
28501 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28502 PyObject *result;
28503 PyObject * obj0 = 0 ;
28504 char *kwnames[] = {
28505 (char *) "self", NULL
28506 };
28507
28508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28510 if (SWIG_arg_fail(1)) SWIG_fail;
28511 {
28512 PyThreadState* __tstate = wxPyBeginAllowThreads();
28513 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28514
28515 wxPyEndAllowThreads(__tstate);
28516 if (PyErr_Occurred()) SWIG_fail;
28517 }
28518 resultobj = result;
28519 return resultobj;
28520 fail:
28521 return NULL;
28522 }
28523
28524
28525 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28526 PyObject *obj;
28527 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28528 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28529 Py_INCREF(obj);
28530 return Py_BuildValue((char *)"");
28531 }
28532 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28533 PyObject *resultobj;
28534 wxURLDataObject *result;
28535 char *kwnames[] = {
28536 NULL
28537 };
28538
28539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28540 {
28541 PyThreadState* __tstate = wxPyBeginAllowThreads();
28542 result = (wxURLDataObject *)new wxURLDataObject();
28543
28544 wxPyEndAllowThreads(__tstate);
28545 if (PyErr_Occurred()) SWIG_fail;
28546 }
28547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28548 return resultobj;
28549 fail:
28550 return NULL;
28551 }
28552
28553
28554 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28555 PyObject *resultobj;
28556 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28557 wxString result;
28558 PyObject * obj0 = 0 ;
28559 char *kwnames[] = {
28560 (char *) "self", NULL
28561 };
28562
28563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28565 if (SWIG_arg_fail(1)) SWIG_fail;
28566 {
28567 PyThreadState* __tstate = wxPyBeginAllowThreads();
28568 result = (arg1)->GetURL();
28569
28570 wxPyEndAllowThreads(__tstate);
28571 if (PyErr_Occurred()) SWIG_fail;
28572 }
28573 {
28574 #if wxUSE_UNICODE
28575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28576 #else
28577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28578 #endif
28579 }
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj;
28588 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28589 wxString *arg2 = 0 ;
28590 bool temp2 = false ;
28591 PyObject * obj0 = 0 ;
28592 PyObject * obj1 = 0 ;
28593 char *kwnames[] = {
28594 (char *) "self",(char *) "url", NULL
28595 };
28596
28597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28599 if (SWIG_arg_fail(1)) SWIG_fail;
28600 {
28601 arg2 = wxString_in_helper(obj1);
28602 if (arg2 == NULL) SWIG_fail;
28603 temp2 = true;
28604 }
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 (arg1)->SetURL((wxString const &)*arg2);
28608
28609 wxPyEndAllowThreads(__tstate);
28610 if (PyErr_Occurred()) SWIG_fail;
28611 }
28612 Py_INCREF(Py_None); resultobj = Py_None;
28613 {
28614 if (temp2)
28615 delete arg2;
28616 }
28617 return resultobj;
28618 fail:
28619 {
28620 if (temp2)
28621 delete arg2;
28622 }
28623 return NULL;
28624 }
28625
28626
28627 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28628 PyObject *obj;
28629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28630 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28631 Py_INCREF(obj);
28632 return Py_BuildValue((char *)"");
28633 }
28634 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28635 PyObject *resultobj;
28636 wxMetafileDataObject *result;
28637 char *kwnames[] = {
28638 NULL
28639 };
28640
28641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28642 {
28643 PyThreadState* __tstate = wxPyBeginAllowThreads();
28644 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28645
28646 wxPyEndAllowThreads(__tstate);
28647 if (PyErr_Occurred()) SWIG_fail;
28648 }
28649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28650 return resultobj;
28651 fail:
28652 return NULL;
28653 }
28654
28655
28656 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28657 PyObject *resultobj;
28658 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28659 wxMetafile *arg2 = 0 ;
28660 PyObject * obj0 = 0 ;
28661 PyObject * obj1 = 0 ;
28662 char *kwnames[] = {
28663 (char *) "self",(char *) "metafile", NULL
28664 };
28665
28666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28668 if (SWIG_arg_fail(1)) SWIG_fail;
28669 {
28670 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28671 if (SWIG_arg_fail(2)) SWIG_fail;
28672 if (arg2 == NULL) {
28673 SWIG_null_ref("wxMetafile");
28674 }
28675 if (SWIG_arg_fail(2)) SWIG_fail;
28676 }
28677 {
28678 PyThreadState* __tstate = wxPyBeginAllowThreads();
28679 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28680
28681 wxPyEndAllowThreads(__tstate);
28682 if (PyErr_Occurred()) SWIG_fail;
28683 }
28684 Py_INCREF(Py_None); resultobj = Py_None;
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28692 PyObject *resultobj;
28693 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28694 wxMetafile result;
28695 PyObject * obj0 = 0 ;
28696 char *kwnames[] = {
28697 (char *) "self", NULL
28698 };
28699
28700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28702 if (SWIG_arg_fail(1)) SWIG_fail;
28703 {
28704 PyThreadState* __tstate = wxPyBeginAllowThreads();
28705 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28706
28707 wxPyEndAllowThreads(__tstate);
28708 if (PyErr_Occurred()) SWIG_fail;
28709 }
28710 {
28711 wxMetafile * resultptr;
28712 resultptr = new wxMetafile((wxMetafile &)(result));
28713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28714 }
28715 return resultobj;
28716 fail:
28717 return NULL;
28718 }
28719
28720
28721 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28722 PyObject *obj;
28723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28724 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28725 Py_INCREF(obj);
28726 return Py_BuildValue((char *)"");
28727 }
28728 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28729 PyObject *resultobj;
28730 wxDragResult arg1 ;
28731 bool result;
28732 PyObject * obj0 = 0 ;
28733 char *kwnames[] = {
28734 (char *) "res", NULL
28735 };
28736
28737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28738 {
28739 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28740 if (SWIG_arg_fail(1)) SWIG_fail;
28741 }
28742 {
28743 PyThreadState* __tstate = wxPyBeginAllowThreads();
28744 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28745
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 {
28750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28751 }
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28759 PyObject *resultobj;
28760 wxWindow *arg1 = (wxWindow *) 0 ;
28761 wxCursor const &arg2_defvalue = wxNullCursor ;
28762 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28763 wxCursor const &arg3_defvalue = wxNullCursor ;
28764 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28765 wxCursor const &arg4_defvalue = wxNullCursor ;
28766 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28767 wxPyDropSource *result;
28768 PyObject * obj0 = 0 ;
28769 PyObject * obj1 = 0 ;
28770 PyObject * obj2 = 0 ;
28771 PyObject * obj3 = 0 ;
28772 char *kwnames[] = {
28773 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28774 };
28775
28776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28778 if (SWIG_arg_fail(1)) SWIG_fail;
28779 if (obj1) {
28780 {
28781 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28782 if (SWIG_arg_fail(2)) SWIG_fail;
28783 if (arg2 == NULL) {
28784 SWIG_null_ref("wxCursor");
28785 }
28786 if (SWIG_arg_fail(2)) SWIG_fail;
28787 }
28788 }
28789 if (obj2) {
28790 {
28791 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28792 if (SWIG_arg_fail(3)) SWIG_fail;
28793 if (arg3 == NULL) {
28794 SWIG_null_ref("wxCursor");
28795 }
28796 if (SWIG_arg_fail(3)) SWIG_fail;
28797 }
28798 }
28799 if (obj3) {
28800 {
28801 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28802 if (SWIG_arg_fail(4)) SWIG_fail;
28803 if (arg4 == NULL) {
28804 SWIG_null_ref("wxCursor");
28805 }
28806 if (SWIG_arg_fail(4)) SWIG_fail;
28807 }
28808 }
28809 {
28810 PyThreadState* __tstate = wxPyBeginAllowThreads();
28811 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28812
28813 wxPyEndAllowThreads(__tstate);
28814 if (PyErr_Occurred()) SWIG_fail;
28815 }
28816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28817 return resultobj;
28818 fail:
28819 return NULL;
28820 }
28821
28822
28823 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28824 PyObject *resultobj;
28825 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28826 PyObject *arg2 = (PyObject *) 0 ;
28827 PyObject *arg3 = (PyObject *) 0 ;
28828 int arg4 ;
28829 PyObject * obj0 = 0 ;
28830 PyObject * obj1 = 0 ;
28831 PyObject * obj2 = 0 ;
28832 PyObject * obj3 = 0 ;
28833 char *kwnames[] = {
28834 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28835 };
28836
28837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28839 if (SWIG_arg_fail(1)) SWIG_fail;
28840 arg2 = obj1;
28841 arg3 = obj2;
28842 {
28843 arg4 = (int)(SWIG_As_int(obj3));
28844 if (SWIG_arg_fail(4)) SWIG_fail;
28845 }
28846 {
28847 PyThreadState* __tstate = wxPyBeginAllowThreads();
28848 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28849
28850 wxPyEndAllowThreads(__tstate);
28851 if (PyErr_Occurred()) SWIG_fail;
28852 }
28853 Py_INCREF(Py_None); resultobj = Py_None;
28854 return resultobj;
28855 fail:
28856 return NULL;
28857 }
28858
28859
28860 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28861 PyObject *resultobj;
28862 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28863 PyObject * obj0 = 0 ;
28864 char *kwnames[] = {
28865 (char *) "self", NULL
28866 };
28867
28868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28870 if (SWIG_arg_fail(1)) SWIG_fail;
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 delete arg1;
28874
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 Py_INCREF(Py_None); resultobj = Py_None;
28879 return resultobj;
28880 fail:
28881 return NULL;
28882 }
28883
28884
28885 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28886 PyObject *resultobj;
28887 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28888 wxDataObject *arg2 = 0 ;
28889 PyObject * obj0 = 0 ;
28890 PyObject * obj1 = 0 ;
28891 char *kwnames[] = {
28892 (char *) "self",(char *) "data", NULL
28893 };
28894
28895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28897 if (SWIG_arg_fail(1)) SWIG_fail;
28898 {
28899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28900 if (SWIG_arg_fail(2)) SWIG_fail;
28901 if (arg2 == NULL) {
28902 SWIG_null_ref("wxDataObject");
28903 }
28904 if (SWIG_arg_fail(2)) SWIG_fail;
28905 }
28906 {
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 (arg1)->SetData(*arg2);
28909
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 Py_INCREF(Py_None); resultobj = Py_None;
28914 return resultobj;
28915 fail:
28916 return NULL;
28917 }
28918
28919
28920 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28921 PyObject *resultobj;
28922 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28923 wxDataObject *result;
28924 PyObject * obj0 = 0 ;
28925 char *kwnames[] = {
28926 (char *) "self", NULL
28927 };
28928
28929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28931 if (SWIG_arg_fail(1)) SWIG_fail;
28932 {
28933 PyThreadState* __tstate = wxPyBeginAllowThreads();
28934 result = (wxDataObject *)(arg1)->GetDataObject();
28935
28936 wxPyEndAllowThreads(__tstate);
28937 if (PyErr_Occurred()) SWIG_fail;
28938 }
28939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28940 return resultobj;
28941 fail:
28942 return NULL;
28943 }
28944
28945
28946 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28947 PyObject *resultobj;
28948 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28949 wxDragResult arg2 ;
28950 wxCursor *arg3 = 0 ;
28951 PyObject * obj0 = 0 ;
28952 PyObject * obj1 = 0 ;
28953 PyObject * obj2 = 0 ;
28954 char *kwnames[] = {
28955 (char *) "self",(char *) "res",(char *) "cursor", NULL
28956 };
28957
28958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28960 if (SWIG_arg_fail(1)) SWIG_fail;
28961 {
28962 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28963 if (SWIG_arg_fail(2)) SWIG_fail;
28964 }
28965 {
28966 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28967 if (SWIG_arg_fail(3)) SWIG_fail;
28968 if (arg3 == NULL) {
28969 SWIG_null_ref("wxCursor");
28970 }
28971 if (SWIG_arg_fail(3)) SWIG_fail;
28972 }
28973 {
28974 PyThreadState* __tstate = wxPyBeginAllowThreads();
28975 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28976
28977 wxPyEndAllowThreads(__tstate);
28978 if (PyErr_Occurred()) SWIG_fail;
28979 }
28980 Py_INCREF(Py_None); resultobj = Py_None;
28981 return resultobj;
28982 fail:
28983 return NULL;
28984 }
28985
28986
28987 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28988 PyObject *resultobj;
28989 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28990 int arg2 = (int) wxDrag_CopyOnly ;
28991 wxDragResult result;
28992 PyObject * obj0 = 0 ;
28993 PyObject * obj1 = 0 ;
28994 char *kwnames[] = {
28995 (char *) "self",(char *) "flags", NULL
28996 };
28997
28998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29000 if (SWIG_arg_fail(1)) SWIG_fail;
29001 if (obj1) {
29002 {
29003 arg2 = (int)(SWIG_As_int(obj1));
29004 if (SWIG_arg_fail(2)) SWIG_fail;
29005 }
29006 }
29007 {
29008 PyThreadState* __tstate = wxPyBeginAllowThreads();
29009 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
29010
29011 wxPyEndAllowThreads(__tstate);
29012 if (PyErr_Occurred()) SWIG_fail;
29013 }
29014 resultobj = SWIG_From_int((result));
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
29022 PyObject *resultobj;
29023 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29024 wxDragResult arg2 ;
29025 bool result;
29026 PyObject * obj0 = 0 ;
29027 PyObject * obj1 = 0 ;
29028 char *kwnames[] = {
29029 (char *) "self",(char *) "effect", NULL
29030 };
29031
29032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
29033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29034 if (SWIG_arg_fail(1)) SWIG_fail;
29035 {
29036 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29037 if (SWIG_arg_fail(2)) SWIG_fail;
29038 }
29039 {
29040 PyThreadState* __tstate = wxPyBeginAllowThreads();
29041 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
29042
29043 wxPyEndAllowThreads(__tstate);
29044 if (PyErr_Occurred()) SWIG_fail;
29045 }
29046 {
29047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29048 }
29049 return resultobj;
29050 fail:
29051 return NULL;
29052 }
29053
29054
29055 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
29056 PyObject *obj;
29057 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29058 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
29059 Py_INCREF(obj);
29060 return Py_BuildValue((char *)"");
29061 }
29062 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29063 PyObject *resultobj;
29064 wxDataObject *arg1 = (wxDataObject *) NULL ;
29065 wxPyDropTarget *result;
29066 PyObject * obj0 = 0 ;
29067 char *kwnames[] = {
29068 (char *) "dataObject", NULL
29069 };
29070
29071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
29072 if (obj0) {
29073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29074 if (SWIG_arg_fail(1)) SWIG_fail;
29075 }
29076 {
29077 PyThreadState* __tstate = wxPyBeginAllowThreads();
29078 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
29079
29080 wxPyEndAllowThreads(__tstate);
29081 if (PyErr_Occurred()) SWIG_fail;
29082 }
29083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
29084 return resultobj;
29085 fail:
29086 return NULL;
29087 }
29088
29089
29090 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29091 PyObject *resultobj;
29092 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29093 PyObject *arg2 = (PyObject *) 0 ;
29094 PyObject *arg3 = (PyObject *) 0 ;
29095 PyObject * obj0 = 0 ;
29096 PyObject * obj1 = 0 ;
29097 PyObject * obj2 = 0 ;
29098 char *kwnames[] = {
29099 (char *) "self",(char *) "self",(char *) "_class", NULL
29100 };
29101
29102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29104 if (SWIG_arg_fail(1)) SWIG_fail;
29105 arg2 = obj1;
29106 arg3 = obj2;
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 (arg1)->_setCallbackInfo(arg2,arg3);
29110
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 Py_INCREF(Py_None); resultobj = Py_None;
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29122 PyObject *resultobj;
29123 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29124 PyObject * obj0 = 0 ;
29125 char *kwnames[] = {
29126 (char *) "self", NULL
29127 };
29128
29129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
29130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29131 if (SWIG_arg_fail(1)) SWIG_fail;
29132 {
29133 PyThreadState* __tstate = wxPyBeginAllowThreads();
29134 delete arg1;
29135
29136 wxPyEndAllowThreads(__tstate);
29137 if (PyErr_Occurred()) SWIG_fail;
29138 }
29139 Py_INCREF(Py_None); resultobj = Py_None;
29140 return resultobj;
29141 fail:
29142 return NULL;
29143 }
29144
29145
29146 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29147 PyObject *resultobj;
29148 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29149 wxDataObject *result;
29150 PyObject * obj0 = 0 ;
29151 char *kwnames[] = {
29152 (char *) "self", NULL
29153 };
29154
29155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29157 if (SWIG_arg_fail(1)) SWIG_fail;
29158 {
29159 PyThreadState* __tstate = wxPyBeginAllowThreads();
29160 result = (wxDataObject *)(arg1)->GetDataObject();
29161
29162 wxPyEndAllowThreads(__tstate);
29163 if (PyErr_Occurred()) SWIG_fail;
29164 }
29165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29166 return resultobj;
29167 fail:
29168 return NULL;
29169 }
29170
29171
29172 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29173 PyObject *resultobj;
29174 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29175 wxDataObject *arg2 = (wxDataObject *) 0 ;
29176 PyObject * obj0 = 0 ;
29177 PyObject * obj1 = 0 ;
29178 char *kwnames[] = {
29179 (char *) "self",(char *) "dataObject", NULL
29180 };
29181
29182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29184 if (SWIG_arg_fail(1)) SWIG_fail;
29185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29186 if (SWIG_arg_fail(2)) SWIG_fail;
29187 {
29188 PyThreadState* __tstate = wxPyBeginAllowThreads();
29189 (arg1)->SetDataObject(arg2);
29190
29191 wxPyEndAllowThreads(__tstate);
29192 if (PyErr_Occurred()) SWIG_fail;
29193 }
29194 Py_INCREF(Py_None); resultobj = Py_None;
29195 return resultobj;
29196 fail:
29197 return NULL;
29198 }
29199
29200
29201 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29202 PyObject *resultobj;
29203 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29204 int arg2 ;
29205 int arg3 ;
29206 wxDragResult arg4 ;
29207 wxDragResult result;
29208 PyObject * obj0 = 0 ;
29209 PyObject * obj1 = 0 ;
29210 PyObject * obj2 = 0 ;
29211 PyObject * obj3 = 0 ;
29212 char *kwnames[] = {
29213 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29214 };
29215
29216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29229 if (SWIG_arg_fail(4)) SWIG_fail;
29230 }
29231 {
29232 PyThreadState* __tstate = wxPyBeginAllowThreads();
29233 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29234
29235 wxPyEndAllowThreads(__tstate);
29236 if (PyErr_Occurred()) SWIG_fail;
29237 }
29238 resultobj = SWIG_From_int((result));
29239 return resultobj;
29240 fail:
29241 return NULL;
29242 }
29243
29244
29245 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29246 PyObject *resultobj;
29247 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29248 int arg2 ;
29249 int arg3 ;
29250 wxDragResult arg4 ;
29251 wxDragResult result;
29252 PyObject * obj0 = 0 ;
29253 PyObject * obj1 = 0 ;
29254 PyObject * obj2 = 0 ;
29255 PyObject * obj3 = 0 ;
29256 char *kwnames[] = {
29257 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29258 };
29259
29260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29262 if (SWIG_arg_fail(1)) SWIG_fail;
29263 {
29264 arg2 = (int)(SWIG_As_int(obj1));
29265 if (SWIG_arg_fail(2)) SWIG_fail;
29266 }
29267 {
29268 arg3 = (int)(SWIG_As_int(obj2));
29269 if (SWIG_arg_fail(3)) SWIG_fail;
29270 }
29271 {
29272 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29273 if (SWIG_arg_fail(4)) SWIG_fail;
29274 }
29275 {
29276 PyThreadState* __tstate = wxPyBeginAllowThreads();
29277 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29278
29279 wxPyEndAllowThreads(__tstate);
29280 if (PyErr_Occurred()) SWIG_fail;
29281 }
29282 resultobj = SWIG_From_int((result));
29283 return resultobj;
29284 fail:
29285 return NULL;
29286 }
29287
29288
29289 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29290 PyObject *resultobj;
29291 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29292 PyObject * obj0 = 0 ;
29293 char *kwnames[] = {
29294 (char *) "self", NULL
29295 };
29296
29297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29299 if (SWIG_arg_fail(1)) SWIG_fail;
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 (arg1)->base_OnLeave();
29303
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 Py_INCREF(Py_None); resultobj = Py_None;
29308 return resultobj;
29309 fail:
29310 return NULL;
29311 }
29312
29313
29314 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29315 PyObject *resultobj;
29316 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29317 int arg2 ;
29318 int arg3 ;
29319 bool result;
29320 PyObject * obj0 = 0 ;
29321 PyObject * obj1 = 0 ;
29322 PyObject * obj2 = 0 ;
29323 char *kwnames[] = {
29324 (char *) "self",(char *) "x",(char *) "y", NULL
29325 };
29326
29327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29329 if (SWIG_arg_fail(1)) SWIG_fail;
29330 {
29331 arg2 = (int)(SWIG_As_int(obj1));
29332 if (SWIG_arg_fail(2)) SWIG_fail;
29333 }
29334 {
29335 arg3 = (int)(SWIG_As_int(obj2));
29336 if (SWIG_arg_fail(3)) SWIG_fail;
29337 }
29338 {
29339 PyThreadState* __tstate = wxPyBeginAllowThreads();
29340 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29341
29342 wxPyEndAllowThreads(__tstate);
29343 if (PyErr_Occurred()) SWIG_fail;
29344 }
29345 {
29346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29347 }
29348 return resultobj;
29349 fail:
29350 return NULL;
29351 }
29352
29353
29354 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29355 PyObject *resultobj;
29356 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29357 bool result;
29358 PyObject * obj0 = 0 ;
29359 char *kwnames[] = {
29360 (char *) "self", NULL
29361 };
29362
29363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29365 if (SWIG_arg_fail(1)) SWIG_fail;
29366 {
29367 PyThreadState* __tstate = wxPyBeginAllowThreads();
29368 result = (bool)(arg1)->GetData();
29369
29370 wxPyEndAllowThreads(__tstate);
29371 if (PyErr_Occurred()) SWIG_fail;
29372 }
29373 {
29374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29375 }
29376 return resultobj;
29377 fail:
29378 return NULL;
29379 }
29380
29381
29382 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29383 PyObject *resultobj;
29384 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29385 wxDragResult arg2 ;
29386 PyObject * obj0 = 0 ;
29387 PyObject * obj1 = 0 ;
29388 char *kwnames[] = {
29389 (char *) "self",(char *) "action", NULL
29390 };
29391
29392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29394 if (SWIG_arg_fail(1)) SWIG_fail;
29395 {
29396 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29397 if (SWIG_arg_fail(2)) SWIG_fail;
29398 }
29399 {
29400 PyThreadState* __tstate = wxPyBeginAllowThreads();
29401 (arg1)->SetDefaultAction((wxDragResult )arg2);
29402
29403 wxPyEndAllowThreads(__tstate);
29404 if (PyErr_Occurred()) SWIG_fail;
29405 }
29406 Py_INCREF(Py_None); resultobj = Py_None;
29407 return resultobj;
29408 fail:
29409 return NULL;
29410 }
29411
29412
29413 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29414 PyObject *resultobj;
29415 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29416 wxDragResult result;
29417 PyObject * obj0 = 0 ;
29418 char *kwnames[] = {
29419 (char *) "self", NULL
29420 };
29421
29422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29424 if (SWIG_arg_fail(1)) SWIG_fail;
29425 {
29426 PyThreadState* __tstate = wxPyBeginAllowThreads();
29427 result = (wxDragResult)(arg1)->GetDefaultAction();
29428
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 resultobj = SWIG_From_int((result));
29433 return resultobj;
29434 fail:
29435 return NULL;
29436 }
29437
29438
29439 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29440 PyObject *obj;
29441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29442 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29443 Py_INCREF(obj);
29444 return Py_BuildValue((char *)"");
29445 }
29446 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj;
29448 wxPyTextDropTarget *result;
29449 char *kwnames[] = {
29450 NULL
29451 };
29452
29453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29454 {
29455 PyThreadState* __tstate = wxPyBeginAllowThreads();
29456 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29457
29458 wxPyEndAllowThreads(__tstate);
29459 if (PyErr_Occurred()) SWIG_fail;
29460 }
29461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29462 return resultobj;
29463 fail:
29464 return NULL;
29465 }
29466
29467
29468 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29469 PyObject *resultobj;
29470 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29471 PyObject *arg2 = (PyObject *) 0 ;
29472 PyObject *arg3 = (PyObject *) 0 ;
29473 PyObject * obj0 = 0 ;
29474 PyObject * obj1 = 0 ;
29475 PyObject * obj2 = 0 ;
29476 char *kwnames[] = {
29477 (char *) "self",(char *) "self",(char *) "_class", NULL
29478 };
29479
29480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29482 if (SWIG_arg_fail(1)) SWIG_fail;
29483 arg2 = obj1;
29484 arg3 = obj2;
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 (arg1)->_setCallbackInfo(arg2,arg3);
29488
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 Py_INCREF(Py_None); resultobj = Py_None;
29493 return resultobj;
29494 fail:
29495 return NULL;
29496 }
29497
29498
29499 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29500 PyObject *resultobj;
29501 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29502 int arg2 ;
29503 int arg3 ;
29504 wxDragResult arg4 ;
29505 wxDragResult result;
29506 PyObject * obj0 = 0 ;
29507 PyObject * obj1 = 0 ;
29508 PyObject * obj2 = 0 ;
29509 PyObject * obj3 = 0 ;
29510 char *kwnames[] = {
29511 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29512 };
29513
29514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29527 if (SWIG_arg_fail(4)) SWIG_fail;
29528 }
29529 {
29530 PyThreadState* __tstate = wxPyBeginAllowThreads();
29531 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29532
29533 wxPyEndAllowThreads(__tstate);
29534 if (PyErr_Occurred()) SWIG_fail;
29535 }
29536 resultobj = SWIG_From_int((result));
29537 return resultobj;
29538 fail:
29539 return NULL;
29540 }
29541
29542
29543 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29544 PyObject *resultobj;
29545 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29546 int arg2 ;
29547 int arg3 ;
29548 wxDragResult arg4 ;
29549 wxDragResult result;
29550 PyObject * obj0 = 0 ;
29551 PyObject * obj1 = 0 ;
29552 PyObject * obj2 = 0 ;
29553 PyObject * obj3 = 0 ;
29554 char *kwnames[] = {
29555 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29556 };
29557
29558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29560 if (SWIG_arg_fail(1)) SWIG_fail;
29561 {
29562 arg2 = (int)(SWIG_As_int(obj1));
29563 if (SWIG_arg_fail(2)) SWIG_fail;
29564 }
29565 {
29566 arg3 = (int)(SWIG_As_int(obj2));
29567 if (SWIG_arg_fail(3)) SWIG_fail;
29568 }
29569 {
29570 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29571 if (SWIG_arg_fail(4)) SWIG_fail;
29572 }
29573 {
29574 PyThreadState* __tstate = wxPyBeginAllowThreads();
29575 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29576
29577 wxPyEndAllowThreads(__tstate);
29578 if (PyErr_Occurred()) SWIG_fail;
29579 }
29580 resultobj = SWIG_From_int((result));
29581 return resultobj;
29582 fail:
29583 return NULL;
29584 }
29585
29586
29587 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29588 PyObject *resultobj;
29589 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29590 PyObject * obj0 = 0 ;
29591 char *kwnames[] = {
29592 (char *) "self", NULL
29593 };
29594
29595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29597 if (SWIG_arg_fail(1)) SWIG_fail;
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 (arg1)->base_OnLeave();
29601
29602 wxPyEndAllowThreads(__tstate);
29603 if (PyErr_Occurred()) SWIG_fail;
29604 }
29605 Py_INCREF(Py_None); resultobj = Py_None;
29606 return resultobj;
29607 fail:
29608 return NULL;
29609 }
29610
29611
29612 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29613 PyObject *resultobj;
29614 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29615 int arg2 ;
29616 int arg3 ;
29617 bool result;
29618 PyObject * obj0 = 0 ;
29619 PyObject * obj1 = 0 ;
29620 PyObject * obj2 = 0 ;
29621 char *kwnames[] = {
29622 (char *) "self",(char *) "x",(char *) "y", NULL
29623 };
29624
29625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29627 if (SWIG_arg_fail(1)) SWIG_fail;
29628 {
29629 arg2 = (int)(SWIG_As_int(obj1));
29630 if (SWIG_arg_fail(2)) SWIG_fail;
29631 }
29632 {
29633 arg3 = (int)(SWIG_As_int(obj2));
29634 if (SWIG_arg_fail(3)) SWIG_fail;
29635 }
29636 {
29637 PyThreadState* __tstate = wxPyBeginAllowThreads();
29638 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29639
29640 wxPyEndAllowThreads(__tstate);
29641 if (PyErr_Occurred()) SWIG_fail;
29642 }
29643 {
29644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29645 }
29646 return resultobj;
29647 fail:
29648 return NULL;
29649 }
29650
29651
29652 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29653 PyObject *resultobj;
29654 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29655 int arg2 ;
29656 int arg3 ;
29657 wxDragResult arg4 ;
29658 wxDragResult result;
29659 PyObject * obj0 = 0 ;
29660 PyObject * obj1 = 0 ;
29661 PyObject * obj2 = 0 ;
29662 PyObject * obj3 = 0 ;
29663 char *kwnames[] = {
29664 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29665 };
29666
29667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29669 if (SWIG_arg_fail(1)) SWIG_fail;
29670 {
29671 arg2 = (int)(SWIG_As_int(obj1));
29672 if (SWIG_arg_fail(2)) SWIG_fail;
29673 }
29674 {
29675 arg3 = (int)(SWIG_As_int(obj2));
29676 if (SWIG_arg_fail(3)) SWIG_fail;
29677 }
29678 {
29679 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29680 if (SWIG_arg_fail(4)) SWIG_fail;
29681 }
29682 {
29683 PyThreadState* __tstate = wxPyBeginAllowThreads();
29684 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29685
29686 wxPyEndAllowThreads(__tstate);
29687 if (PyErr_Occurred()) SWIG_fail;
29688 }
29689 resultobj = SWIG_From_int((result));
29690 return resultobj;
29691 fail:
29692 return NULL;
29693 }
29694
29695
29696 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29697 PyObject *obj;
29698 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29699 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29700 Py_INCREF(obj);
29701 return Py_BuildValue((char *)"");
29702 }
29703 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29704 PyObject *resultobj;
29705 wxPyFileDropTarget *result;
29706 char *kwnames[] = {
29707 NULL
29708 };
29709
29710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29711 {
29712 PyThreadState* __tstate = wxPyBeginAllowThreads();
29713 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29714
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29719 return resultobj;
29720 fail:
29721 return NULL;
29722 }
29723
29724
29725 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29726 PyObject *resultobj;
29727 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29728 PyObject *arg2 = (PyObject *) 0 ;
29729 PyObject *arg3 = (PyObject *) 0 ;
29730 PyObject * obj0 = 0 ;
29731 PyObject * obj1 = 0 ;
29732 PyObject * obj2 = 0 ;
29733 char *kwnames[] = {
29734 (char *) "self",(char *) "self",(char *) "_class", NULL
29735 };
29736
29737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29739 if (SWIG_arg_fail(1)) SWIG_fail;
29740 arg2 = obj1;
29741 arg3 = obj2;
29742 {
29743 PyThreadState* __tstate = wxPyBeginAllowThreads();
29744 (arg1)->_setCallbackInfo(arg2,arg3);
29745
29746 wxPyEndAllowThreads(__tstate);
29747 if (PyErr_Occurred()) SWIG_fail;
29748 }
29749 Py_INCREF(Py_None); resultobj = Py_None;
29750 return resultobj;
29751 fail:
29752 return NULL;
29753 }
29754
29755
29756 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29757 PyObject *resultobj;
29758 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29759 int arg2 ;
29760 int arg3 ;
29761 wxDragResult arg4 ;
29762 wxDragResult result;
29763 PyObject * obj0 = 0 ;
29764 PyObject * obj1 = 0 ;
29765 PyObject * obj2 = 0 ;
29766 PyObject * obj3 = 0 ;
29767 char *kwnames[] = {
29768 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29769 };
29770
29771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29784 if (SWIG_arg_fail(4)) SWIG_fail;
29785 }
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29789
29790 wxPyEndAllowThreads(__tstate);
29791 if (PyErr_Occurred()) SWIG_fail;
29792 }
29793 resultobj = SWIG_From_int((result));
29794 return resultobj;
29795 fail:
29796 return NULL;
29797 }
29798
29799
29800 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29801 PyObject *resultobj;
29802 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29803 int arg2 ;
29804 int arg3 ;
29805 wxDragResult arg4 ;
29806 wxDragResult result;
29807 PyObject * obj0 = 0 ;
29808 PyObject * obj1 = 0 ;
29809 PyObject * obj2 = 0 ;
29810 PyObject * obj3 = 0 ;
29811 char *kwnames[] = {
29812 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29813 };
29814
29815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29817 if (SWIG_arg_fail(1)) SWIG_fail;
29818 {
29819 arg2 = (int)(SWIG_As_int(obj1));
29820 if (SWIG_arg_fail(2)) SWIG_fail;
29821 }
29822 {
29823 arg3 = (int)(SWIG_As_int(obj2));
29824 if (SWIG_arg_fail(3)) SWIG_fail;
29825 }
29826 {
29827 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29828 if (SWIG_arg_fail(4)) SWIG_fail;
29829 }
29830 {
29831 PyThreadState* __tstate = wxPyBeginAllowThreads();
29832 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29833
29834 wxPyEndAllowThreads(__tstate);
29835 if (PyErr_Occurred()) SWIG_fail;
29836 }
29837 resultobj = SWIG_From_int((result));
29838 return resultobj;
29839 fail:
29840 return NULL;
29841 }
29842
29843
29844 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29845 PyObject *resultobj;
29846 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29847 PyObject * obj0 = 0 ;
29848 char *kwnames[] = {
29849 (char *) "self", NULL
29850 };
29851
29852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29854 if (SWIG_arg_fail(1)) SWIG_fail;
29855 {
29856 PyThreadState* __tstate = wxPyBeginAllowThreads();
29857 (arg1)->base_OnLeave();
29858
29859 wxPyEndAllowThreads(__tstate);
29860 if (PyErr_Occurred()) SWIG_fail;
29861 }
29862 Py_INCREF(Py_None); resultobj = Py_None;
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29870 PyObject *resultobj;
29871 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29872 int arg2 ;
29873 int arg3 ;
29874 bool result;
29875 PyObject * obj0 = 0 ;
29876 PyObject * obj1 = 0 ;
29877 PyObject * obj2 = 0 ;
29878 char *kwnames[] = {
29879 (char *) "self",(char *) "x",(char *) "y", NULL
29880 };
29881
29882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29884 if (SWIG_arg_fail(1)) SWIG_fail;
29885 {
29886 arg2 = (int)(SWIG_As_int(obj1));
29887 if (SWIG_arg_fail(2)) SWIG_fail;
29888 }
29889 {
29890 arg3 = (int)(SWIG_As_int(obj2));
29891 if (SWIG_arg_fail(3)) SWIG_fail;
29892 }
29893 {
29894 PyThreadState* __tstate = wxPyBeginAllowThreads();
29895 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29896
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 {
29901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29902 }
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29910 PyObject *resultobj;
29911 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29912 int arg2 ;
29913 int arg3 ;
29914 wxDragResult arg4 ;
29915 wxDragResult result;
29916 PyObject * obj0 = 0 ;
29917 PyObject * obj1 = 0 ;
29918 PyObject * obj2 = 0 ;
29919 PyObject * obj3 = 0 ;
29920 char *kwnames[] = {
29921 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29922 };
29923
29924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29926 if (SWIG_arg_fail(1)) SWIG_fail;
29927 {
29928 arg2 = (int)(SWIG_As_int(obj1));
29929 if (SWIG_arg_fail(2)) SWIG_fail;
29930 }
29931 {
29932 arg3 = (int)(SWIG_As_int(obj2));
29933 if (SWIG_arg_fail(3)) SWIG_fail;
29934 }
29935 {
29936 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29937 if (SWIG_arg_fail(4)) SWIG_fail;
29938 }
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29942
29943 wxPyEndAllowThreads(__tstate);
29944 if (PyErr_Occurred()) SWIG_fail;
29945 }
29946 resultobj = SWIG_From_int((result));
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29954 PyObject *obj;
29955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29956 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29957 Py_INCREF(obj);
29958 return Py_BuildValue((char *)"");
29959 }
29960 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29961 PyObject *resultobj;
29962 wxClipboard *result;
29963 char *kwnames[] = {
29964 NULL
29965 };
29966
29967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29968 {
29969 PyThreadState* __tstate = wxPyBeginAllowThreads();
29970 result = (wxClipboard *)new wxClipboard();
29971
29972 wxPyEndAllowThreads(__tstate);
29973 if (PyErr_Occurred()) SWIG_fail;
29974 }
29975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29976 return resultobj;
29977 fail:
29978 return NULL;
29979 }
29980
29981
29982 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29983 PyObject *resultobj;
29984 wxClipboard *arg1 = (wxClipboard *) 0 ;
29985 PyObject * obj0 = 0 ;
29986 char *kwnames[] = {
29987 (char *) "self", NULL
29988 };
29989
29990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29992 if (SWIG_arg_fail(1)) SWIG_fail;
29993 {
29994 PyThreadState* __tstate = wxPyBeginAllowThreads();
29995 delete arg1;
29996
29997 wxPyEndAllowThreads(__tstate);
29998 if (PyErr_Occurred()) SWIG_fail;
29999 }
30000 Py_INCREF(Py_None); resultobj = Py_None;
30001 return resultobj;
30002 fail:
30003 return NULL;
30004 }
30005
30006
30007 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
30008 PyObject *resultobj;
30009 wxClipboard *arg1 = (wxClipboard *) 0 ;
30010 bool result;
30011 PyObject * obj0 = 0 ;
30012 char *kwnames[] = {
30013 (char *) "self", NULL
30014 };
30015
30016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
30017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30018 if (SWIG_arg_fail(1)) SWIG_fail;
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 result = (bool)(arg1)->Open();
30022
30023 wxPyEndAllowThreads(__tstate);
30024 if (PyErr_Occurred()) SWIG_fail;
30025 }
30026 {
30027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30028 }
30029 return resultobj;
30030 fail:
30031 return NULL;
30032 }
30033
30034
30035 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
30036 PyObject *resultobj;
30037 wxClipboard *arg1 = (wxClipboard *) 0 ;
30038 PyObject * obj0 = 0 ;
30039 char *kwnames[] = {
30040 (char *) "self", NULL
30041 };
30042
30043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
30044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30045 if (SWIG_arg_fail(1)) SWIG_fail;
30046 {
30047 PyThreadState* __tstate = wxPyBeginAllowThreads();
30048 (arg1)->Close();
30049
30050 wxPyEndAllowThreads(__tstate);
30051 if (PyErr_Occurred()) SWIG_fail;
30052 }
30053 Py_INCREF(Py_None); resultobj = Py_None;
30054 return resultobj;
30055 fail:
30056 return NULL;
30057 }
30058
30059
30060 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
30061 PyObject *resultobj;
30062 wxClipboard *arg1 = (wxClipboard *) 0 ;
30063 bool result;
30064 PyObject * obj0 = 0 ;
30065 char *kwnames[] = {
30066 (char *) "self", NULL
30067 };
30068
30069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
30070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30071 if (SWIG_arg_fail(1)) SWIG_fail;
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 result = (bool)((wxClipboard const *)arg1)->IsOpened();
30075
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 {
30080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30081 }
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
30089 PyObject *resultobj;
30090 wxClipboard *arg1 = (wxClipboard *) 0 ;
30091 wxDataObject *arg2 = (wxDataObject *) 0 ;
30092 bool result;
30093 PyObject * obj0 = 0 ;
30094 PyObject * obj1 = 0 ;
30095 char *kwnames[] = {
30096 (char *) "self",(char *) "data", NULL
30097 };
30098
30099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
30100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30101 if (SWIG_arg_fail(1)) SWIG_fail;
30102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30103 if (SWIG_arg_fail(2)) SWIG_fail;
30104 {
30105 PyThreadState* __tstate = wxPyBeginAllowThreads();
30106 result = (bool)(arg1)->AddData(arg2);
30107
30108 wxPyEndAllowThreads(__tstate);
30109 if (PyErr_Occurred()) SWIG_fail;
30110 }
30111 {
30112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30113 }
30114 return resultobj;
30115 fail:
30116 return NULL;
30117 }
30118
30119
30120 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
30121 PyObject *resultobj;
30122 wxClipboard *arg1 = (wxClipboard *) 0 ;
30123 wxDataObject *arg2 = (wxDataObject *) 0 ;
30124 bool result;
30125 PyObject * obj0 = 0 ;
30126 PyObject * obj1 = 0 ;
30127 char *kwnames[] = {
30128 (char *) "self",(char *) "data", NULL
30129 };
30130
30131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
30132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30133 if (SWIG_arg_fail(1)) SWIG_fail;
30134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30135 if (SWIG_arg_fail(2)) SWIG_fail;
30136 {
30137 PyThreadState* __tstate = wxPyBeginAllowThreads();
30138 result = (bool)(arg1)->SetData(arg2);
30139
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 {
30144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30145 }
30146 return resultobj;
30147 fail:
30148 return NULL;
30149 }
30150
30151
30152 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30153 PyObject *resultobj;
30154 wxClipboard *arg1 = (wxClipboard *) 0 ;
30155 wxDataFormat *arg2 = 0 ;
30156 bool result;
30157 PyObject * obj0 = 0 ;
30158 PyObject * obj1 = 0 ;
30159 char *kwnames[] = {
30160 (char *) "self",(char *) "format", NULL
30161 };
30162
30163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30165 if (SWIG_arg_fail(1)) SWIG_fail;
30166 {
30167 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30168 if (SWIG_arg_fail(2)) SWIG_fail;
30169 if (arg2 == NULL) {
30170 SWIG_null_ref("wxDataFormat");
30171 }
30172 if (SWIG_arg_fail(2)) SWIG_fail;
30173 }
30174 {
30175 PyThreadState* __tstate = wxPyBeginAllowThreads();
30176 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30177
30178 wxPyEndAllowThreads(__tstate);
30179 if (PyErr_Occurred()) SWIG_fail;
30180 }
30181 {
30182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30183 }
30184 return resultobj;
30185 fail:
30186 return NULL;
30187 }
30188
30189
30190 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30191 PyObject *resultobj;
30192 wxClipboard *arg1 = (wxClipboard *) 0 ;
30193 wxDataObject *arg2 = 0 ;
30194 bool result;
30195 PyObject * obj0 = 0 ;
30196 PyObject * obj1 = 0 ;
30197 char *kwnames[] = {
30198 (char *) "self",(char *) "data", NULL
30199 };
30200
30201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30203 if (SWIG_arg_fail(1)) SWIG_fail;
30204 {
30205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30206 if (SWIG_arg_fail(2)) SWIG_fail;
30207 if (arg2 == NULL) {
30208 SWIG_null_ref("wxDataObject");
30209 }
30210 if (SWIG_arg_fail(2)) SWIG_fail;
30211 }
30212 {
30213 PyThreadState* __tstate = wxPyBeginAllowThreads();
30214 result = (bool)(arg1)->GetData(*arg2);
30215
30216 wxPyEndAllowThreads(__tstate);
30217 if (PyErr_Occurred()) SWIG_fail;
30218 }
30219 {
30220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30221 }
30222 return resultobj;
30223 fail:
30224 return NULL;
30225 }
30226
30227
30228 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30229 PyObject *resultobj;
30230 wxClipboard *arg1 = (wxClipboard *) 0 ;
30231 PyObject * obj0 = 0 ;
30232 char *kwnames[] = {
30233 (char *) "self", NULL
30234 };
30235
30236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30238 if (SWIG_arg_fail(1)) SWIG_fail;
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 (arg1)->Clear();
30242
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 Py_INCREF(Py_None); resultobj = Py_None;
30247 return resultobj;
30248 fail:
30249 return NULL;
30250 }
30251
30252
30253 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30254 PyObject *resultobj;
30255 wxClipboard *arg1 = (wxClipboard *) 0 ;
30256 bool result;
30257 PyObject * obj0 = 0 ;
30258 char *kwnames[] = {
30259 (char *) "self", NULL
30260 };
30261
30262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30264 if (SWIG_arg_fail(1)) SWIG_fail;
30265 {
30266 PyThreadState* __tstate = wxPyBeginAllowThreads();
30267 result = (bool)(arg1)->Flush();
30268
30269 wxPyEndAllowThreads(__tstate);
30270 if (PyErr_Occurred()) SWIG_fail;
30271 }
30272 {
30273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30274 }
30275 return resultobj;
30276 fail:
30277 return NULL;
30278 }
30279
30280
30281 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30282 PyObject *resultobj;
30283 wxClipboard *arg1 = (wxClipboard *) 0 ;
30284 bool arg2 = (bool) true ;
30285 PyObject * obj0 = 0 ;
30286 PyObject * obj1 = 0 ;
30287 char *kwnames[] = {
30288 (char *) "self",(char *) "primary", NULL
30289 };
30290
30291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30293 if (SWIG_arg_fail(1)) SWIG_fail;
30294 if (obj1) {
30295 {
30296 arg2 = (bool)(SWIG_As_bool(obj1));
30297 if (SWIG_arg_fail(2)) SWIG_fail;
30298 }
30299 }
30300 {
30301 PyThreadState* __tstate = wxPyBeginAllowThreads();
30302 (arg1)->UsePrimarySelection(arg2);
30303
30304 wxPyEndAllowThreads(__tstate);
30305 if (PyErr_Occurred()) SWIG_fail;
30306 }
30307 Py_INCREF(Py_None); resultobj = Py_None;
30308 return resultobj;
30309 fail:
30310 return NULL;
30311 }
30312
30313
30314 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30315 PyObject *resultobj;
30316 wxClipboard *result;
30317 char *kwnames[] = {
30318 NULL
30319 };
30320
30321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 result = (wxClipboard *)wxClipboard::Get();
30325
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30337 PyObject *obj;
30338 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30339 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30340 Py_INCREF(obj);
30341 return Py_BuildValue((char *)"");
30342 }
30343 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30344 PyObject *resultobj;
30345 wxClipboard *arg1 = (wxClipboard *) NULL ;
30346 wxClipboardLocker *result;
30347 PyObject * obj0 = 0 ;
30348 char *kwnames[] = {
30349 (char *) "clipboard", NULL
30350 };
30351
30352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30353 if (obj0) {
30354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30355 if (SWIG_arg_fail(1)) SWIG_fail;
30356 }
30357 {
30358 PyThreadState* __tstate = wxPyBeginAllowThreads();
30359 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30360
30361 wxPyEndAllowThreads(__tstate);
30362 if (PyErr_Occurred()) SWIG_fail;
30363 }
30364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30372 PyObject *resultobj;
30373 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30374 PyObject * obj0 = 0 ;
30375 char *kwnames[] = {
30376 (char *) "self", NULL
30377 };
30378
30379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30381 if (SWIG_arg_fail(1)) SWIG_fail;
30382 {
30383 PyThreadState* __tstate = wxPyBeginAllowThreads();
30384 delete arg1;
30385
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 Py_INCREF(Py_None); resultobj = Py_None;
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj;
30398 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30399 bool result;
30400 PyObject * obj0 = 0 ;
30401 char *kwnames[] = {
30402 (char *) "self", NULL
30403 };
30404
30405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30407 if (SWIG_arg_fail(1)) SWIG_fail;
30408 {
30409 PyThreadState* __tstate = wxPyBeginAllowThreads();
30410 result = (bool)wxClipboardLocker___nonzero__(arg1);
30411
30412 wxPyEndAllowThreads(__tstate);
30413 if (PyErr_Occurred()) SWIG_fail;
30414 }
30415 {
30416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30417 }
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30425 PyObject *obj;
30426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30427 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30428 Py_INCREF(obj);
30429 return Py_BuildValue((char *)"");
30430 }
30431 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30432 PyObject *resultobj;
30433 int arg1 = (int) 0 ;
30434 int arg2 = (int) 0 ;
30435 int arg3 = (int) 0 ;
30436 int arg4 = (int) 0 ;
30437 wxVideoMode *result;
30438 PyObject * obj0 = 0 ;
30439 PyObject * obj1 = 0 ;
30440 PyObject * obj2 = 0 ;
30441 PyObject * obj3 = 0 ;
30442 char *kwnames[] = {
30443 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30444 };
30445
30446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30447 if (obj0) {
30448 {
30449 arg1 = (int)(SWIG_As_int(obj0));
30450 if (SWIG_arg_fail(1)) SWIG_fail;
30451 }
30452 }
30453 if (obj1) {
30454 {
30455 arg2 = (int)(SWIG_As_int(obj1));
30456 if (SWIG_arg_fail(2)) SWIG_fail;
30457 }
30458 }
30459 if (obj2) {
30460 {
30461 arg3 = (int)(SWIG_As_int(obj2));
30462 if (SWIG_arg_fail(3)) SWIG_fail;
30463 }
30464 }
30465 if (obj3) {
30466 {
30467 arg4 = (int)(SWIG_As_int(obj3));
30468 if (SWIG_arg_fail(4)) SWIG_fail;
30469 }
30470 }
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30474
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30479 return resultobj;
30480 fail:
30481 return NULL;
30482 }
30483
30484
30485 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30486 PyObject *resultobj;
30487 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30488 PyObject * obj0 = 0 ;
30489 char *kwnames[] = {
30490 (char *) "self", NULL
30491 };
30492
30493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30495 if (SWIG_arg_fail(1)) SWIG_fail;
30496 {
30497 PyThreadState* __tstate = wxPyBeginAllowThreads();
30498 delete arg1;
30499
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 Py_INCREF(Py_None); resultobj = Py_None;
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30511 PyObject *resultobj;
30512 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30513 wxVideoMode *arg2 = 0 ;
30514 bool result;
30515 PyObject * obj0 = 0 ;
30516 PyObject * obj1 = 0 ;
30517 char *kwnames[] = {
30518 (char *) "self",(char *) "other", NULL
30519 };
30520
30521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30523 if (SWIG_arg_fail(1)) SWIG_fail;
30524 {
30525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30526 if (SWIG_arg_fail(2)) SWIG_fail;
30527 if (arg2 == NULL) {
30528 SWIG_null_ref("wxVideoMode");
30529 }
30530 if (SWIG_arg_fail(2)) SWIG_fail;
30531 }
30532 {
30533 PyThreadState* __tstate = wxPyBeginAllowThreads();
30534 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30535
30536 wxPyEndAllowThreads(__tstate);
30537 if (PyErr_Occurred()) SWIG_fail;
30538 }
30539 {
30540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30541 }
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30549 PyObject *resultobj;
30550 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30551 int result;
30552 PyObject * obj0 = 0 ;
30553 char *kwnames[] = {
30554 (char *) "self", NULL
30555 };
30556
30557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30559 if (SWIG_arg_fail(1)) SWIG_fail;
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30563
30564 wxPyEndAllowThreads(__tstate);
30565 if (PyErr_Occurred()) SWIG_fail;
30566 }
30567 {
30568 resultobj = SWIG_From_int((int)(result));
30569 }
30570 return resultobj;
30571 fail:
30572 return NULL;
30573 }
30574
30575
30576 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30577 PyObject *resultobj;
30578 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30579 int result;
30580 PyObject * obj0 = 0 ;
30581 char *kwnames[] = {
30582 (char *) "self", NULL
30583 };
30584
30585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30587 if (SWIG_arg_fail(1)) SWIG_fail;
30588 {
30589 PyThreadState* __tstate = wxPyBeginAllowThreads();
30590 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30591
30592 wxPyEndAllowThreads(__tstate);
30593 if (PyErr_Occurred()) SWIG_fail;
30594 }
30595 {
30596 resultobj = SWIG_From_int((int)(result));
30597 }
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30605 PyObject *resultobj;
30606 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30607 int result;
30608 PyObject * obj0 = 0 ;
30609 char *kwnames[] = {
30610 (char *) "self", NULL
30611 };
30612
30613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30615 if (SWIG_arg_fail(1)) SWIG_fail;
30616 {
30617 PyThreadState* __tstate = wxPyBeginAllowThreads();
30618 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30619
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 {
30624 resultobj = SWIG_From_int((int)(result));
30625 }
30626 return resultobj;
30627 fail:
30628 return NULL;
30629 }
30630
30631
30632 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30633 PyObject *resultobj;
30634 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30635 bool result;
30636 PyObject * obj0 = 0 ;
30637 char *kwnames[] = {
30638 (char *) "self", NULL
30639 };
30640
30641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30643 if (SWIG_arg_fail(1)) SWIG_fail;
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30647
30648 wxPyEndAllowThreads(__tstate);
30649 if (PyErr_Occurred()) SWIG_fail;
30650 }
30651 {
30652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30653 }
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30661 PyObject *resultobj;
30662 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30663 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30664 bool result;
30665 PyObject * obj0 = 0 ;
30666 PyObject * obj1 = 0 ;
30667 char *kwnames[] = {
30668 (char *) "self",(char *) "other", NULL
30669 };
30670
30671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30673 if (SWIG_arg_fail(1)) SWIG_fail;
30674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30675 if (SWIG_arg_fail(2)) SWIG_fail;
30676 {
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30679
30680 wxPyEndAllowThreads(__tstate);
30681 if (PyErr_Occurred()) SWIG_fail;
30682 }
30683 {
30684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30685 }
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30693 PyObject *resultobj;
30694 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30695 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30696 bool result;
30697 PyObject * obj0 = 0 ;
30698 PyObject * obj1 = 0 ;
30699 char *kwnames[] = {
30700 (char *) "self",(char *) "other", NULL
30701 };
30702
30703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30705 if (SWIG_arg_fail(1)) SWIG_fail;
30706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30707 if (SWIG_arg_fail(2)) SWIG_fail;
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30711
30712 wxPyEndAllowThreads(__tstate);
30713 if (PyErr_Occurred()) SWIG_fail;
30714 }
30715 {
30716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30717 }
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30725 PyObject *resultobj;
30726 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30727 int arg2 ;
30728 PyObject * obj0 = 0 ;
30729 PyObject * obj1 = 0 ;
30730 char *kwnames[] = {
30731 (char *) "self",(char *) "w", NULL
30732 };
30733
30734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30736 if (SWIG_arg_fail(1)) SWIG_fail;
30737 {
30738 arg2 = (int)(SWIG_As_int(obj1));
30739 if (SWIG_arg_fail(2)) SWIG_fail;
30740 }
30741 if (arg1) (arg1)->w = arg2;
30742
30743 Py_INCREF(Py_None); resultobj = Py_None;
30744 return resultobj;
30745 fail:
30746 return NULL;
30747 }
30748
30749
30750 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30751 PyObject *resultobj;
30752 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30753 int result;
30754 PyObject * obj0 = 0 ;
30755 char *kwnames[] = {
30756 (char *) "self", NULL
30757 };
30758
30759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30761 if (SWIG_arg_fail(1)) SWIG_fail;
30762 result = (int) ((arg1)->w);
30763
30764 {
30765 resultobj = SWIG_From_int((int)(result));
30766 }
30767 return resultobj;
30768 fail:
30769 return NULL;
30770 }
30771
30772
30773 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30774 PyObject *resultobj;
30775 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30776 int arg2 ;
30777 PyObject * obj0 = 0 ;
30778 PyObject * obj1 = 0 ;
30779 char *kwnames[] = {
30780 (char *) "self",(char *) "h", NULL
30781 };
30782
30783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30785 if (SWIG_arg_fail(1)) SWIG_fail;
30786 {
30787 arg2 = (int)(SWIG_As_int(obj1));
30788 if (SWIG_arg_fail(2)) SWIG_fail;
30789 }
30790 if (arg1) (arg1)->h = arg2;
30791
30792 Py_INCREF(Py_None); resultobj = Py_None;
30793 return resultobj;
30794 fail:
30795 return NULL;
30796 }
30797
30798
30799 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30800 PyObject *resultobj;
30801 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30802 int result;
30803 PyObject * obj0 = 0 ;
30804 char *kwnames[] = {
30805 (char *) "self", NULL
30806 };
30807
30808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30810 if (SWIG_arg_fail(1)) SWIG_fail;
30811 result = (int) ((arg1)->h);
30812
30813 {
30814 resultobj = SWIG_From_int((int)(result));
30815 }
30816 return resultobj;
30817 fail:
30818 return NULL;
30819 }
30820
30821
30822 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30823 PyObject *resultobj;
30824 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30825 int arg2 ;
30826 PyObject * obj0 = 0 ;
30827 PyObject * obj1 = 0 ;
30828 char *kwnames[] = {
30829 (char *) "self",(char *) "bpp", NULL
30830 };
30831
30832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30834 if (SWIG_arg_fail(1)) SWIG_fail;
30835 {
30836 arg2 = (int)(SWIG_As_int(obj1));
30837 if (SWIG_arg_fail(2)) SWIG_fail;
30838 }
30839 if (arg1) (arg1)->bpp = arg2;
30840
30841 Py_INCREF(Py_None); resultobj = Py_None;
30842 return resultobj;
30843 fail:
30844 return NULL;
30845 }
30846
30847
30848 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30849 PyObject *resultobj;
30850 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30851 int result;
30852 PyObject * obj0 = 0 ;
30853 char *kwnames[] = {
30854 (char *) "self", NULL
30855 };
30856
30857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30859 if (SWIG_arg_fail(1)) SWIG_fail;
30860 result = (int) ((arg1)->bpp);
30861
30862 {
30863 resultobj = SWIG_From_int((int)(result));
30864 }
30865 return resultobj;
30866 fail:
30867 return NULL;
30868 }
30869
30870
30871 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30872 PyObject *resultobj;
30873 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30874 int arg2 ;
30875 PyObject * obj0 = 0 ;
30876 PyObject * obj1 = 0 ;
30877 char *kwnames[] = {
30878 (char *) "self",(char *) "refresh", NULL
30879 };
30880
30881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30883 if (SWIG_arg_fail(1)) SWIG_fail;
30884 {
30885 arg2 = (int)(SWIG_As_int(obj1));
30886 if (SWIG_arg_fail(2)) SWIG_fail;
30887 }
30888 if (arg1) (arg1)->refresh = arg2;
30889
30890 Py_INCREF(Py_None); resultobj = Py_None;
30891 return resultobj;
30892 fail:
30893 return NULL;
30894 }
30895
30896
30897 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30898 PyObject *resultobj;
30899 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30900 int result;
30901 PyObject * obj0 = 0 ;
30902 char *kwnames[] = {
30903 (char *) "self", NULL
30904 };
30905
30906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30908 if (SWIG_arg_fail(1)) SWIG_fail;
30909 result = (int) ((arg1)->refresh);
30910
30911 {
30912 resultobj = SWIG_From_int((int)(result));
30913 }
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30921 PyObject *obj;
30922 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30923 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30924 Py_INCREF(obj);
30925 return Py_BuildValue((char *)"");
30926 }
30927 static int _wrap_DefaultVideoMode_set(PyObject *) {
30928 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30929 return 1;
30930 }
30931
30932
30933 static PyObject *_wrap_DefaultVideoMode_get(void) {
30934 PyObject *pyobj;
30935
30936 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30937 return pyobj;
30938 }
30939
30940
30941 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30942 PyObject *resultobj;
30943 size_t arg1 = (size_t) 0 ;
30944 wxDisplay *result;
30945 PyObject * obj0 = 0 ;
30946 char *kwnames[] = {
30947 (char *) "index", NULL
30948 };
30949
30950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30951 if (obj0) {
30952 {
30953 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30954 if (SWIG_arg_fail(1)) SWIG_fail;
30955 }
30956 }
30957 {
30958 PyThreadState* __tstate = wxPyBeginAllowThreads();
30959 result = (wxDisplay *)new wxDisplay(arg1);
30960
30961 wxPyEndAllowThreads(__tstate);
30962 if (PyErr_Occurred()) SWIG_fail;
30963 }
30964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30965 return resultobj;
30966 fail:
30967 return NULL;
30968 }
30969
30970
30971 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30972 PyObject *resultobj;
30973 wxDisplay *arg1 = (wxDisplay *) 0 ;
30974 PyObject * obj0 = 0 ;
30975 char *kwnames[] = {
30976 (char *) "self", NULL
30977 };
30978
30979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30981 if (SWIG_arg_fail(1)) SWIG_fail;
30982 {
30983 PyThreadState* __tstate = wxPyBeginAllowThreads();
30984 delete arg1;
30985
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 Py_INCREF(Py_None); resultobj = Py_None;
30990 return resultobj;
30991 fail:
30992 return NULL;
30993 }
30994
30995
30996 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30997 PyObject *resultobj;
30998 size_t result;
30999 char *kwnames[] = {
31000 NULL
31001 };
31002
31003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 result = (size_t)wxDisplay::GetCount();
31007
31008 wxPyEndAllowThreads(__tstate);
31009 if (PyErr_Occurred()) SWIG_fail;
31010 }
31011 {
31012 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
31013 }
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj;
31022 wxPoint *arg1 = 0 ;
31023 int result;
31024 wxPoint temp1 ;
31025 PyObject * obj0 = 0 ;
31026 char *kwnames[] = {
31027 (char *) "pt", NULL
31028 };
31029
31030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
31031 {
31032 arg1 = &temp1;
31033 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
31034 }
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 {
31043 resultobj = SWIG_From_int((int)(result));
31044 }
31045 return resultobj;
31046 fail:
31047 return NULL;
31048 }
31049
31050
31051 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31052 PyObject *resultobj;
31053 wxWindow *arg1 = (wxWindow *) 0 ;
31054 int result;
31055 PyObject * obj0 = 0 ;
31056 char *kwnames[] = {
31057 (char *) "window", NULL
31058 };
31059
31060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
31061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31062 if (SWIG_arg_fail(1)) SWIG_fail;
31063 {
31064 PyThreadState* __tstate = wxPyBeginAllowThreads();
31065 result = (int)wxDisplay::GetFromWindow(arg1);
31066
31067 wxPyEndAllowThreads(__tstate);
31068 if (PyErr_Occurred()) SWIG_fail;
31069 }
31070 {
31071 resultobj = SWIG_From_int((int)(result));
31072 }
31073 return resultobj;
31074 fail:
31075 return NULL;
31076 }
31077
31078
31079 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
31080 PyObject *resultobj;
31081 wxDisplay *arg1 = (wxDisplay *) 0 ;
31082 bool result;
31083 PyObject * obj0 = 0 ;
31084 char *kwnames[] = {
31085 (char *) "self", NULL
31086 };
31087
31088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
31089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31090 if (SWIG_arg_fail(1)) SWIG_fail;
31091 {
31092 PyThreadState* __tstate = wxPyBeginAllowThreads();
31093 result = (bool)((wxDisplay const *)arg1)->IsOk();
31094
31095 wxPyEndAllowThreads(__tstate);
31096 if (PyErr_Occurred()) SWIG_fail;
31097 }
31098 {
31099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31100 }
31101 return resultobj;
31102 fail:
31103 return NULL;
31104 }
31105
31106
31107 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
31108 PyObject *resultobj;
31109 wxDisplay *arg1 = (wxDisplay *) 0 ;
31110 wxRect result;
31111 PyObject * obj0 = 0 ;
31112 char *kwnames[] = {
31113 (char *) "self", NULL
31114 };
31115
31116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
31117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31118 if (SWIG_arg_fail(1)) SWIG_fail;
31119 {
31120 PyThreadState* __tstate = wxPyBeginAllowThreads();
31121 result = ((wxDisplay const *)arg1)->GetGeometry();
31122
31123 wxPyEndAllowThreads(__tstate);
31124 if (PyErr_Occurred()) SWIG_fail;
31125 }
31126 {
31127 wxRect * resultptr;
31128 resultptr = new wxRect((wxRect &)(result));
31129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
31130 }
31131 return resultobj;
31132 fail:
31133 return NULL;
31134 }
31135
31136
31137 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
31138 PyObject *resultobj;
31139 wxDisplay *arg1 = (wxDisplay *) 0 ;
31140 wxString result;
31141 PyObject * obj0 = 0 ;
31142 char *kwnames[] = {
31143 (char *) "self", NULL
31144 };
31145
31146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31148 if (SWIG_arg_fail(1)) SWIG_fail;
31149 {
31150 PyThreadState* __tstate = wxPyBeginAllowThreads();
31151 result = ((wxDisplay const *)arg1)->GetName();
31152
31153 wxPyEndAllowThreads(__tstate);
31154 if (PyErr_Occurred()) SWIG_fail;
31155 }
31156 {
31157 #if wxUSE_UNICODE
31158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31159 #else
31160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31161 #endif
31162 }
31163 return resultobj;
31164 fail:
31165 return NULL;
31166 }
31167
31168
31169 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31170 PyObject *resultobj;
31171 wxDisplay *arg1 = (wxDisplay *) 0 ;
31172 bool result;
31173 PyObject * obj0 = 0 ;
31174 char *kwnames[] = {
31175 (char *) "self", NULL
31176 };
31177
31178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31180 if (SWIG_arg_fail(1)) SWIG_fail;
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31184
31185 wxPyEndAllowThreads(__tstate);
31186 if (PyErr_Occurred()) SWIG_fail;
31187 }
31188 {
31189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31190 }
31191 return resultobj;
31192 fail:
31193 return NULL;
31194 }
31195
31196
31197 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31198 PyObject *resultobj;
31199 wxDisplay *arg1 = (wxDisplay *) 0 ;
31200 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31201 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31202 PyObject *result;
31203 PyObject * obj0 = 0 ;
31204 PyObject * obj1 = 0 ;
31205 char *kwnames[] = {
31206 (char *) "self",(char *) "mode", NULL
31207 };
31208
31209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31211 if (SWIG_arg_fail(1)) SWIG_fail;
31212 if (obj1) {
31213 {
31214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31215 if (SWIG_arg_fail(2)) SWIG_fail;
31216 if (arg2 == NULL) {
31217 SWIG_null_ref("wxVideoMode");
31218 }
31219 if (SWIG_arg_fail(2)) SWIG_fail;
31220 }
31221 }
31222 {
31223 PyThreadState* __tstate = wxPyBeginAllowThreads();
31224 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31225
31226 wxPyEndAllowThreads(__tstate);
31227 if (PyErr_Occurred()) SWIG_fail;
31228 }
31229 resultobj = result;
31230 return resultobj;
31231 fail:
31232 return NULL;
31233 }
31234
31235
31236 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31237 PyObject *resultobj;
31238 wxDisplay *arg1 = (wxDisplay *) 0 ;
31239 wxVideoMode result;
31240 PyObject * obj0 = 0 ;
31241 char *kwnames[] = {
31242 (char *) "self", NULL
31243 };
31244
31245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31247 if (SWIG_arg_fail(1)) SWIG_fail;
31248 {
31249 PyThreadState* __tstate = wxPyBeginAllowThreads();
31250 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31251
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 {
31256 wxVideoMode * resultptr;
31257 resultptr = new wxVideoMode((wxVideoMode &)(result));
31258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31259 }
31260 return resultobj;
31261 fail:
31262 return NULL;
31263 }
31264
31265
31266 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31267 PyObject *resultobj;
31268 wxDisplay *arg1 = (wxDisplay *) 0 ;
31269 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31270 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31271 bool result;
31272 PyObject * obj0 = 0 ;
31273 PyObject * obj1 = 0 ;
31274 char *kwnames[] = {
31275 (char *) "self",(char *) "mode", NULL
31276 };
31277
31278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31280 if (SWIG_arg_fail(1)) SWIG_fail;
31281 if (obj1) {
31282 {
31283 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31284 if (SWIG_arg_fail(2)) SWIG_fail;
31285 if (arg2 == NULL) {
31286 SWIG_null_ref("wxVideoMode");
31287 }
31288 if (SWIG_arg_fail(2)) SWIG_fail;
31289 }
31290 }
31291 {
31292 PyThreadState* __tstate = wxPyBeginAllowThreads();
31293 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31294
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 {
31299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31300 }
31301 return resultobj;
31302 fail:
31303 return NULL;
31304 }
31305
31306
31307 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31308 PyObject *resultobj;
31309 wxDisplay *arg1 = (wxDisplay *) 0 ;
31310 PyObject * obj0 = 0 ;
31311 char *kwnames[] = {
31312 (char *) "self", NULL
31313 };
31314
31315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31317 if (SWIG_arg_fail(1)) SWIG_fail;
31318 {
31319 PyThreadState* __tstate = wxPyBeginAllowThreads();
31320 (arg1)->ResetMode();
31321
31322 wxPyEndAllowThreads(__tstate);
31323 if (PyErr_Occurred()) SWIG_fail;
31324 }
31325 Py_INCREF(Py_None); resultobj = Py_None;
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31333 PyObject *obj;
31334 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31335 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31336 Py_INCREF(obj);
31337 return Py_BuildValue((char *)"");
31338 }
31339 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31340 PyObject *resultobj;
31341 wxStandardPaths *result;
31342 char *kwnames[] = {
31343 NULL
31344 };
31345
31346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31347 {
31348 PyThreadState* __tstate = wxPyBeginAllowThreads();
31349 result = (wxStandardPaths *)StandardPaths_Get();
31350
31351 wxPyEndAllowThreads(__tstate);
31352 if (PyErr_Occurred()) SWIG_fail;
31353 }
31354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31355 return resultobj;
31356 fail:
31357 return NULL;
31358 }
31359
31360
31361 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31362 PyObject *resultobj;
31363 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31364 wxString result;
31365 PyObject * obj0 = 0 ;
31366 char *kwnames[] = {
31367 (char *) "self", NULL
31368 };
31369
31370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31372 if (SWIG_arg_fail(1)) SWIG_fail;
31373 {
31374 PyThreadState* __tstate = wxPyBeginAllowThreads();
31375 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31376
31377 wxPyEndAllowThreads(__tstate);
31378 if (PyErr_Occurred()) SWIG_fail;
31379 }
31380 {
31381 #if wxUSE_UNICODE
31382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31383 #else
31384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31385 #endif
31386 }
31387 return resultobj;
31388 fail:
31389 return NULL;
31390 }
31391
31392
31393 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31394 PyObject *resultobj;
31395 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31396 wxString result;
31397 PyObject * obj0 = 0 ;
31398 char *kwnames[] = {
31399 (char *) "self", NULL
31400 };
31401
31402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31404 if (SWIG_arg_fail(1)) SWIG_fail;
31405 {
31406 PyThreadState* __tstate = wxPyBeginAllowThreads();
31407 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31408
31409 wxPyEndAllowThreads(__tstate);
31410 if (PyErr_Occurred()) SWIG_fail;
31411 }
31412 {
31413 #if wxUSE_UNICODE
31414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31415 #else
31416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31417 #endif
31418 }
31419 return resultobj;
31420 fail:
31421 return NULL;
31422 }
31423
31424
31425 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31426 PyObject *resultobj;
31427 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31428 wxString result;
31429 PyObject * obj0 = 0 ;
31430 char *kwnames[] = {
31431 (char *) "self", NULL
31432 };
31433
31434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31436 if (SWIG_arg_fail(1)) SWIG_fail;
31437 {
31438 PyThreadState* __tstate = wxPyBeginAllowThreads();
31439 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31440
31441 wxPyEndAllowThreads(__tstate);
31442 if (PyErr_Occurred()) SWIG_fail;
31443 }
31444 {
31445 #if wxUSE_UNICODE
31446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31447 #else
31448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31449 #endif
31450 }
31451 return resultobj;
31452 fail:
31453 return NULL;
31454 }
31455
31456
31457 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31458 PyObject *resultobj;
31459 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31460 wxString result;
31461 PyObject * obj0 = 0 ;
31462 char *kwnames[] = {
31463 (char *) "self", NULL
31464 };
31465
31466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31468 if (SWIG_arg_fail(1)) SWIG_fail;
31469 {
31470 PyThreadState* __tstate = wxPyBeginAllowThreads();
31471 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31472
31473 wxPyEndAllowThreads(__tstate);
31474 if (PyErr_Occurred()) SWIG_fail;
31475 }
31476 {
31477 #if wxUSE_UNICODE
31478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31479 #else
31480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31481 #endif
31482 }
31483 return resultobj;
31484 fail:
31485 return NULL;
31486 }
31487
31488
31489 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31490 PyObject *resultobj;
31491 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31492 wxString result;
31493 PyObject * obj0 = 0 ;
31494 char *kwnames[] = {
31495 (char *) "self", NULL
31496 };
31497
31498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31500 if (SWIG_arg_fail(1)) SWIG_fail;
31501 {
31502 PyThreadState* __tstate = wxPyBeginAllowThreads();
31503 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31504
31505 wxPyEndAllowThreads(__tstate);
31506 if (PyErr_Occurred()) SWIG_fail;
31507 }
31508 {
31509 #if wxUSE_UNICODE
31510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31511 #else
31512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31513 #endif
31514 }
31515 return resultobj;
31516 fail:
31517 return NULL;
31518 }
31519
31520
31521 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31522 PyObject *resultobj;
31523 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31524 wxString result;
31525 PyObject * obj0 = 0 ;
31526 char *kwnames[] = {
31527 (char *) "self", NULL
31528 };
31529
31530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31532 if (SWIG_arg_fail(1)) SWIG_fail;
31533 {
31534 PyThreadState* __tstate = wxPyBeginAllowThreads();
31535 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31536
31537 wxPyEndAllowThreads(__tstate);
31538 if (PyErr_Occurred()) SWIG_fail;
31539 }
31540 {
31541 #if wxUSE_UNICODE
31542 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31543 #else
31544 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31545 #endif
31546 }
31547 return resultobj;
31548 fail:
31549 return NULL;
31550 }
31551
31552
31553 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31554 PyObject *resultobj;
31555 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31556 wxString result;
31557 PyObject * obj0 = 0 ;
31558 char *kwnames[] = {
31559 (char *) "self", NULL
31560 };
31561
31562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31564 if (SWIG_arg_fail(1)) SWIG_fail;
31565 {
31566 PyThreadState* __tstate = wxPyBeginAllowThreads();
31567 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31568
31569 wxPyEndAllowThreads(__tstate);
31570 if (PyErr_Occurred()) SWIG_fail;
31571 }
31572 {
31573 #if wxUSE_UNICODE
31574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31575 #else
31576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31577 #endif
31578 }
31579 return resultobj;
31580 fail:
31581 return NULL;
31582 }
31583
31584
31585 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31586 PyObject *resultobj;
31587 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31588 wxString *arg2 = 0 ;
31589 bool temp2 = false ;
31590 PyObject * obj0 = 0 ;
31591 PyObject * obj1 = 0 ;
31592 char *kwnames[] = {
31593 (char *) "self",(char *) "prefix", NULL
31594 };
31595
31596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31598 if (SWIG_arg_fail(1)) SWIG_fail;
31599 {
31600 arg2 = wxString_in_helper(obj1);
31601 if (arg2 == NULL) SWIG_fail;
31602 temp2 = true;
31603 }
31604 {
31605 PyThreadState* __tstate = wxPyBeginAllowThreads();
31606 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31607
31608 wxPyEndAllowThreads(__tstate);
31609 if (PyErr_Occurred()) SWIG_fail;
31610 }
31611 Py_INCREF(Py_None); resultobj = Py_None;
31612 {
31613 if (temp2)
31614 delete arg2;
31615 }
31616 return resultobj;
31617 fail:
31618 {
31619 if (temp2)
31620 delete arg2;
31621 }
31622 return NULL;
31623 }
31624
31625
31626 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31627 PyObject *resultobj;
31628 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31629 wxString result;
31630 PyObject * obj0 = 0 ;
31631 char *kwnames[] = {
31632 (char *) "self", NULL
31633 };
31634
31635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31637 if (SWIG_arg_fail(1)) SWIG_fail;
31638 {
31639 PyThreadState* __tstate = wxPyBeginAllowThreads();
31640 result = wxStandardPaths_GetInstallPrefix(arg1);
31641
31642 wxPyEndAllowThreads(__tstate);
31643 if (PyErr_Occurred()) SWIG_fail;
31644 }
31645 {
31646 #if wxUSE_UNICODE
31647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31648 #else
31649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31650 #endif
31651 }
31652 return resultobj;
31653 fail:
31654 return NULL;
31655 }
31656
31657
31658 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31659 PyObject *obj;
31660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31661 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31662 Py_INCREF(obj);
31663 return Py_BuildValue((char *)"");
31664 }
31665 static PyMethodDef SwigMethods[] = {
31666 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31673 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31681 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31747 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31755 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31773 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31776 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31779 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31782 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31788 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31802 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31808 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31814 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31817 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31831 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31834 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31835 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31838 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31865 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31867 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31869 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31871 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31878 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31884 { (char *)"new_LogBuffer", (PyCFunction) _wrap_new_LogBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"LogBuffer_GetBuffer", (PyCFunction) _wrap_LogBuffer_GetBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"LogBuffer_Flush", (PyCFunction) _wrap_LogBuffer_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
31888 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31902 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31906 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31909 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31926 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31934 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31981 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31999 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
32009 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
32025 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
32041 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
32055 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
32065 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
32108 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
32111 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
32114 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
32118 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32211 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32212 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32213 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32214 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32231 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32276 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32308 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32310 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32318 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32319 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32320 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32324 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32329 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32330 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32331 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32332 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32333 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32334 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32335 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32336 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32337 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32338 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32339 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32340 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32341 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32342 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32343 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32344 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32345 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32346 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32347 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32348 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32349 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32350 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32351 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32352 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32353 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32354 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32355 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32356 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32357 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32358 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32359 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32360 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32361 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32362 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32363 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32364 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32365 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32366 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32367 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32368 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32369 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32370 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32371 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32372 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32373 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32374 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32375 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32376 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32377 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32378 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32379 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32380 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32381 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32382 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32383 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32384 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32385 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32386 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32387 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32388 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32389 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32390 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32391 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32392 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32393 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32394 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32395 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32396 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32397 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32398 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32399 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32400 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32401 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32402 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32403 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32404 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32405 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32406 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32407 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32408 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32409 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32410 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32411 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32412 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32413 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32414 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32415 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32416 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32417 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32418 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32419 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32420 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32421 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32422 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32423 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32424 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32425 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32426 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32427 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32428 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32429 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32430 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32431 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32432 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32433 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32434 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32435 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32436 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32437 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32438 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32439 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32440 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32441 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32442 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32443 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32444 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32445 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32446 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32447 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32448 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32449 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32450 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32451 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32452 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32453 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32454 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32455 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32456 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32457 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32458 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32459 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32460 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32461 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32462 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32463 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32464 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32465 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32466 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32467 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32468 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32469 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32470 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32471 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32472 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32473 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32474 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32475 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32476 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32477 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32478 { NULL, NULL, 0, NULL }
32479 };
32480
32481
32482 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32483
32484 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32485 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32486 }
32487 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32488 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32489 }
32490 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32491 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32492 }
32493 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32494 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32495 }
32496 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32497 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32498 }
32499 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32500 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32501 }
32502 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32503 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32504 }
32505 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32506 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32507 }
32508 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32509 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32510 }
32511 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32512 return (void *)((wxEvent *) ((wxPyEvent *) x));
32513 }
32514 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32515 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32516 }
32517 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32518 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32519 }
32520 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32521 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32522 }
32523 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32524 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32525 }
32526 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32527 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32528 }
32529 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32530 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32531 }
32532 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32533 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32534 }
32535 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32536 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32537 }
32538 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32539 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32540 }
32541 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32542 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32543 }
32544 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32545 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32546 }
32547 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32548 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32549 }
32550 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32551 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32552 }
32553 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32554 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32555 }
32556 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32557 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32558 }
32559 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32560 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32561 }
32562 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32563 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32564 }
32565 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32566 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32567 }
32568 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32569 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32570 }
32571 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32572 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32573 }
32574 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32575 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32576 }
32577 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32578 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32579 }
32580 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32581 return (void *)((wxEvent *) ((wxShowEvent *) x));
32582 }
32583 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32584 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32585 }
32586 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32587 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32588 }
32589 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32590 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32591 }
32592 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32593 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32594 }
32595 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32596 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32597 }
32598 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32599 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32600 }
32601 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32602 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32603 }
32604 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32605 return (void *)((wxConfigBase *) ((wxConfig *) x));
32606 }
32607 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32608 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32609 }
32610 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32611 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32612 }
32613 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32614 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32615 }
32616 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32617 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32618 }
32619 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32620 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32621 }
32622 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32623 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32624 }
32625 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32626 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32627 }
32628 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32629 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32630 }
32631 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32632 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32633 }
32634 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32635 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32636 }
32637 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32638 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32639 }
32640 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32641 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32642 }
32643 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32644 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32645 }
32646 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32647 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32648 }
32649 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32650 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32651 }
32652 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32653 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32654 }
32655 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32656 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32657 }
32658 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32659 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32660 }
32661 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32662 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32663 }
32664 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32665 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32666 }
32667 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32668 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32669 }
32670 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32671 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32672 }
32673 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32674 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32675 }
32676 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32677 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32678 }
32679 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32680 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32681 }
32682 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32683 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32684 }
32685 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32686 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32687 }
32688 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32689 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32690 }
32691 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32692 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32693 }
32694 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32695 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32696 }
32697 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32698 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32699 }
32700 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32701 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32702 }
32703 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32704 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32705 }
32706 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32707 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32708 }
32709 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32710 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32711 }
32712 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32713 return (void *)((wxObject *) ((wxSizerItem *) x));
32714 }
32715 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32716 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32717 }
32718 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32719 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32720 }
32721 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32722 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32723 }
32724 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32725 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32726 }
32727 static void *_p_wxSizerTo_p_wxObject(void *x) {
32728 return (void *)((wxObject *) ((wxSizer *) x));
32729 }
32730 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32731 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32732 }
32733 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32734 return (void *)((wxObject *) ((wxFileHistory *) x));
32735 }
32736 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32737 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32738 }
32739 static void *_p_wxEventTo_p_wxObject(void *x) {
32740 return (void *)((wxObject *) ((wxEvent *) x));
32741 }
32742 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32743 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32744 }
32745 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32746 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32747 }
32748 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32749 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32750 }
32751 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32752 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32753 }
32754 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32755 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32756 }
32757 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32758 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32759 }
32760 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32761 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32762 }
32763 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32764 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32765 }
32766 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32767 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32768 }
32769 static void *_p_wxControlTo_p_wxObject(void *x) {
32770 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32771 }
32772 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32773 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32774 }
32775 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32776 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32777 }
32778 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32779 return (void *)((wxObject *) ((wxFSFile *) x));
32780 }
32781 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32782 return (void *)((wxObject *) ((wxClipboard *) x));
32783 }
32784 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32785 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32786 }
32787 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32788 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32789 }
32790 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32791 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32792 }
32793 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32794 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32795 }
32796 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32797 return (void *)((wxObject *) ((wxToolTip *) x));
32798 }
32799 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32800 return (void *)((wxObject *) ((wxMenuItem *) x));
32801 }
32802 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32803 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32804 }
32805 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32806 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32807 }
32808 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32809 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32810 }
32811 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32812 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32813 }
32814 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32815 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32816 }
32817 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32818 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32819 }
32820 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32821 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32822 }
32823 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32824 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32825 }
32826 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32827 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32828 }
32829 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32830 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32831 }
32832 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32833 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32834 }
32835 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32836 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32837 }
32838 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32839 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32840 }
32841 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32842 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32843 }
32844 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32845 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32846 }
32847 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32848 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32849 }
32850 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32851 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32852 }
32853 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32854 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32855 }
32856 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32857 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32858 }
32859 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32860 return (void *)((wxObject *) ((wxImageHandler *) x));
32861 }
32862 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32863 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32864 }
32865 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32866 return (void *)((wxObject *) ((wxEvtHandler *) x));
32867 }
32868 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32869 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32870 }
32871 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32872 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32873 }
32874 static void *_p_wxImageTo_p_wxObject(void *x) {
32875 return (void *)((wxObject *) ((wxImage *) x));
32876 }
32877 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32878 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32879 }
32880 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32881 return (void *)((wxObject *) ((wxSystemOptions *) x));
32882 }
32883 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32884 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32885 }
32886 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32887 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32888 }
32889 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32890 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32891 }
32892 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32893 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32894 }
32895 static void *_p_wxWindowTo_p_wxObject(void *x) {
32896 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32897 }
32898 static void *_p_wxMenuTo_p_wxObject(void *x) {
32899 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32900 }
32901 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32902 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32903 }
32904 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32905 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32906 }
32907 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32908 return (void *)((wxObject *) ((wxFileSystem *) x));
32909 }
32910 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32911 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32912 }
32913 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32914 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32915 }
32916 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32917 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32918 }
32919 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32920 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32921 }
32922 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32923 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32924 }
32925 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32926 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32927 }
32928 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32929 return (void *)((wxObject *) ((wxBusyInfo *) x));
32930 }
32931 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32932 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32933 }
32934 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32935 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32936 }
32937 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32938 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32939 }
32940 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32941 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32942 }
32943 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32944 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32945 }
32946 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32947 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32948 }
32949 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32950 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32951 }
32952 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32953 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32954 }
32955 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32956 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32957 }
32958 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32959 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32960 }
32961 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
32962 return (void *)((wxLog *) ((wxLogBuffer *) x));
32963 }
32964 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32965 return (void *)((wxLog *) ((wxLogStderr *) x));
32966 }
32967 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32968 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32969 }
32970 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32971 return (void *)((wxLog *) ((wxLogWindow *) x));
32972 }
32973 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32974 return (void *)((wxLog *) ((wxLogChain *) x));
32975 }
32976 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32977 return (void *)((wxLog *) ((wxLogGui *) x));
32978 }
32979 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32980 return (void *)((wxLog *) ((wxPyLog *) x));
32981 }
32982 static void *_p_wxControlTo_p_wxWindow(void *x) {
32983 return (void *)((wxWindow *) ((wxControl *) x));
32984 }
32985 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32986 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32987 }
32988 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32989 return (void *)((wxWindow *) ((wxMenuBar *) x));
32990 }
32991 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32992 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32993 }
32994 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32995 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32996 }
32997 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}};
32998 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}};
32999 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}};
33000 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}};
33001 static swig_type_info _swigt__p_wxLog[] = {{"_p_wxLog", 0, "wxLog *", 0, 0, 0, 0},{"_p_wxLogBuffer", _p_wxLogBufferTo_p_wxLog, 0, 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}};
33002 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}};
33003 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}};
33004 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}};
33005 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}};
33006 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}};
33007 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}};
33008 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}};
33009 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}};
33010 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}};
33011 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}};
33012 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}};
33013 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}};
33014 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}};
33015 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}};
33016 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}};
33017 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}};
33018 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}};
33019 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}};
33020 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}};
33021 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}};
33022 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}};
33023 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}};
33024 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}};
33025 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}};
33026 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}};
33027 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}};
33028 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}};
33029 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}};
33030 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}};
33031 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}};
33032 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}};
33033 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}};
33034 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}};
33035 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}};
33036 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}};
33037 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}};
33038 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}};
33039 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}};
33040 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}};
33041 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}};
33042 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}};
33043 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}};
33044 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}};
33045 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}};
33046 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}};
33047 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}};
33048 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}};
33049 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}};
33050 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}};
33051 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}};
33052 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}};
33053 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}};
33054 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}};
33055 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}};
33056 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}};
33057 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}};
33058 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}};
33059 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}};
33060 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}};
33061 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}};
33062 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}};
33063 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}};
33064 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}};
33065 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}};
33066 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}};
33067 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}};
33068 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}};
33069 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}};
33070 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}};
33071 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}};
33072 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}};
33073 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}};
33074 static swig_type_info _swigt__p_wxLogBuffer[] = {{"_p_wxLogBuffer", 0, "wxLogBuffer *", 0, 0, 0, 0},{"_p_wxLogBuffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
33075 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}};
33076 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}};
33077 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}};
33078 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}};
33079 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}};
33080 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}};
33081 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}};
33082 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}};
33083 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}};
33084 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}};
33085 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}};
33086 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}};
33087 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}};
33088 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}};
33089 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}};
33090 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}};
33091 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}};
33092 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}};
33093 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}};
33094 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}};
33095 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}};
33096
33097 static swig_type_info *swig_types_initial[] = {
33098 _swigt__p_wxLogChain,
33099 _swigt__p_wxMutexGuiLocker,
33100 _swigt__p_wxMetafile,
33101 _swigt__p_wxFileHistory,
33102 _swigt__p_wxLog,
33103 _swigt__p_wxMenu,
33104 _swigt__p_wxEvent,
33105 _swigt__p_wxDateTime__TimeZone,
33106 _swigt__p_wxConfigBase,
33107 _swigt__p_wxDisplay,
33108 _swigt__p_wxFileType,
33109 _swigt__p_wxLogGui,
33110 _swigt__p_wxFont,
33111 _swigt__p_wxDataFormat,
33112 _swigt__p_wxTimerEvent,
33113 _swigt__p_wxCaret,
33114 _swigt__ptrdiff_t,
33115 _swigt__std__ptrdiff_t,
33116 _swigt__p_void,
33117 _swigt__p_int,
33118 _swigt__p_wxSize,
33119 _swigt__p_wxClipboard,
33120 _swigt__p_wxStopWatch,
33121 _swigt__p_wxDC,
33122 _swigt__p_wxClipboardLocker,
33123 _swigt__p_wxIcon,
33124 _swigt__p_wxLogStderr,
33125 _swigt__p_wxLogTextCtrl,
33126 _swigt__p_wxTextCtrl,
33127 _swigt__p_wxBusyCursor,
33128 _swigt__p_wxBitmapDataObject,
33129 _swigt__p_wxTextDataObject,
33130 _swigt__p_wxDataObject,
33131 _swigt__p_wxPyTextDataObject,
33132 _swigt__p_wxPyBitmapDataObject,
33133 _swigt__p_wxFileDataObject,
33134 _swigt__p_wxCustomDataObject,
33135 _swigt__p_wxURLDataObject,
33136 _swigt__p_wxMetafileDataObject,
33137 _swigt__p_wxSound,
33138 _swigt__p_wxTimerRunner,
33139 _swigt__p_wxLogWindow,
33140 _swigt__p_wxTimeSpan,
33141 _swigt__p_wxArrayString,
33142 _swigt__p_wxWindowDisabler,
33143 _swigt__p_form_ops_t,
33144 _swigt__p_wxToolTip,
33145 _swigt__p_wxDataObjectComposite,
33146 _swigt__p_wxSystemSettings,
33147 _swigt__p_wxFileConfig,
33148 _swigt__p_wxVideoMode,
33149 _swigt__p_wxDataObjectSimple,
33150 _swigt__p_wxPyDataObjectSimple,
33151 _swigt__p_wxDuplexMode,
33152 _swigt__p_wxEvtHandler,
33153 _swigt__p_wxRect,
33154 _swigt__p_char,
33155 _swigt__p_wxSingleInstanceChecker,
33156 _swigt__p_wxStandardPaths,
33157 _swigt__p_wxFileTypeInfo,
33158 _swigt__p_wxFrame,
33159 _swigt__p_wxTimer,
33160 _swigt__p_wxPaperSize,
33161 _swigt__p_wxMimeTypesManager,
33162 _swigt__p_wxPyArtProvider,
33163 _swigt__p_wxPyTipProvider,
33164 _swigt__p_wxTipProvider,
33165 _swigt__p_wxJoystick,
33166 _swigt__p_wxSystemOptions,
33167 _swigt__p_wxPoint,
33168 _swigt__p_wxJoystickEvent,
33169 _swigt__p_wxCursor,
33170 _swigt__p_wxObject,
33171 _swigt__p_wxOutputStream,
33172 _swigt__p_wxDateTime,
33173 _swigt__p_wxPyDropSource,
33174 _swigt__p_unsigned_long,
33175 _swigt__p_wxLogBuffer,
33176 _swigt__p_wxKillError,
33177 _swigt__p_wxWindow,
33178 _swigt__p_wxString,
33179 _swigt__p_wxPyProcess,
33180 _swigt__p_wxBitmap,
33181 _swigt__unsigned_int,
33182 _swigt__p_unsigned_int,
33183 _swigt__p_wxConfig,
33184 _swigt__p_unsigned_char,
33185 _swigt__p_wxChar,
33186 _swigt__p_wxBusyInfo,
33187 _swigt__p_wxPyDropTarget,
33188 _swigt__p_wxPyTextDropTarget,
33189 _swigt__p_wxPyFileDropTarget,
33190 _swigt__p_wxProcessEvent,
33191 _swigt__p_wxPyLog,
33192 _swigt__p_wxLogNull,
33193 _swigt__p_wxColour,
33194 _swigt__p_wxPyTimer,
33195 _swigt__p_wxConfigPathChanger,
33196 _swigt__p_wxDateSpan,
33197 0
33198 };
33199
33200
33201 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33202
33203 static swig_const_info swig_const_table[] = {
33204 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33205 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33206 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33207 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33208 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33209 {0, 0, 0, 0.0, 0, 0}};
33210
33211 #ifdef __cplusplus
33212 }
33213 #endif
33214
33215
33216 #ifdef __cplusplus
33217 extern "C" {
33218 #endif
33219
33220 /* Python-specific SWIG API */
33221 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33222 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33223 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33224
33225 /* -----------------------------------------------------------------------------
33226 * global variable support code.
33227 * ----------------------------------------------------------------------------- */
33228
33229 typedef struct swig_globalvar {
33230 char *name; /* Name of global variable */
33231 PyObject *(*get_attr)(); /* Return the current value */
33232 int (*set_attr)(PyObject *); /* Set the value */
33233 struct swig_globalvar *next;
33234 } swig_globalvar;
33235
33236 typedef struct swig_varlinkobject {
33237 PyObject_HEAD
33238 swig_globalvar *vars;
33239 } swig_varlinkobject;
33240
33241 static PyObject *
33242 swig_varlink_repr(swig_varlinkobject *v) {
33243 v = v;
33244 return PyString_FromString("<Swig global variables>");
33245 }
33246
33247 static int
33248 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33249 swig_globalvar *var;
33250 flags = flags;
33251 fprintf(fp,"Swig global variables { ");
33252 for (var = v->vars; var; var=var->next) {
33253 fprintf(fp,"%s", var->name);
33254 if (var->next) fprintf(fp,", ");
33255 }
33256 fprintf(fp," }\n");
33257 return 0;
33258 }
33259
33260 static PyObject *
33261 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33262 swig_globalvar *var = v->vars;
33263 while (var) {
33264 if (strcmp(var->name,n) == 0) {
33265 return (*var->get_attr)();
33266 }
33267 var = var->next;
33268 }
33269 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33270 return NULL;
33271 }
33272
33273 static int
33274 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33275 swig_globalvar *var = v->vars;
33276 while (var) {
33277 if (strcmp(var->name,n) == 0) {
33278 return (*var->set_attr)(p);
33279 }
33280 var = var->next;
33281 }
33282 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33283 return 1;
33284 }
33285
33286 static PyTypeObject varlinktype = {
33287 PyObject_HEAD_INIT(0)
33288 0, /* Number of items in variable part (ob_size) */
33289 (char *)"swigvarlink", /* Type name (tp_name) */
33290 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33291 0, /* Itemsize (tp_itemsize) */
33292 0, /* Deallocator (tp_dealloc) */
33293 (printfunc) swig_varlink_print, /* Print (tp_print) */
33294 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33295 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33296 0, /* tp_compare */
33297 (reprfunc) swig_varlink_repr, /* tp_repr */
33298 0, /* tp_as_number */
33299 0, /* tp_as_sequence */
33300 0, /* tp_as_mapping */
33301 0, /* tp_hash */
33302 0, /* tp_call */
33303 0, /* tp_str */
33304 0, /* tp_getattro */
33305 0, /* tp_setattro */
33306 0, /* tp_as_buffer */
33307 0, /* tp_flags */
33308 0, /* tp_doc */
33309 #if PY_VERSION_HEX >= 0x02000000
33310 0, /* tp_traverse */
33311 0, /* tp_clear */
33312 #endif
33313 #if PY_VERSION_HEX >= 0x02010000
33314 0, /* tp_richcompare */
33315 0, /* tp_weaklistoffset */
33316 #endif
33317 #if PY_VERSION_HEX >= 0x02020000
33318 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33319 #endif
33320 #if PY_VERSION_HEX >= 0x02030000
33321 0, /* tp_del */
33322 #endif
33323 #ifdef COUNT_ALLOCS
33324 0,0,0,0 /* tp_alloc -> tp_next */
33325 #endif
33326 };
33327
33328 /* Create a variable linking object for use later */
33329 static PyObject *
33330 SWIG_Python_newvarlink(void) {
33331 swig_varlinkobject *result = 0;
33332 result = PyMem_NEW(swig_varlinkobject,1);
33333 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33334 result->ob_type = &varlinktype;
33335 result->vars = 0;
33336 result->ob_refcnt = 0;
33337 Py_XINCREF((PyObject *) result);
33338 return ((PyObject*) result);
33339 }
33340
33341 static void
33342 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33343 swig_varlinkobject *v;
33344 swig_globalvar *gv;
33345 v= (swig_varlinkobject *) p;
33346 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33347 gv->name = (char *) malloc(strlen(name)+1);
33348 strcpy(gv->name,name);
33349 gv->get_attr = get_attr;
33350 gv->set_attr = set_attr;
33351 gv->next = v->vars;
33352 v->vars = gv;
33353 }
33354
33355 /* -----------------------------------------------------------------------------
33356 * constants/methods manipulation
33357 * ----------------------------------------------------------------------------- */
33358
33359 /* Install Constants */
33360 static void
33361 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33362 PyObject *obj = 0;
33363 size_t i;
33364 for (i = 0; constants[i].type; i++) {
33365 switch(constants[i].type) {
33366 case SWIG_PY_INT:
33367 obj = PyInt_FromLong(constants[i].lvalue);
33368 break;
33369 case SWIG_PY_FLOAT:
33370 obj = PyFloat_FromDouble(constants[i].dvalue);
33371 break;
33372 case SWIG_PY_STRING:
33373 if (constants[i].pvalue) {
33374 obj = PyString_FromString((char *) constants[i].pvalue);
33375 } else {
33376 Py_INCREF(Py_None);
33377 obj = Py_None;
33378 }
33379 break;
33380 case SWIG_PY_POINTER:
33381 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33382 break;
33383 case SWIG_PY_BINARY:
33384 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33385 break;
33386 default:
33387 obj = 0;
33388 break;
33389 }
33390 if (obj) {
33391 PyDict_SetItemString(d,constants[i].name,obj);
33392 Py_DECREF(obj);
33393 }
33394 }
33395 }
33396
33397 /* -----------------------------------------------------------------------------*/
33398 /* Fix SwigMethods to carry the callback ptrs when needed */
33399 /* -----------------------------------------------------------------------------*/
33400
33401 static void
33402 SWIG_Python_FixMethods(PyMethodDef *methods,
33403 swig_const_info *const_table,
33404 swig_type_info **types,
33405 swig_type_info **types_initial) {
33406 size_t i;
33407 for (i = 0; methods[i].ml_name; ++i) {
33408 char *c = methods[i].ml_doc;
33409 if (c && (c = strstr(c, "swig_ptr: "))) {
33410 int j;
33411 swig_const_info *ci = 0;
33412 char *name = c + 10;
33413 for (j = 0; const_table[j].type; j++) {
33414 if (strncmp(const_table[j].name, name,
33415 strlen(const_table[j].name)) == 0) {
33416 ci = &(const_table[j]);
33417 break;
33418 }
33419 }
33420 if (ci) {
33421 size_t shift = (ci->ptype) - types;
33422 swig_type_info *ty = types_initial[shift];
33423 size_t ldoc = (c - methods[i].ml_doc);
33424 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33425 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33426 char *buff = ndoc;
33427 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33428 strncpy(buff, methods[i].ml_doc, ldoc);
33429 buff += ldoc;
33430 strncpy(buff, "swig_ptr: ", 10);
33431 buff += 10;
33432 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33433 methods[i].ml_doc = ndoc;
33434 }
33435 }
33436 }
33437 }
33438
33439 /* -----------------------------------------------------------------------------*
33440 * Initialize type list
33441 * -----------------------------------------------------------------------------*/
33442
33443 #if PY_MAJOR_VERSION < 2
33444 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33445 is copied out of Python/modsupport.c in python version 2.3.4 */
33446 static int
33447 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33448 {
33449 PyObject *dict;
33450 if (!PyModule_Check(m)) {
33451 PyErr_SetString(PyExc_TypeError,
33452 "PyModule_AddObject() needs module as first arg");
33453 return -1;
33454 }
33455 if (!o) {
33456 PyErr_SetString(PyExc_TypeError,
33457 "PyModule_AddObject() needs non-NULL value");
33458 return -1;
33459 }
33460
33461 dict = PyModule_GetDict(m);
33462 if (dict == NULL) {
33463 /* Internal error -- modules must have a dict! */
33464 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33465 PyModule_GetName(m));
33466 return -1;
33467 }
33468 if (PyDict_SetItemString(dict, name, o))
33469 return -1;
33470 Py_DECREF(o);
33471 return 0;
33472 }
33473 #endif
33474
33475 static swig_type_info **
33476 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33477 static PyMethodDef swig_empty_runtime_method_table[] = {
33478 {
33479 NULL, NULL, 0, NULL
33480 }
33481 };/* Sentinel */
33482
33483 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33484 swig_empty_runtime_method_table);
33485 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33486 if (pointer && module) {
33487 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33488 }
33489 return type_list_handle;
33490 }
33491
33492 static swig_type_info **
33493 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33494 swig_type_info **type_pointer;
33495
33496 /* first check if module already created */
33497 type_pointer = SWIG_Python_GetTypeListHandle();
33498 if (type_pointer) {
33499 return type_pointer;
33500 } else {
33501 /* create a new module and variable */
33502 return SWIG_Python_SetTypeListHandle(type_list_handle);
33503 }
33504 }
33505
33506 #ifdef __cplusplus
33507 }
33508 #endif
33509
33510 /* -----------------------------------------------------------------------------*
33511 * Partial Init method
33512 * -----------------------------------------------------------------------------*/
33513
33514 #ifdef SWIG_LINK_RUNTIME
33515 #ifdef __cplusplus
33516 extern "C"
33517 #endif
33518 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33519 #endif
33520
33521 #ifdef __cplusplus
33522 extern "C"
33523 #endif
33524 SWIGEXPORT(void) SWIG_init(void) {
33525 static PyObject *SWIG_globals = 0;
33526 static int typeinit = 0;
33527 PyObject *m, *d;
33528 int i;
33529 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33530
33531 /* Fix SwigMethods to carry the callback ptrs when needed */
33532 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33533
33534 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33535 d = PyModule_GetDict(m);
33536
33537 if (!typeinit) {
33538 #ifdef SWIG_LINK_RUNTIME
33539 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33540 #else
33541 # ifndef SWIG_STATIC_RUNTIME
33542 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33543 # endif
33544 #endif
33545 for (i = 0; swig_types_initial[i]; i++) {
33546 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33547 }
33548 typeinit = 1;
33549 }
33550 SWIG_InstallConstants(d,swig_const_table);
33551
33552 {
33553 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33722 }
33723 {
33724 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33782 }
33783 {
33784 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33824 }
33825 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33826 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33827 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33828 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33829 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33830 {
33831 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33841 }
33842 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33843
33844 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33845
33846 {
33847 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33878 }
33879 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33880 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33881 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33882 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33883 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33884 {
33885 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33886 }
33887 {
33888 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33892 }
33893 {
33894 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33895 }
33896 {
33897 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33898 }
33899 {
33900 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33901 }
33902 {
33903 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33904 }
33905 {
33906 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33907 }
33908 {
33909 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33910 }
33911 {
33912 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33913 }
33914 {
33915 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33916 }
33917 {
33918 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33919 }
33920 {
33921 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33937 }
33938 {
33939 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33940 }
33941 {
33942 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33943 }
33944 {
33945 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33946 }
33947 {
33948 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33949 }
33950 {
33951 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33976 }
33977 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33978 {
33979 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33980 }
33981 {
33982 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33992 }
33993
33994 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33995
33996 {
33997 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
34016 }
34017 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
34018 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
34019 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
34020 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
34021 {
34022 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
34044 }
34045 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
34046 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
34047 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
34048 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
34049 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
34050 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
34051 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
34052 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
34053 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
34054 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
34055 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
34056 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
34057 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
34058 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
34059 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
34060 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
34061 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
34062 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
34063 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
34064 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
34065 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
34066 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
34067 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
34068 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
34069 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
34070 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
34071 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
34072 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
34073 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
34074 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
34075 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
34076 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
34077 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
34078 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
34079 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
34080 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
34081 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
34082 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
34083 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
34084 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
34085 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
34086 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
34087 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
34088 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
34089 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
34090 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
34091 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
34092 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
34093 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
34094 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
34095 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
34096 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
34097 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
34098 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
34099 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
34100 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
34101 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
34102
34103 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
34104
34105 {
34106 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
34131 }
34132 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
34133 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
34134 {
34135 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34205 }
34206 {
34207 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34208 }
34209 {
34210 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34211 }
34212 {
34213 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34214 }
34215 {
34216 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34217 }
34218 {
34219 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34220 }
34221 {
34222 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34223 }
34224 {
34225 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34226 }
34227 {
34228 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34229 }
34230 {
34231 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34232 }
34233 {
34234 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34235 }
34236 {
34237 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34238 }
34239 {
34240 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34241 }
34242 {
34243 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34244 }
34245 {
34246 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34247 }
34248 {
34249 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34283 }
34284 {
34285 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34286 }
34287 {
34288 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34343 }
34344 {
34345 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34358 }
34359 {
34360 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34364 }
34365 {
34366 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34367 }
34368 {
34369 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34370 }
34371 {
34372 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34373 }
34374 {
34375 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34376 }
34377 {
34378 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34379 }
34380 {
34381 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34382 }
34383 {
34384 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34385 }
34386 {
34387 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34394 }
34395 {
34396 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34397 }
34398 {
34399 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34400 }
34401 {
34402 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34403 }
34404 {
34405 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34406 }
34407 {
34408 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34409 }
34410 {
34411 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34412 }
34413 {
34414 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34415 }
34416 {
34417 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34418 }
34419 {
34420 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34421 }
34422 {
34423 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34424 }
34425 {
34426 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34439 }
34440 {
34441 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34442 }
34443 {
34444 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34445 }
34446 {
34447 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34448 }
34449 {
34450 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34451 }
34452 {
34453 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34454 }
34455 {
34456 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34457 }
34458 {
34459 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34460 }
34461 {
34462 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34463 }
34464 {
34465 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34466 }
34467 {
34468 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34469 }
34470 {
34471 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34472 }
34473 {
34474 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34475 }
34476 {
34477 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34478 }
34479 {
34480 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34481 }
34482 {
34483 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34484 }
34485 {
34486 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34487 }
34488 {
34489 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34490 }
34491 {
34492 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34493 }
34494 {
34495 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34496 }
34497 {
34498 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34499 }
34500 {
34501 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34502 }
34503 {
34504 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34505 }
34506 {
34507 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34508 }
34509 {
34510 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34511 }
34512 {
34513 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34514 }
34515 {
34516 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34517 }
34518 {
34519 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34520 }
34521 {
34522 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34523 }
34524 {
34525 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34526 }
34527 {
34528 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34529 }
34530 {
34531 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34532 }
34533 {
34534 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34535 }
34536 {
34537 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34538 }
34539 {
34540 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34541 }
34542 {
34543 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34544 }
34545 {
34546 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34547 }
34548 {
34549 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34550 }
34551 {
34552 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34553 }
34554 {
34555 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34556 }
34557 {
34558 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34559 }
34560 {
34561 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34562 }
34563 {
34564 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34565 }
34566 {
34567 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34568 }
34569 {
34570 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34571 }
34572 {
34573 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34574 }
34575 {
34576 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34577 }
34578 {
34579 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34580 }
34581 {
34582 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34583 }
34584 {
34585 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34586 }
34587 {
34588 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34589 }
34590 {
34591 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34592 }
34593 {
34594 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34595 }
34596 {
34597 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34598 }
34599 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34600 {
34601 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34602 }
34603 {
34604 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34605 }
34606 {
34607 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34608 }
34609 {
34610 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34611 }
34612 {
34613 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34614 }
34615 {
34616 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34617 }
34618 {
34619 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34620 }
34621 {
34622 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34623 }
34624 {
34625 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34626 }
34627 {
34628 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34629 }
34630 {
34631 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34632 }
34633 {
34634 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34635 }
34636 {
34637 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34638 }
34639 {
34640 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34641 }
34642 {
34643 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34644 }
34645 {
34646 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34647 }
34648 {
34649 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34650 }
34651 {
34652 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34653 }
34654 {
34655 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34656 }
34657 {
34658 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34659 }
34660 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34661 {
34662 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34663 }
34664 {
34665 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34666 }
34667 {
34668 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34669 }
34670 {
34671 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34672 }
34673 {
34674 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34675 }
34676 {
34677 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34678 }
34679 {
34680 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34681 }
34682 {
34683 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34684 }
34685 {
34686 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34687 }
34688 {
34689 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34690 }
34691 {
34692 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34693 }
34694 {
34695 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34696 }
34697
34698 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34699 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34700 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34701 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34702
34703 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34704 }
34705
wxWidgets (Impactor)