]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Check wxMSWUniv condition earlier.
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxClipboardLocker swig_types[21]
1363 #define SWIGTYPE_p_wxIcon swig_types[22]
1364 #define SWIGTYPE_p_wxLogStderr swig_types[23]
1365 #define SWIGTYPE_p_wxLogTextCtrl swig_types[24]
1366 #define SWIGTYPE_p_wxTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxBusyCursor swig_types[26]
1368 #define SWIGTYPE_p_wxBitmapDataObject swig_types[27]
1369 #define SWIGTYPE_p_wxTextDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxPyTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxFileDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxURLDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxMetafileDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxSound swig_types[36]
1378 #define SWIGTYPE_p_wxTimerRunner swig_types[37]
1379 #define SWIGTYPE_p_wxLogWindow swig_types[38]
1380 #define SWIGTYPE_p_wxTimeSpan swig_types[39]
1381 #define SWIGTYPE_p_wxArrayString swig_types[40]
1382 #define SWIGTYPE_p_wxWindowDisabler swig_types[41]
1383 #define SWIGTYPE_p_form_ops_t swig_types[42]
1384 #define SWIGTYPE_p_wxToolTip swig_types[43]
1385 #define SWIGTYPE_p_wxDataObjectComposite swig_types[44]
1386 #define SWIGTYPE_p_wxFileConfig swig_types[45]
1387 #define SWIGTYPE_p_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxVideoMode swig_types[47]
1389 #define SWIGTYPE_p_wxDataObjectSimple swig_types[48]
1390 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxDuplexMode swig_types[50]
1392 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
1393 #define SWIGTYPE_p_wxRect swig_types[52]
1394 #define SWIGTYPE_p_char swig_types[53]
1395 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[54]
1396 #define SWIGTYPE_p_wxStandardPaths swig_types[55]
1397 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
1398 #define SWIGTYPE_p_wxFrame swig_types[57]
1399 #define SWIGTYPE_p_wxTimer swig_types[58]
1400 #define SWIGTYPE_p_wxPaperSize swig_types[59]
1401 #define SWIGTYPE_p_wxMimeTypesManager swig_types[60]
1402 #define SWIGTYPE_p_wxPyArtProvider swig_types[61]
1403 #define SWIGTYPE_p_wxPyTipProvider swig_types[62]
1404 #define SWIGTYPE_p_wxTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxJoystick swig_types[64]
1406 #define SWIGTYPE_p_wxSystemOptions swig_types[65]
1407 #define SWIGTYPE_p_wxPoint swig_types[66]
1408 #define SWIGTYPE_p_wxJoystickEvent swig_types[67]
1409 #define SWIGTYPE_p_wxCursor swig_types[68]
1410 #define SWIGTYPE_p_wxObject swig_types[69]
1411 #define SWIGTYPE_p_wxOutputStream swig_types[70]
1412 #define SWIGTYPE_p_wxDateTime swig_types[71]
1413 #define SWIGTYPE_p_wxPyDropSource swig_types[72]
1414 #define SWIGTYPE_p_unsigned_long swig_types[73]
1415 #define SWIGTYPE_p_wxKillError swig_types[74]
1416 #define SWIGTYPE_p_wxWindow swig_types[75]
1417 #define SWIGTYPE_p_wxString swig_types[76]
1418 #define SWIGTYPE_p_wxPyProcess swig_types[77]
1419 #define SWIGTYPE_p_wxBitmap swig_types[78]
1420 #define SWIGTYPE_p_wxConfig swig_types[79]
1421 #define SWIGTYPE_unsigned_int swig_types[80]
1422 #define SWIGTYPE_p_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_char swig_types[82]
1424 #define SWIGTYPE_p_wxChar swig_types[83]
1425 #define SWIGTYPE_p_wxBusyInfo swig_types[84]
1426 #define SWIGTYPE_p_wxPyDropTarget swig_types[85]
1427 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxProcessEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPyLog swig_types[89]
1431 #define SWIGTYPE_p_wxLogNull swig_types[90]
1432 #define SWIGTYPE_p_wxColour swig_types[91]
1433 #define SWIGTYPE_p_wxPyTimer swig_types[92]
1434 #define SWIGTYPE_p_wxConfigPathChanger swig_types[93]
1435 #define SWIGTYPE_p_wxDateSpan swig_types[94]
1436 static swig_type_info *swig_types[96];
1437
1438 /* -------- TYPES TABLE (END) -------- */
1439
1440
1441 /*-----------------------------------------------
1442 @(target):= _misc_.so
1443 ------------------------------------------------*/
1444 #define SWIG_init init_misc_
1445
1446 #define SWIG_name "_misc_"
1447
1448 #include "wx/wxPython/wxPython.h"
1449 #include "wx/wxPython/pyclasses.h"
1450 #include "wx/wxPython/pyistream.h"
1451
1452 static const wxString wxPyEmptyString(wxEmptyString);
1453
1454
1455
1456 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1457 #define SWIG_From_int PyInt_FromLong
1458 /*@@*/
1459
1460
1461 #include <limits.h>
1462
1463
1464 SWIGINTERN int
1465 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1466 const char *errmsg)
1467 {
1468 if (value < min_value) {
1469 if (errmsg) {
1470 PyErr_Format(PyExc_OverflowError,
1471 "value %ld is less than '%s' minimum %ld",
1472 value, errmsg, min_value);
1473 }
1474 return 0;
1475 } else if (value > max_value) {
1476 if (errmsg) {
1477 PyErr_Format(PyExc_OverflowError,
1478 "value %ld is greater than '%s' maximum %ld",
1479 value, errmsg, max_value);
1480 }
1481 return 0;
1482 }
1483 return 1;
1484 }
1485
1486
1487 SWIGINTERN int
1488 SWIG_AsVal_long(PyObject* obj, long* val)
1489 {
1490 if (PyNumber_Check(obj)) {
1491 if (val) *val = PyInt_AsLong(obj);
1492 return 1;
1493 }
1494 else {
1495 SWIG_type_error("number", obj);
1496 }
1497 return 0;
1498 }
1499
1500
1501 #if INT_MAX != LONG_MAX
1502 SWIGINTERN int
1503 SWIG_AsVal_int(PyObject *obj, int *val)
1504 {
1505 const char* errmsg = val ? "int" : (char*)0;
1506 long v;
1507 if (SWIG_AsVal_long(obj, &v)) {
1508 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1509 if (val) *val = (int)(v);
1510 return 1;
1511 } else {
1512 return 0;
1513 }
1514 } else {
1515 PyErr_Clear();
1516 }
1517 if (val) {
1518 SWIG_type_error(errmsg, obj);
1519 }
1520 return 0;
1521 }
1522 #else
1523 SWIGINTERNSHORT int
1524 SWIG_AsVal_int(PyObject *obj, int *val)
1525 {
1526 return SWIG_AsVal_long(obj,(long*)val);
1527 }
1528 #endif
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_As_int(PyObject* obj)
1533 {
1534 int v;
1535 if (!SWIG_AsVal_int(obj, &v)) {
1536 /*
1537 this is needed to make valgrind/purify happier.
1538 */
1539 memset((void*)&v, 0, sizeof(int));
1540 }
1541 return v;
1542 }
1543
1544
1545 SWIGINTERNSHORT int
1546 SWIG_Check_int(PyObject* obj)
1547 {
1548 return SWIG_AsVal_int(obj, (int*)0);
1549 }
1550
1551 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1552
1553 #include <wx/stockitem.h>
1554
1555 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1556 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1557 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1558
1559 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1560 #define SWIG_From_long PyInt_FromLong
1561 /*@@*/
1562
1563
1564 SWIGINTERNSHORT long
1565 SWIG_As_long(PyObject* obj)
1566 {
1567 long v;
1568 if (!SWIG_AsVal_long(obj, &v)) {
1569 /*
1570 this is needed to make valgrind/purify happier.
1571 */
1572 memset((void*)&v, 0, sizeof(long));
1573 }
1574 return v;
1575 }
1576
1577
1578 SWIGINTERNSHORT int
1579 SWIG_Check_long(PyObject* obj)
1580 {
1581 return SWIG_AsVal_long(obj, (long*)0);
1582 }
1583
1584
1585 SWIGINTERN int
1586 SWIG_AsVal_bool(PyObject *obj, bool *val)
1587 {
1588 if (obj == Py_True) {
1589 if (val) *val = true;
1590 return 1;
1591 }
1592 if (obj == Py_False) {
1593 if (val) *val = false;
1594 return 1;
1595 }
1596 int res = 0;
1597 if (SWIG_AsVal_int(obj, &res)) {
1598 if (val) *val = res ? true : false;
1599 return 1;
1600 } else {
1601 PyErr_Clear();
1602 }
1603 if (val) {
1604 SWIG_type_error("bool", obj);
1605 }
1606 return 0;
1607 }
1608
1609
1610 SWIGINTERNSHORT bool
1611 SWIG_As_bool(PyObject* obj)
1612 {
1613 bool v;
1614 if (!SWIG_AsVal_bool(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(bool));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_bool(PyObject* obj)
1626 {
1627 return SWIG_AsVal_bool(obj, (bool*)0);
1628 }
1629
1630
1631 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1632 PyObject* o2;
1633 PyObject* o3;
1634
1635 if (!target) {
1636 target = o;
1637 } else if (target == Py_None) {
1638 Py_DECREF(Py_None);
1639 target = o;
1640 } else {
1641 if (!PyTuple_Check(target)) {
1642 o2 = target;
1643 target = PyTuple_New(1);
1644 PyTuple_SetItem(target, 0, o2);
1645 }
1646 o3 = PyTuple_New(1);
1647 PyTuple_SetItem(o3, 0, o);
1648
1649 o2 = target;
1650 target = PySequence_Concat(o2, o3);
1651 Py_DECREF(o2);
1652 Py_DECREF(o3);
1653 }
1654 return target;
1655 }
1656
1657
1658
1659 long wxGetFreeMemory()
1660 { wxPyRaiseNotImplemented(); return 0; }
1661
1662
1663 SWIGINTERN int
1664 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1665 {
1666 long v = 0;
1667 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1668 SWIG_type_error("unsigned number", obj);
1669 }
1670 else if (val)
1671 *val = (unsigned long)v;
1672 return 1;
1673 }
1674
1675
1676 SWIGINTERNSHORT unsigned long
1677 SWIG_As_unsigned_SS_long(PyObject* obj)
1678 {
1679 unsigned long v;
1680 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1681 /*
1682 this is needed to make valgrind/purify happier.
1683 */
1684 memset((void*)&v, 0, sizeof(unsigned long));
1685 }
1686 return v;
1687 }
1688
1689
1690 SWIGINTERNSHORT int
1691 SWIG_Check_unsigned_SS_long(PyObject* obj)
1692 {
1693 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1694 }
1695
1696
1697 SWIGINTERNSHORT PyObject*
1698 SWIG_From_unsigned_SS_long(unsigned long value)
1699 {
1700 return (value > LONG_MAX) ?
1701 PyLong_FromUnsignedLong(value)
1702 : PyInt_FromLong((long)(value));
1703 }
1704
1705
1706 void wxWakeUpMainThread() {}
1707
1708
1709 bool wxThread_IsMain() {
1710 #ifdef WXP_WITH_THREAD
1711 return wxThread::IsMain();
1712 #else
1713 return true;
1714 #endif
1715 }
1716
1717
1718 int wxCaret_GetBlinkTime() {
1719 return wxCaret::GetBlinkTime();
1720 }
1721
1722 void wxCaret_SetBlinkTime(int milliseconds) {
1723 wxCaret::SetBlinkTime(milliseconds);
1724 }
1725
1726
1727 #include <wx/snglinst.h>
1728
1729
1730 #include <wx/tipdlg.h>
1731
1732
1733 class wxPyTipProvider : public wxTipProvider {
1734 public:
1735 wxPyTipProvider(size_t currentTip)
1736 : wxTipProvider(currentTip) {}
1737
1738 DEC_PYCALLBACK_STRING__pure(GetTip);
1739 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1740 PYPRIVATE;
1741 };
1742
1743 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1744 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1745
1746
1747 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1748
1749 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1750
1751 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1752 : wxTimer(owner, id)
1753 {
1754 if (owner == NULL) SetOwner(this);
1755 }
1756
1757
1758 void wxPyTimer::Notify() {
1759 bool found;
1760 bool blocked = wxPyBeginBlockThreads();
1761 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1762 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1763 wxPyEndBlockThreads(blocked);
1764 if (! found)
1765 wxTimer::Notify();
1766 }
1767 void wxPyTimer::base_Notify() {
1768 wxTimer::Notify();
1769 }
1770
1771
1772
1773 SWIGINTERN PyObject *
1774 SWIG_FromCharPtr(const char* cptr)
1775 {
1776 if (cptr) {
1777 size_t size = strlen(cptr);
1778 if (size > INT_MAX) {
1779 return SWIG_NewPointerObj((char*)(cptr),
1780 SWIG_TypeQuery("char *"), 0);
1781 } else {
1782 if (size != 0) {
1783 return PyString_FromStringAndSize(cptr, size);
1784 } else {
1785 return PyString_FromString(cptr);
1786 }
1787 }
1788 }
1789 Py_INCREF(Py_None);
1790 return Py_None;
1791 }
1792
1793
1794 SWIGINTERNSHORT int
1795 SWIG_CheckUnsignedLongInRange(unsigned long value,
1796 unsigned long max_value,
1797 const char *errmsg)
1798 {
1799 if (value > max_value) {
1800 if (errmsg) {
1801 PyErr_Format(PyExc_OverflowError,
1802 "value %lu is greater than '%s' minimum %lu",
1803 value, errmsg, max_value);
1804 }
1805 return 0;
1806 }
1807 return 1;
1808 }
1809
1810
1811 #if UINT_MAX != ULONG_MAX
1812 SWIGINTERN int
1813 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1814 {
1815 const char* errmsg = val ? "unsigned int" : (char*)0;
1816 unsigned long v;
1817 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1818 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1819 if (val) *val = (unsigned int)(v);
1820 return 1;
1821 }
1822 } else {
1823 PyErr_Clear();
1824 }
1825 if (val) {
1826 SWIG_type_error(errmsg, obj);
1827 }
1828 return 0;
1829 }
1830 #else
1831 SWIGINTERNSHORT unsigned int
1832 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1833 {
1834 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1835 }
1836 #endif
1837
1838
1839 SWIGINTERNSHORT unsigned int
1840 SWIG_As_unsigned_SS_int(PyObject* obj)
1841 {
1842 unsigned int v;
1843 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1844 /*
1845 this is needed to make valgrind/purify happier.
1846 */
1847 memset((void*)&v, 0, sizeof(unsigned int));
1848 }
1849 return v;
1850 }
1851
1852
1853 SWIGINTERNSHORT int
1854 SWIG_Check_unsigned_SS_int(PyObject* obj)
1855 {
1856 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1857 }
1858
1859 static wxString Log_TimeStamp(){
1860 wxString msg;
1861 wxLog::TimeStamp(&msg);
1862 return msg;
1863 }
1864 static void wxLog_Destroy(wxLog *self){ delete self; }
1865 // Make somce wrappers that double any % signs so they are 'escaped'
1866 void wxPyLogFatalError(const wxString& msg)
1867 {
1868 wxString m(msg);
1869 m.Replace(wxT("%"), wxT("%%"));
1870 wxLogFatalError(m);
1871 }
1872
1873 void wxPyLogError(const wxString& msg)
1874 {
1875 wxString m(msg);
1876 m.Replace(wxT("%"), wxT("%%"));
1877 wxLogError(m);
1878 }
1879
1880 void wxPyLogWarning(const wxString& msg)
1881 {
1882 wxString m(msg);
1883 m.Replace(wxT("%"), wxT("%%"));
1884 wxLogWarning(m);
1885 }
1886
1887 void wxPyLogMessage(const wxString& msg)
1888 {
1889 wxString m(msg);
1890 m.Replace(wxT("%"), wxT("%%"));
1891 wxLogMessage(m);
1892 }
1893
1894 void wxPyLogInfo(const wxString& msg)
1895 {
1896 wxString m(msg);
1897 m.Replace(wxT("%"), wxT("%%"));
1898 wxLogInfo(m);
1899 }
1900
1901 void wxPyLogDebug(const wxString& msg)
1902 {
1903 wxString m(msg);
1904 m.Replace(wxT("%"), wxT("%%"));
1905 wxLogDebug(m);
1906 }
1907
1908 void wxPyLogVerbose(const wxString& msg)
1909 {
1910 wxString m(msg);
1911 m.Replace(wxT("%"), wxT("%%"));
1912 wxLogVerbose(m);
1913 }
1914
1915 void wxPyLogStatus(const wxString& msg)
1916 {
1917 wxString m(msg);
1918 m.Replace(wxT("%"), wxT("%%"));
1919 wxLogStatus(m);
1920 }
1921
1922 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1923 {
1924 wxString m(msg);
1925 m.Replace(wxT("%"), wxT("%%"));
1926 wxLogStatus(pFrame, m);
1927 }
1928
1929 void wxPyLogSysError(const wxString& msg)
1930 {
1931 wxString m(msg);
1932 m.Replace(wxT("%"), wxT("%%"));
1933 wxLogSysError(m);
1934 }
1935
1936 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1937 {
1938 wxString m(msg);
1939 m.Replace(wxT("%"), wxT("%%"));
1940 wxLogGeneric(level, m);
1941 }
1942
1943 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1944 {
1945 wxString m(msg);
1946 m.Replace(wxT("%"), wxT("%%"));
1947 wxLogTrace(mask, m);
1948 }
1949
1950 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogTrace(mask, m);
1955 }
1956
1957
1958
1959 // A wxLog class that can be derived from in wxPython
1960 class wxPyLog : public wxLog {
1961 public:
1962 wxPyLog() : wxLog() {}
1963
1964 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1965 bool found;
1966 bool blocked = wxPyBeginBlockThreads();
1967 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1968 PyObject* s = wx2PyString(szString);
1969 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1970 Py_DECREF(s);
1971 }
1972 wxPyEndBlockThreads(blocked);
1973 if (! found)
1974 wxLog::DoLog(level, szString, t);
1975 }
1976
1977 virtual void DoLogString(const wxChar *szString, time_t t) {
1978 bool found;
1979 bool blocked = wxPyBeginBlockThreads();
1980 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1981 PyObject* s = wx2PyString(szString);
1982 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1983 Py_DECREF(s);
1984 }
1985 wxPyEndBlockThreads(blocked);
1986 if (! found)
1987 wxLog::DoLogString(szString, t);
1988 }
1989
1990 PYPRIVATE;
1991 };
1992
1993
1994
1995
1996 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1997
1998
1999 #include <wx/joystick.h>
2000
2001
2002 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2003 // A C++ stub class for wxJoystick for platforms that don't have it.
2004 class wxJoystick : public wxObject {
2005 public:
2006 wxJoystick(int joystick = wxJOYSTICK1) {
2007 bool blocked = wxPyBeginBlockThreads();
2008 PyErr_SetString(PyExc_NotImplementedError,
2009 "wxJoystick is not available on this platform.");
2010 wxPyEndBlockThreads(blocked);
2011 }
2012 wxPoint GetPosition() { return wxPoint(-1,-1); }
2013 int GetZPosition() { return -1; }
2014 int GetButtonState() { return -1; }
2015 int GetPOVPosition() { return -1; }
2016 int GetPOVCTSPosition() { return -1; }
2017 int GetRudderPosition() { return -1; }
2018 int GetUPosition() { return -1; }
2019 int GetVPosition() { return -1; }
2020 int GetMovementThreshold() { return -1; }
2021 void SetMovementThreshold(int threshold) {}
2022
2023 bool IsOk(void) { return false; }
2024 int GetNumberJoysticks() { return -1; }
2025 int GetManufacturerId() { return -1; }
2026 int GetProductId() { return -1; }
2027 wxString GetProductName() { return wxEmptyString; }
2028 int GetXMin() { return -1; }
2029 int GetYMin() { return -1; }
2030 int GetZMin() { return -1; }
2031 int GetXMax() { return -1; }
2032 int GetYMax() { return -1; }
2033 int GetZMax() { return -1; }
2034 int GetNumberButtons() { return -1; }
2035 int GetNumberAxes() { return -1; }
2036 int GetMaxButtons() { return -1; }
2037 int GetMaxAxes() { return -1; }
2038 int GetPollingMin() { return -1; }
2039 int GetPollingMax() { return -1; }
2040 int GetRudderMin() { return -1; }
2041 int GetRudderMax() { return -1; }
2042 int GetUMin() { return -1; }
2043 int GetUMax() { return -1; }
2044 int GetVMin() { return -1; }
2045 int GetVMax() { return -1; }
2046
2047 bool HasRudder() { return false; }
2048 bool HasZ() { return false; }
2049 bool HasU() { return false; }
2050 bool HasV() { return false; }
2051 bool HasPOV() { return false; }
2052 bool HasPOV4Dir() { return false; }
2053 bool HasPOVCTS() { return false; }
2054
2055 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2056 bool ReleaseCapture() { return false; }
2057 };
2058 #endif
2059
2060
2061 #include <wx/sound.h>
2062
2063
2064 #if !wxUSE_SOUND
2065 // A C++ stub class for wxWave for platforms that don't have it.
2066 class wxSound : public wxObject
2067 {
2068 public:
2069 wxSound() {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075 wxSound(const wxString&/*, bool*/) {
2076 bool blocked = wxPyBeginBlockThreads();
2077 PyErr_SetString(PyExc_NotImplementedError,
2078 "wxSound is not available on this platform.");
2079 wxPyEndBlockThreads(blocked);
2080 }
2081 wxSound(int, const wxByte*) {
2082 bool blocked = wxPyBeginBlockThreads();
2083 PyErr_SetString(PyExc_NotImplementedError,
2084 "wxSound is not available on this platform.");
2085 wxPyEndBlockThreads(blocked);
2086 }
2087
2088 ~wxSound() {};
2089
2090 bool Create(const wxString&/*, bool*/) { return false; }
2091 bool Create(int, const wxByte*) { return false; };
2092 bool IsOk() { return false; };
2093 bool Play(unsigned) const { return false; }
2094 static bool Play(const wxString&, unsigned) { return false; }
2095 static void Stop() {}
2096 };
2097
2098 #endif
2099
2100 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2101 if (fileName.Length() == 0)
2102 return new wxSound;
2103 else
2104 return new wxSound(fileName);
2105 }
2106 static wxSound *new_wxSound(PyObject *data){
2107 unsigned char* buffer; int size;
2108 wxSound *sound = NULL;
2109
2110 bool blocked = wxPyBeginBlockThreads();
2111 if (!PyArg_Parse(data, "t#", &buffer, &size))
2112 goto done;
2113 sound = new wxSound(size, buffer);
2114 done:
2115 wxPyEndBlockThreads(blocked);
2116 return sound;
2117 }
2118 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2119 #ifndef __WXMAC__
2120 unsigned char* buffer;
2121 int size;
2122 bool rv = false;
2123
2124 bool blocked = wxPyBeginBlockThreads();
2125 if (!PyArg_Parse(data, "t#", &buffer, &size))
2126 goto done;
2127 rv = self->Create(size, buffer);
2128 done:
2129 wxPyEndBlockThreads(blocked);
2130 return rv;
2131 #else
2132 bool blocked = wxPyBeginBlockThreads();
2133 PyErr_SetString(PyExc_NotImplementedError,
2134 "Create from data is not available on this platform.");
2135 wxPyEndBlockThreads(blocked);
2136 return false;
2137 #endif
2138 }
2139
2140 #include <wx/mimetype.h>
2141
2142 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2143 wxString str;
2144 if (self->GetMimeType(&str))
2145 return wx2PyString(str);
2146 else
2147 RETURN_NONE();
2148 }
2149 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2150 wxArrayString arr;
2151 if (self->GetMimeTypes(arr))
2152 return wxArrayString2PyList_helper(arr);
2153 else
2154 RETURN_NONE();
2155 }
2156 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2157 wxArrayString arr;
2158 if (self->GetExtensions(arr))
2159 return wxArrayString2PyList_helper(arr);
2160 else
2161 RETURN_NONE();
2162 }
2163 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2164 wxIconLocation loc;
2165 if (self->GetIcon(&loc))
2166 return new wxIcon(loc);
2167 else
2168 return NULL;
2169 }
2170 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2171 wxIconLocation loc;
2172 if (self->GetIcon(&loc)) {
2173 wxString iconFile = loc.GetFileName();
2174 int iconIndex = -1;
2175
2176
2177
2178 // Make a tuple and put the values in it
2179 bool blocked = wxPyBeginBlockThreads();
2180 PyObject* tuple = PyTuple_New(3);
2181 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2182 wxT("wxIcon"), true));
2183 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2184 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2185 wxPyEndBlockThreads(blocked);
2186 return tuple;
2187 }
2188 else
2189 RETURN_NONE();
2190 }
2191 static PyObject *wxFileType_GetDescription(wxFileType *self){
2192 wxString str;
2193 if (self->GetDescription(&str))
2194 return wx2PyString(str);
2195 else
2196 RETURN_NONE();
2197 }
2198 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2199 wxString str;
2200 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2201 return wx2PyString(str);
2202 else
2203 RETURN_NONE();
2204 }
2205 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2206 wxString str;
2207 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2208 return wx2PyString(str);
2209 else
2210 RETURN_NONE();
2211 }
2212 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2213 wxArrayString verbs;
2214 wxArrayString commands;
2215 if (self->GetAllCommands(&verbs, &commands,
2216 wxFileType::MessageParameters(filename, mimetype))) {
2217 bool blocked = wxPyBeginBlockThreads();
2218 PyObject* tuple = PyTuple_New(2);
2219 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2220 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2221 wxPyEndBlockThreads(blocked);
2222 return tuple;
2223 }
2224 else
2225 RETURN_NONE();
2226 }
2227 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2228 return wxFileType::ExpandCommand(command,
2229 wxFileType::MessageParameters(filename, mimetype));
2230 }
2231 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2232 wxArrayString arr;
2233 self->EnumAllFileTypes(arr);
2234 return wxArrayString2PyList_helper(arr);
2235 }
2236
2237 #include <wx/artprov.h>
2238
2239 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2240 static const wxString wxPyART_MENU(wxART_MENU);
2241 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2242 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2243 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2244 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2245 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2246 static const wxString wxPyART_OTHER(wxART_OTHER);
2247 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2248 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2249 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2250 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2251 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2252 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2253 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2254 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2255 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2256 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2257 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2258 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2259 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2260 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2261 static const wxString wxPyART_PRINT(wxART_PRINT);
2262 static const wxString wxPyART_HELP(wxART_HELP);
2263 static const wxString wxPyART_TIP(wxART_TIP);
2264 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2265 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2266 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2267 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2268 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2269 static const wxString wxPyART_CDROM(wxART_CDROM);
2270 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2271 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2272 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2273 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2274 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2275 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2276 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2277 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2278 static const wxString wxPyART_ERROR(wxART_ERROR);
2279 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2280 static const wxString wxPyART_WARNING(wxART_WARNING);
2281 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2282 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2283 // Python aware wxArtProvider
2284 class wxPyArtProvider : public wxArtProvider {
2285 public:
2286
2287 virtual wxBitmap CreateBitmap(const wxArtID& id,
2288 const wxArtClient& client,
2289 const wxSize& size) {
2290 wxBitmap rval = wxNullBitmap;
2291 bool blocked = wxPyBeginBlockThreads();
2292 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2293 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2294 PyObject* ro;
2295 wxBitmap* ptr;
2296 PyObject* s1, *s2;
2297 s1 = wx2PyString(id);
2298 s2 = wx2PyString(client);
2299 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2300 Py_DECREF(so);
2301 Py_DECREF(s1);
2302 Py_DECREF(s2);
2303 if (ro) {
2304 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2305 rval = *ptr;
2306 Py_DECREF(ro);
2307 }
2308 }
2309 wxPyEndBlockThreads(blocked);
2310 return rval;
2311 }
2312
2313 PYPRIVATE;
2314 };
2315
2316 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2317
2318
2319
2320 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2321 PyObject* ret = PyTuple_New(3);
2322 if (ret) {
2323 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2324 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2325 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2326 }
2327 return ret;
2328 }
2329
2330 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2331 bool cont;
2332 long index = 0;
2333 wxString value;
2334
2335 cont = self->GetFirstGroup(value, index);
2336 return __EnumerationHelper(cont, value, index);
2337 }
2338 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2339 bool cont;
2340 wxString value;
2341
2342 cont = self->GetNextGroup(value, index);
2343 return __EnumerationHelper(cont, value, index);
2344 }
2345 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2346 bool cont;
2347 long index = 0;
2348 wxString value;
2349
2350 cont = self->GetFirstEntry(value, index);
2351 return __EnumerationHelper(cont, value, index);
2352 }
2353 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2354 bool cont;
2355 wxString value;
2356
2357 cont = self->GetNextEntry(value, index);
2358 return __EnumerationHelper(cont, value, index);
2359 }
2360 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2361 long rv;
2362 self->Read(key, &rv, defaultVal);
2363 return rv;
2364 }
2365
2366 SWIGINTERN int
2367 SWIG_AsVal_double(PyObject *obj, double* val)
2368 {
2369 if (PyNumber_Check(obj)) {
2370 if (val) *val = PyFloat_AsDouble(obj);
2371 return 1;
2372 }
2373 else {
2374 SWIG_type_error("number", obj);
2375 }
2376 return 0;
2377 }
2378
2379
2380 SWIGINTERNSHORT double
2381 SWIG_As_double(PyObject* obj)
2382 {
2383 double v;
2384 if (!SWIG_AsVal_double(obj, &v)) {
2385 /*
2386 this is needed to make valgrind/purify happier.
2387 */
2388 memset((void*)&v, 0, sizeof(double));
2389 }
2390 return v;
2391 }
2392
2393
2394 SWIGINTERNSHORT int
2395 SWIG_Check_double(PyObject* obj)
2396 {
2397 return SWIG_AsVal_double(obj, (double*)0);
2398 }
2399
2400 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2401 double rv;
2402 self->Read(key, &rv, defaultVal);
2403 return rv;
2404 }
2405
2406 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2407 #define SWIG_From_double PyFloat_FromDouble
2408 /*@@*/
2409
2410 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2411 bool rv;
2412 self->Read(key, &rv, defaultVal);
2413 return rv;
2414 }
2415
2416 #include <wx/datetime.h>
2417
2418
2419 static const wxString wxPyDateFormatStr(wxT("%c"));
2420 static const wxString wxPyTimeSpanFormatStr(wxT("%H:%M:%S"));
2421
2422 #define LOCAL_TZ wxDateTime::Local
2423
2424
2425 #if UINT_MAX < LONG_MAX
2426 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2427 #define SWIG_From_unsigned_SS_int SWIG_From_long
2428 /*@@*/
2429 #else
2430 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2431 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2432 /*@@*/
2433 #endif
2434
2435 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2436 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2437 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2438 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2439 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2440 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2441 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2442 return (*self < *other);
2443 }
2444 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2445 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2446 return (*self <= *other);
2447 }
2448 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2449 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2450 return (*self > *other);
2451 }
2452 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2453 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2454 return (*self >= *other);
2455 }
2456 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2457 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2458 return (*self == *other);
2459 }
2460 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2461 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2462 return (*self != *other);
2463 }
2464 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2465 const wxChar* rv;
2466 const wxChar* _date = date;
2467 rv = self->ParseRfc822Date(_date);
2468 if (rv == NULL) return -1;
2469 return rv - _date;
2470 }
2471 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDateFormatStr,wxDateTime const &dateDef=wxDefaultDateTime){
2472 const wxChar* rv;
2473 const wxChar* _date = date;
2474 rv = self->ParseFormat(_date, format, dateDef);
2475 if (rv == NULL) return -1;
2476 return rv - _date;
2477 }
2478 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2479 const wxChar* rv;
2480 const wxChar* _datetime = datetime;
2481 rv = self->ParseDateTime(_datetime);
2482 if (rv == NULL) return -1;
2483 return rv - _datetime;
2484 }
2485 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2486 const wxChar* rv;
2487 const wxChar* _date = date;
2488 rv = self->ParseDate(_date);
2489 if (rv == NULL) return -1;
2490 return rv - _date;
2491 }
2492 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2493 const wxChar* rv;
2494 const wxChar* _time = time;
2495 rv = self->ParseTime(_time);
2496 if (rv == NULL) return -1;
2497 return rv - _time;
2498 }
2499 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2500 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2501 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2502 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2503 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2504 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2505 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2506 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2507 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2508 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2509 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2510 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2511 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2512 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2513 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2514 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2515
2516 #include <wx/dataobj.h>
2517
2518 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2519 size_t count = self->GetFormatCount(dir);
2520 wxDataFormat* formats = new wxDataFormat[count];
2521 self->GetAllFormats(formats, dir);
2522
2523 bool blocked = wxPyBeginBlockThreads();
2524 PyObject* list = PyList_New(count);
2525 for (size_t i=0; i<count; i++) {
2526 wxDataFormat* format = new wxDataFormat(formats[i]);
2527 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2528 PyList_Append(list, obj);
2529 Py_DECREF(obj);
2530 }
2531 wxPyEndBlockThreads(blocked);
2532 delete [] formats;
2533 return list;
2534 }
2535 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2536 PyObject* rval = NULL;
2537 size_t size = self->GetDataSize(format);
2538 bool blocked = wxPyBeginBlockThreads();
2539 if (size) {
2540 char* buf = new char[size];
2541 if (self->GetDataHere(format, buf))
2542 rval = PyString_FromStringAndSize(buf, size);
2543 delete [] buf;
2544 }
2545 if (! rval) {
2546 rval = Py_None;
2547 Py_INCREF(rval);
2548 }
2549 wxPyEndBlockThreads(blocked);
2550 return rval;
2551 }
2552 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2553 bool rval;
2554 bool blocked = wxPyBeginBlockThreads();
2555 if (PyString_Check(data)) {
2556 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2557 }
2558 else {
2559 // raise a TypeError if not a string
2560 PyErr_SetString(PyExc_TypeError, "String expected.");
2561 rval = false;
2562 }
2563 wxPyEndBlockThreads(blocked);
2564 return rval;
2565 }
2566 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2567 PyObject* rval = NULL;
2568 size_t size = self->GetDataSize();
2569 bool blocked = wxPyBeginBlockThreads();
2570 if (size) {
2571 char* buf = new char[size];
2572 if (self->GetDataHere(buf))
2573 rval = PyString_FromStringAndSize(buf, size);
2574 delete [] buf;
2575 }
2576 if (! rval) {
2577 rval = Py_None;
2578 Py_INCREF(rval);
2579 }
2580 wxPyEndBlockThreads(blocked);
2581 return rval;
2582 }
2583 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2584 bool rval;
2585 bool blocked = wxPyBeginBlockThreads();
2586 if (PyString_Check(data)) {
2587 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2588 }
2589 else {
2590 // raise a TypeError if not a string
2591 PyErr_SetString(PyExc_TypeError, "String expected.");
2592 rval = false;
2593 }
2594 wxPyEndBlockThreads(blocked);
2595 return rval;
2596 }
2597 // Create a new class for wxPython to use
2598 class wxPyDataObjectSimple : public wxDataObjectSimple {
2599 public:
2600 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2601 : wxDataObjectSimple(format) {}
2602
2603 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2604 bool GetDataHere(void *buf) const;
2605 bool SetData(size_t len, const void *buf) const;
2606 PYPRIVATE;
2607 };
2608
2609 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2610
2611 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2612 // We need to get the data for this object and write it to buf. I think
2613 // the best way to do this for wxPython is to have the Python method
2614 // return either a string or None and then act appropriately with the
2615 // C++ version.
2616
2617 bool rval = false;
2618 bool blocked = wxPyBeginBlockThreads();
2619 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2620 PyObject* ro;
2621 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2622 if (ro) {
2623 rval = (ro != Py_None && PyString_Check(ro));
2624 if (rval)
2625 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2626 Py_DECREF(ro);
2627 }
2628 }
2629 wxPyEndBlockThreads(blocked);
2630 return rval;
2631 }
2632
2633 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2634 // For this one we simply need to make a string from buf and len
2635 // and send it to the Python method.
2636 bool rval = false;
2637 bool blocked = wxPyBeginBlockThreads();
2638 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2639 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2640 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2641 Py_DECREF(data);
2642 }
2643 wxPyEndBlockThreads(blocked);
2644 return rval;
2645 }
2646
2647 // Create a new class for wxPython to use
2648 class wxPyTextDataObject : public wxTextDataObject {
2649 public:
2650 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2651 : wxTextDataObject(text) {}
2652
2653 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2654 DEC_PYCALLBACK_STRING__const(GetText);
2655 DEC_PYCALLBACK__STRING(SetText);
2656 PYPRIVATE;
2657 };
2658
2659 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2660 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2661 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2662
2663
2664 // Create a new class for wxPython to use
2665 class wxPyBitmapDataObject : public wxBitmapDataObject {
2666 public:
2667 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2668 : wxBitmapDataObject(bitmap) {}
2669
2670 wxBitmap GetBitmap() const;
2671 void SetBitmap(const wxBitmap& bitmap);
2672 PYPRIVATE;
2673 };
2674
2675 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2676 wxBitmap* rval = &wxNullBitmap;
2677 bool blocked = wxPyBeginBlockThreads();
2678 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2679 PyObject* ro;
2680 wxBitmap* ptr;
2681 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2682 if (ro) {
2683 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2684 rval = ptr;
2685 Py_DECREF(ro);
2686 }
2687 }
2688 wxPyEndBlockThreads(blocked);
2689 return *rval;
2690 }
2691
2692 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2693 bool blocked = wxPyBeginBlockThreads();
2694 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2695 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2696 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2697 Py_DECREF(bo);
2698 }
2699 wxPyEndBlockThreads(blocked);
2700 }
2701
2702 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2703 bool rval;
2704 bool 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 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2717 PyObject* obj;
2718 bool blocked = wxPyBeginBlockThreads();
2719 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2720 wxPyEndBlockThreads(blocked);
2721 return obj;
2722 }
2723
2724 class wxMetafileDataObject : public wxDataObjectSimple
2725 {
2726 public:
2727 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2728 };
2729
2730
2731 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2732
2733
2734 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2735 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2736 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2737 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2738 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2739
2740
2741 class wxPyTextDropTarget : public wxTextDropTarget {
2742 public:
2743 wxPyTextDropTarget() {}
2744
2745 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2746
2747 DEC_PYCALLBACK__(OnLeave);
2748 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2749 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2750 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2751 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2752
2753 PYPRIVATE;
2754 };
2755
2756 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2757 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2758 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2759 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2760 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2761 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2762
2763
2764
2765 class wxPyFileDropTarget : public wxFileDropTarget {
2766 public:
2767 wxPyFileDropTarget() {}
2768
2769 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2770
2771 DEC_PYCALLBACK__(OnLeave);
2772 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2773 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2774 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2775 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2776
2777 PYPRIVATE;
2778 };
2779
2780 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2781 const wxArrayString& filenames) {
2782 bool rval = false;
2783 bool blocked = wxPyBeginBlockThreads();
2784 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2785 PyObject* list = wxArrayString2PyList_helper(filenames);
2786 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2787 Py_DECREF(list);
2788 }
2789 wxPyEndBlockThreads(blocked);
2790 return rval;
2791 }
2792
2793
2794
2795 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2796 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2797 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2798 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2799 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2800
2801
2802
2803
2804 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2805
2806 #include <wx/display.h>
2807
2808 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2809 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2810
2811 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2812 #if !wxUSE_DISPLAY
2813 #include <wx/dynarray.h>
2814 #include <wx/vidmode.h>
2815
2816 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2817 #include "wx/arrimpl.cpp"
2818 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2819 const wxVideoMode wxDefaultVideoMode;
2820
2821 class wxDisplay
2822 {
2823 public:
2824 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2825 ~wxDisplay() {}
2826
2827 static size_t GetCount()
2828 { wxPyRaiseNotImplemented(); return 0; }
2829
2830 static int GetFromPoint(const wxPoint& pt)
2831 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2832 static int GetFromWindow(wxWindow *window)
2833 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2834
2835 virtual bool IsOk() const { return false; }
2836 virtual wxRect GetGeometry() const { wxRect r; return r; }
2837 virtual wxString GetName() const { return wxEmptyString; }
2838 bool IsPrimary() const { return false; }
2839
2840 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2841 { wxArrayVideoModes a; return a; }
2842
2843 virtual wxVideoMode GetCurrentMode() const
2844 { return wxDefaultVideoMode; }
2845
2846 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2847 { return false; }
2848
2849 void ResetMode() {}
2850 };
2851 #endif
2852
2853 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2854 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2855 PyObject* pyList = NULL;
2856 wxArrayVideoModes arr = self->GetModes(mode);
2857 bool blocked = wxPyBeginBlockThreads();
2858 pyList = PyList_New(0);
2859 for (int i=0; i < arr.GetCount(); i++) {
2860 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2861 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2862 PyList_Append(pyList, pyObj);
2863 Py_DECREF(pyObj);
2864 }
2865 wxPyEndBlockThreads(blocked);
2866 return pyList;
2867 }
2868
2869 #include <wx/stdpaths.h>
2870
2871 static wxStandardPaths *StandardPaths_Get(){
2872 return (wxStandardPaths*) &wxStandardPaths::Get();
2873 }
2874 #ifdef __cplusplus
2875 extern "C" {
2876 #endif
2877 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2878 PyObject *resultobj;
2879 wxSystemColour arg1 ;
2880 wxColour result;
2881 PyObject * obj0 = 0 ;
2882 char *kwnames[] = {
2883 (char *) "index", NULL
2884 };
2885
2886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2887 {
2888 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2889 if (SWIG_arg_fail(1)) SWIG_fail;
2890 }
2891 {
2892 if (!wxPyCheckForApp()) SWIG_fail;
2893 PyThreadState* __tstate = wxPyBeginAllowThreads();
2894 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2895
2896 wxPyEndAllowThreads(__tstate);
2897 if (PyErr_Occurred()) SWIG_fail;
2898 }
2899 {
2900 wxColour * resultptr;
2901 resultptr = new wxColour((wxColour &)(result));
2902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2903 }
2904 return resultobj;
2905 fail:
2906 return NULL;
2907 }
2908
2909
2910 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2911 PyObject *resultobj;
2912 wxSystemFont arg1 ;
2913 wxFont result;
2914 PyObject * obj0 = 0 ;
2915 char *kwnames[] = {
2916 (char *) "index", NULL
2917 };
2918
2919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2920 {
2921 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2922 if (SWIG_arg_fail(1)) SWIG_fail;
2923 }
2924 {
2925 if (!wxPyCheckForApp()) SWIG_fail;
2926 PyThreadState* __tstate = wxPyBeginAllowThreads();
2927 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2928
2929 wxPyEndAllowThreads(__tstate);
2930 if (PyErr_Occurred()) SWIG_fail;
2931 }
2932 {
2933 wxFont * resultptr;
2934 resultptr = new wxFont((wxFont &)(result));
2935 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2936 }
2937 return resultobj;
2938 fail:
2939 return NULL;
2940 }
2941
2942
2943 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2944 PyObject *resultobj;
2945 wxSystemMetric arg1 ;
2946 int result;
2947 PyObject * obj0 = 0 ;
2948 char *kwnames[] = {
2949 (char *) "index", NULL
2950 };
2951
2952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2953 {
2954 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2955 if (SWIG_arg_fail(1)) SWIG_fail;
2956 }
2957 {
2958 if (!wxPyCheckForApp()) SWIG_fail;
2959 PyThreadState* __tstate = wxPyBeginAllowThreads();
2960 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2961
2962 wxPyEndAllowThreads(__tstate);
2963 if (PyErr_Occurred()) SWIG_fail;
2964 }
2965 {
2966 resultobj = SWIG_From_int((int)(result));
2967 }
2968 return resultobj;
2969 fail:
2970 return NULL;
2971 }
2972
2973
2974 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2975 PyObject *resultobj;
2976 wxSystemFeature arg1 ;
2977 bool result;
2978 PyObject * obj0 = 0 ;
2979 char *kwnames[] = {
2980 (char *) "index", NULL
2981 };
2982
2983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2984 {
2985 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2986 if (SWIG_arg_fail(1)) SWIG_fail;
2987 }
2988 {
2989 if (!wxPyCheckForApp()) SWIG_fail;
2990 PyThreadState* __tstate = wxPyBeginAllowThreads();
2991 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2992
2993 wxPyEndAllowThreads(__tstate);
2994 if (PyErr_Occurred()) SWIG_fail;
2995 }
2996 {
2997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2998 }
2999 return resultobj;
3000 fail:
3001 return NULL;
3002 }
3003
3004
3005 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3006 PyObject *resultobj;
3007 wxSystemScreenType result;
3008 char *kwnames[] = {
3009 NULL
3010 };
3011
3012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3013 {
3014 if (!wxPyCheckForApp()) SWIG_fail;
3015 PyThreadState* __tstate = wxPyBeginAllowThreads();
3016 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3017
3018 wxPyEndAllowThreads(__tstate);
3019 if (PyErr_Occurred()) SWIG_fail;
3020 }
3021 resultobj = SWIG_From_int((result));
3022 return resultobj;
3023 fail:
3024 return NULL;
3025 }
3026
3027
3028 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3029 PyObject *resultobj;
3030 wxSystemScreenType arg1 ;
3031 PyObject * obj0 = 0 ;
3032 char *kwnames[] = {
3033 (char *) "screen", NULL
3034 };
3035
3036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3037 {
3038 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3039 if (SWIG_arg_fail(1)) SWIG_fail;
3040 }
3041 {
3042 if (!wxPyCheckForApp()) SWIG_fail;
3043 PyThreadState* __tstate = wxPyBeginAllowThreads();
3044 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3045
3046 wxPyEndAllowThreads(__tstate);
3047 if (PyErr_Occurred()) SWIG_fail;
3048 }
3049 Py_INCREF(Py_None); resultobj = Py_None;
3050 return resultobj;
3051 fail:
3052 return NULL;
3053 }
3054
3055
3056 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3057 PyObject *obj;
3058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3059 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3060 Py_INCREF(obj);
3061 return Py_BuildValue((char *)"");
3062 }
3063 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3064 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3065 return 1;
3066 }
3067
3068
3069 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3070 PyObject *pyobj;
3071
3072 {
3073 #if wxUSE_UNICODE
3074 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3075 #else
3076 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3077 #endif
3078 }
3079 return pyobj;
3080 }
3081
3082
3083 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3084 PyObject *resultobj;
3085 wxSystemOptions *result;
3086 char *kwnames[] = {
3087 NULL
3088 };
3089
3090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3091 {
3092 PyThreadState* __tstate = wxPyBeginAllowThreads();
3093 result = (wxSystemOptions *)new wxSystemOptions();
3094
3095 wxPyEndAllowThreads(__tstate);
3096 if (PyErr_Occurred()) SWIG_fail;
3097 }
3098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3099 return resultobj;
3100 fail:
3101 return NULL;
3102 }
3103
3104
3105 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3106 PyObject *resultobj;
3107 wxString *arg1 = 0 ;
3108 wxString *arg2 = 0 ;
3109 bool temp1 = false ;
3110 bool temp2 = false ;
3111 PyObject * obj0 = 0 ;
3112 PyObject * obj1 = 0 ;
3113 char *kwnames[] = {
3114 (char *) "name",(char *) "value", NULL
3115 };
3116
3117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3118 {
3119 arg1 = wxString_in_helper(obj0);
3120 if (arg1 == NULL) SWIG_fail;
3121 temp1 = true;
3122 }
3123 {
3124 arg2 = wxString_in_helper(obj1);
3125 if (arg2 == NULL) SWIG_fail;
3126 temp2 = true;
3127 }
3128 {
3129 PyThreadState* __tstate = wxPyBeginAllowThreads();
3130 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3131
3132 wxPyEndAllowThreads(__tstate);
3133 if (PyErr_Occurred()) SWIG_fail;
3134 }
3135 Py_INCREF(Py_None); resultobj = Py_None;
3136 {
3137 if (temp1)
3138 delete arg1;
3139 }
3140 {
3141 if (temp2)
3142 delete arg2;
3143 }
3144 return resultobj;
3145 fail:
3146 {
3147 if (temp1)
3148 delete arg1;
3149 }
3150 {
3151 if (temp2)
3152 delete arg2;
3153 }
3154 return NULL;
3155 }
3156
3157
3158 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3159 PyObject *resultobj;
3160 wxString *arg1 = 0 ;
3161 int arg2 ;
3162 bool temp1 = false ;
3163 PyObject * obj0 = 0 ;
3164 PyObject * obj1 = 0 ;
3165 char *kwnames[] = {
3166 (char *) "name",(char *) "value", NULL
3167 };
3168
3169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3170 {
3171 arg1 = wxString_in_helper(obj0);
3172 if (arg1 == NULL) SWIG_fail;
3173 temp1 = true;
3174 }
3175 {
3176 arg2 = (int)(SWIG_As_int(obj1));
3177 if (SWIG_arg_fail(2)) SWIG_fail;
3178 }
3179 {
3180 PyThreadState* __tstate = wxPyBeginAllowThreads();
3181 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3182
3183 wxPyEndAllowThreads(__tstate);
3184 if (PyErr_Occurred()) SWIG_fail;
3185 }
3186 Py_INCREF(Py_None); resultobj = Py_None;
3187 {
3188 if (temp1)
3189 delete arg1;
3190 }
3191 return resultobj;
3192 fail:
3193 {
3194 if (temp1)
3195 delete arg1;
3196 }
3197 return NULL;
3198 }
3199
3200
3201 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3202 PyObject *resultobj;
3203 wxString *arg1 = 0 ;
3204 wxString result;
3205 bool temp1 = false ;
3206 PyObject * obj0 = 0 ;
3207 char *kwnames[] = {
3208 (char *) "name", NULL
3209 };
3210
3211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3212 {
3213 arg1 = wxString_in_helper(obj0);
3214 if (arg1 == NULL) SWIG_fail;
3215 temp1 = true;
3216 }
3217 {
3218 PyThreadState* __tstate = wxPyBeginAllowThreads();
3219 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3220
3221 wxPyEndAllowThreads(__tstate);
3222 if (PyErr_Occurred()) SWIG_fail;
3223 }
3224 {
3225 #if wxUSE_UNICODE
3226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3227 #else
3228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3229 #endif
3230 }
3231 {
3232 if (temp1)
3233 delete arg1;
3234 }
3235 return resultobj;
3236 fail:
3237 {
3238 if (temp1)
3239 delete arg1;
3240 }
3241 return NULL;
3242 }
3243
3244
3245 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3246 PyObject *resultobj;
3247 wxString *arg1 = 0 ;
3248 int result;
3249 bool temp1 = false ;
3250 PyObject * obj0 = 0 ;
3251 char *kwnames[] = {
3252 (char *) "name", NULL
3253 };
3254
3255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3256 {
3257 arg1 = wxString_in_helper(obj0);
3258 if (arg1 == NULL) SWIG_fail;
3259 temp1 = true;
3260 }
3261 {
3262 PyThreadState* __tstate = wxPyBeginAllowThreads();
3263 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3264
3265 wxPyEndAllowThreads(__tstate);
3266 if (PyErr_Occurred()) SWIG_fail;
3267 }
3268 {
3269 resultobj = SWIG_From_int((int)(result));
3270 }
3271 {
3272 if (temp1)
3273 delete arg1;
3274 }
3275 return resultobj;
3276 fail:
3277 {
3278 if (temp1)
3279 delete arg1;
3280 }
3281 return NULL;
3282 }
3283
3284
3285 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3286 PyObject *resultobj;
3287 wxString *arg1 = 0 ;
3288 bool result;
3289 bool temp1 = false ;
3290 PyObject * obj0 = 0 ;
3291 char *kwnames[] = {
3292 (char *) "name", NULL
3293 };
3294
3295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3296 {
3297 arg1 = wxString_in_helper(obj0);
3298 if (arg1 == NULL) SWIG_fail;
3299 temp1 = true;
3300 }
3301 {
3302 PyThreadState* __tstate = wxPyBeginAllowThreads();
3303 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3304
3305 wxPyEndAllowThreads(__tstate);
3306 if (PyErr_Occurred()) SWIG_fail;
3307 }
3308 {
3309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3310 }
3311 {
3312 if (temp1)
3313 delete arg1;
3314 }
3315 return resultobj;
3316 fail:
3317 {
3318 if (temp1)
3319 delete arg1;
3320 }
3321 return NULL;
3322 }
3323
3324
3325 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3326 PyObject *obj;
3327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3328 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3329 Py_INCREF(obj);
3330 return Py_BuildValue((char *)"");
3331 }
3332 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3333 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3334 return 1;
3335 }
3336
3337
3338 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3339 PyObject *pyobj;
3340
3341 {
3342 #if wxUSE_UNICODE
3343 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3344 #else
3345 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3346 #endif
3347 }
3348 return pyobj;
3349 }
3350
3351
3352 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3353 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3354 return 1;
3355 }
3356
3357
3358 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3359 PyObject *pyobj;
3360
3361 {
3362 #if wxUSE_UNICODE
3363 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3364 #else
3365 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3366 #endif
3367 }
3368 return pyobj;
3369 }
3370
3371
3372 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3373 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3374 return 1;
3375 }
3376
3377
3378 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3379 PyObject *pyobj;
3380
3381 {
3382 #if wxUSE_UNICODE
3383 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3384 #else
3385 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3386 #endif
3387 }
3388 return pyobj;
3389 }
3390
3391
3392 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3393 PyObject *resultobj;
3394 long result;
3395 char *kwnames[] = {
3396 NULL
3397 };
3398
3399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3400 {
3401 PyThreadState* __tstate = wxPyBeginAllowThreads();
3402 result = (long)wxNewId();
3403
3404 wxPyEndAllowThreads(__tstate);
3405 if (PyErr_Occurred()) SWIG_fail;
3406 }
3407 {
3408 resultobj = SWIG_From_long((long)(result));
3409 }
3410 return resultobj;
3411 fail:
3412 return NULL;
3413 }
3414
3415
3416 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3417 PyObject *resultobj;
3418 long arg1 ;
3419 PyObject * obj0 = 0 ;
3420 char *kwnames[] = {
3421 (char *) "id", NULL
3422 };
3423
3424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3425 {
3426 arg1 = (long)(SWIG_As_long(obj0));
3427 if (SWIG_arg_fail(1)) SWIG_fail;
3428 }
3429 {
3430 PyThreadState* __tstate = wxPyBeginAllowThreads();
3431 wxRegisterId(arg1);
3432
3433 wxPyEndAllowThreads(__tstate);
3434 if (PyErr_Occurred()) SWIG_fail;
3435 }
3436 Py_INCREF(Py_None); resultobj = Py_None;
3437 return resultobj;
3438 fail:
3439 return NULL;
3440 }
3441
3442
3443 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3444 PyObject *resultobj;
3445 long result;
3446 char *kwnames[] = {
3447 NULL
3448 };
3449
3450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3451 {
3452 PyThreadState* __tstate = wxPyBeginAllowThreads();
3453 result = (long)wxGetCurrentId();
3454
3455 wxPyEndAllowThreads(__tstate);
3456 if (PyErr_Occurred()) SWIG_fail;
3457 }
3458 {
3459 resultobj = SWIG_From_long((long)(result));
3460 }
3461 return resultobj;
3462 fail:
3463 return NULL;
3464 }
3465
3466
3467 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3468 PyObject *resultobj;
3469 int arg1 ;
3470 bool result;
3471 PyObject * obj0 = 0 ;
3472 char *kwnames[] = {
3473 (char *) "id", NULL
3474 };
3475
3476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3477 {
3478 arg1 = (int)(SWIG_As_int(obj0));
3479 if (SWIG_arg_fail(1)) SWIG_fail;
3480 }
3481 {
3482 PyThreadState* __tstate = wxPyBeginAllowThreads();
3483 result = (bool)wxIsStockID(arg1);
3484
3485 wxPyEndAllowThreads(__tstate);
3486 if (PyErr_Occurred()) SWIG_fail;
3487 }
3488 {
3489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3490 }
3491 return resultobj;
3492 fail:
3493 return NULL;
3494 }
3495
3496
3497 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3498 PyObject *resultobj;
3499 int arg1 ;
3500 wxString *arg2 = 0 ;
3501 bool result;
3502 bool temp2 = false ;
3503 PyObject * obj0 = 0 ;
3504 PyObject * obj1 = 0 ;
3505 char *kwnames[] = {
3506 (char *) "id",(char *) "label", NULL
3507 };
3508
3509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3510 {
3511 arg1 = (int)(SWIG_As_int(obj0));
3512 if (SWIG_arg_fail(1)) SWIG_fail;
3513 }
3514 {
3515 arg2 = wxString_in_helper(obj1);
3516 if (arg2 == NULL) SWIG_fail;
3517 temp2 = true;
3518 }
3519 {
3520 PyThreadState* __tstate = wxPyBeginAllowThreads();
3521 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3522
3523 wxPyEndAllowThreads(__tstate);
3524 if (PyErr_Occurred()) SWIG_fail;
3525 }
3526 {
3527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3528 }
3529 {
3530 if (temp2)
3531 delete arg2;
3532 }
3533 return resultobj;
3534 fail:
3535 {
3536 if (temp2)
3537 delete arg2;
3538 }
3539 return NULL;
3540 }
3541
3542
3543 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3544 PyObject *resultobj;
3545 int arg1 ;
3546 wxString result;
3547 PyObject * obj0 = 0 ;
3548 char *kwnames[] = {
3549 (char *) "id", NULL
3550 };
3551
3552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetStockLabel",kwnames,&obj0)) goto fail;
3553 {
3554 arg1 = (int)(SWIG_As_int(obj0));
3555 if (SWIG_arg_fail(1)) SWIG_fail;
3556 }
3557 {
3558 PyThreadState* __tstate = wxPyBeginAllowThreads();
3559 result = wxGetStockLabel(arg1);
3560
3561 wxPyEndAllowThreads(__tstate);
3562 if (PyErr_Occurred()) SWIG_fail;
3563 }
3564 {
3565 #if wxUSE_UNICODE
3566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3567 #else
3568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3569 #endif
3570 }
3571 return resultobj;
3572 fail:
3573 return NULL;
3574 }
3575
3576
3577 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3578 PyObject *resultobj;
3579 char *kwnames[] = {
3580 NULL
3581 };
3582
3583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3584 {
3585 if (!wxPyCheckForApp()) SWIG_fail;
3586 PyThreadState* __tstate = wxPyBeginAllowThreads();
3587 wxBell();
3588
3589 wxPyEndAllowThreads(__tstate);
3590 if (PyErr_Occurred()) SWIG_fail;
3591 }
3592 Py_INCREF(Py_None); resultobj = Py_None;
3593 return resultobj;
3594 fail:
3595 return NULL;
3596 }
3597
3598
3599 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3600 PyObject *resultobj;
3601 char *kwnames[] = {
3602 NULL
3603 };
3604
3605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3606 {
3607 if (!wxPyCheckForApp()) SWIG_fail;
3608 PyThreadState* __tstate = wxPyBeginAllowThreads();
3609 wxEndBusyCursor();
3610
3611 wxPyEndAllowThreads(__tstate);
3612 if (PyErr_Occurred()) SWIG_fail;
3613 }
3614 Py_INCREF(Py_None); resultobj = Py_None;
3615 return resultobj;
3616 fail:
3617 return NULL;
3618 }
3619
3620
3621 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3622 PyObject *resultobj;
3623 bool arg1 = (bool) true ;
3624 long result;
3625 PyObject * obj0 = 0 ;
3626 char *kwnames[] = {
3627 (char *) "resetTimer", NULL
3628 };
3629
3630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3631 if (obj0) {
3632 {
3633 arg1 = (bool)(SWIG_As_bool(obj0));
3634 if (SWIG_arg_fail(1)) SWIG_fail;
3635 }
3636 }
3637 {
3638 PyThreadState* __tstate = wxPyBeginAllowThreads();
3639 result = (long)wxGetElapsedTime(arg1);
3640
3641 wxPyEndAllowThreads(__tstate);
3642 if (PyErr_Occurred()) SWIG_fail;
3643 }
3644 {
3645 resultobj = SWIG_From_long((long)(result));
3646 }
3647 return resultobj;
3648 fail:
3649 return NULL;
3650 }
3651
3652
3653 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3654 PyObject *resultobj;
3655 int *arg1 = (int *) 0 ;
3656 int *arg2 = (int *) 0 ;
3657 int temp1 ;
3658 int res1 = 0 ;
3659 int temp2 ;
3660 int res2 = 0 ;
3661 char *kwnames[] = {
3662 NULL
3663 };
3664
3665 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3666 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3668 {
3669 if (!wxPyCheckForApp()) SWIG_fail;
3670 PyThreadState* __tstate = wxPyBeginAllowThreads();
3671 wxGetMousePosition(arg1,arg2);
3672
3673 wxPyEndAllowThreads(__tstate);
3674 if (PyErr_Occurred()) SWIG_fail;
3675 }
3676 Py_INCREF(Py_None); resultobj = Py_None;
3677 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3678 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3679 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3680 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3681 return resultobj;
3682 fail:
3683 return NULL;
3684 }
3685
3686
3687 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3688 PyObject *resultobj;
3689 bool result;
3690 char *kwnames[] = {
3691 NULL
3692 };
3693
3694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3695 {
3696 PyThreadState* __tstate = wxPyBeginAllowThreads();
3697 result = (bool)wxIsBusy();
3698
3699 wxPyEndAllowThreads(__tstate);
3700 if (PyErr_Occurred()) SWIG_fail;
3701 }
3702 {
3703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3704 }
3705 return resultobj;
3706 fail:
3707 return NULL;
3708 }
3709
3710
3711 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3712 PyObject *resultobj;
3713 wxString result;
3714 char *kwnames[] = {
3715 NULL
3716 };
3717
3718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3719 {
3720 PyThreadState* __tstate = wxPyBeginAllowThreads();
3721 result = wxNow();
3722
3723 wxPyEndAllowThreads(__tstate);
3724 if (PyErr_Occurred()) SWIG_fail;
3725 }
3726 {
3727 #if wxUSE_UNICODE
3728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3729 #else
3730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3731 #endif
3732 }
3733 return resultobj;
3734 fail:
3735 return NULL;
3736 }
3737
3738
3739 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3740 PyObject *resultobj;
3741 wxString const &arg1_defvalue = wxPyEmptyString ;
3742 wxString *arg1 = (wxString *) &arg1_defvalue ;
3743 bool result;
3744 bool temp1 = false ;
3745 PyObject * obj0 = 0 ;
3746 char *kwnames[] = {
3747 (char *) "command", NULL
3748 };
3749
3750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3751 if (obj0) {
3752 {
3753 arg1 = wxString_in_helper(obj0);
3754 if (arg1 == NULL) SWIG_fail;
3755 temp1 = true;
3756 }
3757 }
3758 {
3759 PyThreadState* __tstate = wxPyBeginAllowThreads();
3760 result = (bool)wxShell((wxString const &)*arg1);
3761
3762 wxPyEndAllowThreads(__tstate);
3763 if (PyErr_Occurred()) SWIG_fail;
3764 }
3765 {
3766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3767 }
3768 {
3769 if (temp1)
3770 delete arg1;
3771 }
3772 return resultobj;
3773 fail:
3774 {
3775 if (temp1)
3776 delete arg1;
3777 }
3778 return NULL;
3779 }
3780
3781
3782 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3783 PyObject *resultobj;
3784 char *kwnames[] = {
3785 NULL
3786 };
3787
3788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3789 {
3790 PyThreadState* __tstate = wxPyBeginAllowThreads();
3791 wxStartTimer();
3792
3793 wxPyEndAllowThreads(__tstate);
3794 if (PyErr_Occurred()) SWIG_fail;
3795 }
3796 Py_INCREF(Py_None); resultobj = Py_None;
3797 return resultobj;
3798 fail:
3799 return NULL;
3800 }
3801
3802
3803 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3804 PyObject *resultobj;
3805 int *arg1 = (int *) 0 ;
3806 int *arg2 = (int *) 0 ;
3807 int result;
3808 int temp1 ;
3809 int res1 = 0 ;
3810 int temp2 ;
3811 int res2 = 0 ;
3812 char *kwnames[] = {
3813 NULL
3814 };
3815
3816 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3817 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3819 {
3820 PyThreadState* __tstate = wxPyBeginAllowThreads();
3821 result = (int)wxGetOsVersion(arg1,arg2);
3822
3823 wxPyEndAllowThreads(__tstate);
3824 if (PyErr_Occurred()) SWIG_fail;
3825 }
3826 {
3827 resultobj = SWIG_From_int((int)(result));
3828 }
3829 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3830 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3831 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3832 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3833 return resultobj;
3834 fail:
3835 return NULL;
3836 }
3837
3838
3839 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3840 PyObject *resultobj;
3841 wxString result;
3842 char *kwnames[] = {
3843 NULL
3844 };
3845
3846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3847 {
3848 PyThreadState* __tstate = wxPyBeginAllowThreads();
3849 result = wxGetOsDescription();
3850
3851 wxPyEndAllowThreads(__tstate);
3852 if (PyErr_Occurred()) SWIG_fail;
3853 }
3854 {
3855 #if wxUSE_UNICODE
3856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3857 #else
3858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3859 #endif
3860 }
3861 return resultobj;
3862 fail:
3863 return NULL;
3864 }
3865
3866
3867 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3868 PyObject *resultobj;
3869 long result;
3870 char *kwnames[] = {
3871 NULL
3872 };
3873
3874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3875 {
3876 PyThreadState* __tstate = wxPyBeginAllowThreads();
3877 result = (long)wxGetFreeMemory();
3878
3879 wxPyEndAllowThreads(__tstate);
3880 if (PyErr_Occurred()) SWIG_fail;
3881 }
3882 {
3883 resultobj = SWIG_From_long((long)(result));
3884 }
3885 return resultobj;
3886 fail:
3887 return NULL;
3888 }
3889
3890
3891 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3892 PyObject *resultobj;
3893 wxShutdownFlags arg1 ;
3894 bool result;
3895 PyObject * obj0 = 0 ;
3896 char *kwnames[] = {
3897 (char *) "wFlags", NULL
3898 };
3899
3900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3901 {
3902 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3903 if (SWIG_arg_fail(1)) SWIG_fail;
3904 }
3905 {
3906 if (!wxPyCheckForApp()) SWIG_fail;
3907 PyThreadState* __tstate = wxPyBeginAllowThreads();
3908 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3909
3910 wxPyEndAllowThreads(__tstate);
3911 if (PyErr_Occurred()) SWIG_fail;
3912 }
3913 {
3914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3915 }
3916 return resultobj;
3917 fail:
3918 return NULL;
3919 }
3920
3921
3922 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3923 PyObject *resultobj;
3924 int arg1 ;
3925 PyObject * obj0 = 0 ;
3926 char *kwnames[] = {
3927 (char *) "secs", NULL
3928 };
3929
3930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3931 {
3932 arg1 = (int)(SWIG_As_int(obj0));
3933 if (SWIG_arg_fail(1)) SWIG_fail;
3934 }
3935 {
3936 PyThreadState* __tstate = wxPyBeginAllowThreads();
3937 wxSleep(arg1);
3938
3939 wxPyEndAllowThreads(__tstate);
3940 if (PyErr_Occurred()) SWIG_fail;
3941 }
3942 Py_INCREF(Py_None); resultobj = Py_None;
3943 return resultobj;
3944 fail:
3945 return NULL;
3946 }
3947
3948
3949 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3950 PyObject *resultobj;
3951 unsigned long arg1 ;
3952 PyObject * obj0 = 0 ;
3953 char *kwnames[] = {
3954 (char *) "milliseconds", NULL
3955 };
3956
3957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3958 {
3959 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3960 if (SWIG_arg_fail(1)) SWIG_fail;
3961 }
3962 {
3963 PyThreadState* __tstate = wxPyBeginAllowThreads();
3964 wxMilliSleep(arg1);
3965
3966 wxPyEndAllowThreads(__tstate);
3967 if (PyErr_Occurred()) SWIG_fail;
3968 }
3969 Py_INCREF(Py_None); resultobj = Py_None;
3970 return resultobj;
3971 fail:
3972 return NULL;
3973 }
3974
3975
3976 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3977 PyObject *resultobj;
3978 unsigned long arg1 ;
3979 PyObject * obj0 = 0 ;
3980 char *kwnames[] = {
3981 (char *) "microseconds", NULL
3982 };
3983
3984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
3985 {
3986 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3987 if (SWIG_arg_fail(1)) SWIG_fail;
3988 }
3989 {
3990 PyThreadState* __tstate = wxPyBeginAllowThreads();
3991 wxMicroSleep(arg1);
3992
3993 wxPyEndAllowThreads(__tstate);
3994 if (PyErr_Occurred()) SWIG_fail;
3995 }
3996 Py_INCREF(Py_None); resultobj = Py_None;
3997 return resultobj;
3998 fail:
3999 return NULL;
4000 }
4001
4002
4003 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4004 PyObject *resultobj;
4005 bool arg1 ;
4006 PyObject * obj0 = 0 ;
4007 char *kwnames[] = {
4008 (char *) "enable", NULL
4009 };
4010
4011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4012 {
4013 arg1 = (bool)(SWIG_As_bool(obj0));
4014 if (SWIG_arg_fail(1)) SWIG_fail;
4015 }
4016 {
4017 PyThreadState* __tstate = wxPyBeginAllowThreads();
4018 wxEnableTopLevelWindows(arg1);
4019
4020 wxPyEndAllowThreads(__tstate);
4021 if (PyErr_Occurred()) SWIG_fail;
4022 }
4023 Py_INCREF(Py_None); resultobj = Py_None;
4024 return resultobj;
4025 fail:
4026 return NULL;
4027 }
4028
4029
4030 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4031 PyObject *resultobj;
4032 wxString *arg1 = 0 ;
4033 wxString result;
4034 bool temp1 = false ;
4035 PyObject * obj0 = 0 ;
4036 char *kwnames[] = {
4037 (char *) "in", NULL
4038 };
4039
4040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4041 {
4042 arg1 = wxString_in_helper(obj0);
4043 if (arg1 == NULL) SWIG_fail;
4044 temp1 = true;
4045 }
4046 {
4047 PyThreadState* __tstate = wxPyBeginAllowThreads();
4048 result = wxStripMenuCodes((wxString const &)*arg1);
4049
4050 wxPyEndAllowThreads(__tstate);
4051 if (PyErr_Occurred()) SWIG_fail;
4052 }
4053 {
4054 #if wxUSE_UNICODE
4055 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4056 #else
4057 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4058 #endif
4059 }
4060 {
4061 if (temp1)
4062 delete arg1;
4063 }
4064 return resultobj;
4065 fail:
4066 {
4067 if (temp1)
4068 delete arg1;
4069 }
4070 return NULL;
4071 }
4072
4073
4074 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4075 PyObject *resultobj;
4076 wxString result;
4077 char *kwnames[] = {
4078 NULL
4079 };
4080
4081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4082 {
4083 PyThreadState* __tstate = wxPyBeginAllowThreads();
4084 result = wxGetEmailAddress();
4085
4086 wxPyEndAllowThreads(__tstate);
4087 if (PyErr_Occurred()) SWIG_fail;
4088 }
4089 {
4090 #if wxUSE_UNICODE
4091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4092 #else
4093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4094 #endif
4095 }
4096 return resultobj;
4097 fail:
4098 return NULL;
4099 }
4100
4101
4102 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4103 PyObject *resultobj;
4104 wxString result;
4105 char *kwnames[] = {
4106 NULL
4107 };
4108
4109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4110 {
4111 PyThreadState* __tstate = wxPyBeginAllowThreads();
4112 result = wxGetHostName();
4113
4114 wxPyEndAllowThreads(__tstate);
4115 if (PyErr_Occurred()) SWIG_fail;
4116 }
4117 {
4118 #if wxUSE_UNICODE
4119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4120 #else
4121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4122 #endif
4123 }
4124 return resultobj;
4125 fail:
4126 return NULL;
4127 }
4128
4129
4130 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4131 PyObject *resultobj;
4132 wxString result;
4133 char *kwnames[] = {
4134 NULL
4135 };
4136
4137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4138 {
4139 PyThreadState* __tstate = wxPyBeginAllowThreads();
4140 result = wxGetFullHostName();
4141
4142 wxPyEndAllowThreads(__tstate);
4143 if (PyErr_Occurred()) SWIG_fail;
4144 }
4145 {
4146 #if wxUSE_UNICODE
4147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4148 #else
4149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4150 #endif
4151 }
4152 return resultobj;
4153 fail:
4154 return NULL;
4155 }
4156
4157
4158 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4159 PyObject *resultobj;
4160 wxString result;
4161 char *kwnames[] = {
4162 NULL
4163 };
4164
4165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4166 {
4167 PyThreadState* __tstate = wxPyBeginAllowThreads();
4168 result = wxGetUserId();
4169
4170 wxPyEndAllowThreads(__tstate);
4171 if (PyErr_Occurred()) SWIG_fail;
4172 }
4173 {
4174 #if wxUSE_UNICODE
4175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4176 #else
4177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4178 #endif
4179 }
4180 return resultobj;
4181 fail:
4182 return NULL;
4183 }
4184
4185
4186 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4187 PyObject *resultobj;
4188 wxString result;
4189 char *kwnames[] = {
4190 NULL
4191 };
4192
4193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4194 {
4195 PyThreadState* __tstate = wxPyBeginAllowThreads();
4196 result = wxGetUserName();
4197
4198 wxPyEndAllowThreads(__tstate);
4199 if (PyErr_Occurred()) SWIG_fail;
4200 }
4201 {
4202 #if wxUSE_UNICODE
4203 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4204 #else
4205 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4206 #endif
4207 }
4208 return resultobj;
4209 fail:
4210 return NULL;
4211 }
4212
4213
4214 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4215 PyObject *resultobj;
4216 wxString result;
4217 char *kwnames[] = {
4218 NULL
4219 };
4220
4221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4222 {
4223 PyThreadState* __tstate = wxPyBeginAllowThreads();
4224 result = wxGetHomeDir();
4225
4226 wxPyEndAllowThreads(__tstate);
4227 if (PyErr_Occurred()) SWIG_fail;
4228 }
4229 {
4230 #if wxUSE_UNICODE
4231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4232 #else
4233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4234 #endif
4235 }
4236 return resultobj;
4237 fail:
4238 return NULL;
4239 }
4240
4241
4242 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4243 PyObject *resultobj;
4244 wxString const &arg1_defvalue = wxPyEmptyString ;
4245 wxString *arg1 = (wxString *) &arg1_defvalue ;
4246 wxString result;
4247 bool temp1 = false ;
4248 PyObject * obj0 = 0 ;
4249 char *kwnames[] = {
4250 (char *) "user", NULL
4251 };
4252
4253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4254 if (obj0) {
4255 {
4256 arg1 = wxString_in_helper(obj0);
4257 if (arg1 == NULL) SWIG_fail;
4258 temp1 = true;
4259 }
4260 }
4261 {
4262 PyThreadState* __tstate = wxPyBeginAllowThreads();
4263 result = wxGetUserHome((wxString const &)*arg1);
4264
4265 wxPyEndAllowThreads(__tstate);
4266 if (PyErr_Occurred()) SWIG_fail;
4267 }
4268 {
4269 #if wxUSE_UNICODE
4270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4271 #else
4272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4273 #endif
4274 }
4275 {
4276 if (temp1)
4277 delete arg1;
4278 }
4279 return resultobj;
4280 fail:
4281 {
4282 if (temp1)
4283 delete arg1;
4284 }
4285 return NULL;
4286 }
4287
4288
4289 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4290 PyObject *resultobj;
4291 unsigned long result;
4292 char *kwnames[] = {
4293 NULL
4294 };
4295
4296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4297 {
4298 PyThreadState* __tstate = wxPyBeginAllowThreads();
4299 result = (unsigned long)wxGetProcessId();
4300
4301 wxPyEndAllowThreads(__tstate);
4302 if (PyErr_Occurred()) SWIG_fail;
4303 }
4304 {
4305 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4306 }
4307 return resultobj;
4308 fail:
4309 return NULL;
4310 }
4311
4312
4313 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4314 PyObject *resultobj;
4315 char *kwnames[] = {
4316 NULL
4317 };
4318
4319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4320 {
4321 PyThreadState* __tstate = wxPyBeginAllowThreads();
4322 wxTrap();
4323
4324 wxPyEndAllowThreads(__tstate);
4325 if (PyErr_Occurred()) SWIG_fail;
4326 }
4327 Py_INCREF(Py_None); resultobj = Py_None;
4328 return resultobj;
4329 fail:
4330 return NULL;
4331 }
4332
4333
4334 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4335 PyObject *resultobj;
4336 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4337 wxString *arg1 = (wxString *) &arg1_defvalue ;
4338 wxString const &arg2_defvalue = wxPyEmptyString ;
4339 wxString *arg2 = (wxString *) &arg2_defvalue ;
4340 wxString const &arg3_defvalue = wxPyEmptyString ;
4341 wxString *arg3 = (wxString *) &arg3_defvalue ;
4342 wxString const &arg4_defvalue = wxPyEmptyString ;
4343 wxString *arg4 = (wxString *) &arg4_defvalue ;
4344 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4345 wxString *arg5 = (wxString *) &arg5_defvalue ;
4346 int arg6 = (int) 0 ;
4347 wxWindow *arg7 = (wxWindow *) NULL ;
4348 int arg8 = (int) -1 ;
4349 int arg9 = (int) -1 ;
4350 wxString result;
4351 bool temp1 = false ;
4352 bool temp2 = false ;
4353 bool temp3 = false ;
4354 bool temp4 = false ;
4355 bool temp5 = false ;
4356 PyObject * obj0 = 0 ;
4357 PyObject * obj1 = 0 ;
4358 PyObject * obj2 = 0 ;
4359 PyObject * obj3 = 0 ;
4360 PyObject * obj4 = 0 ;
4361 PyObject * obj5 = 0 ;
4362 PyObject * obj6 = 0 ;
4363 PyObject * obj7 = 0 ;
4364 PyObject * obj8 = 0 ;
4365 char *kwnames[] = {
4366 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4367 };
4368
4369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4370 if (obj0) {
4371 {
4372 arg1 = wxString_in_helper(obj0);
4373 if (arg1 == NULL) SWIG_fail;
4374 temp1 = true;
4375 }
4376 }
4377 if (obj1) {
4378 {
4379 arg2 = wxString_in_helper(obj1);
4380 if (arg2 == NULL) SWIG_fail;
4381 temp2 = true;
4382 }
4383 }
4384 if (obj2) {
4385 {
4386 arg3 = wxString_in_helper(obj2);
4387 if (arg3 == NULL) SWIG_fail;
4388 temp3 = true;
4389 }
4390 }
4391 if (obj3) {
4392 {
4393 arg4 = wxString_in_helper(obj3);
4394 if (arg4 == NULL) SWIG_fail;
4395 temp4 = true;
4396 }
4397 }
4398 if (obj4) {
4399 {
4400 arg5 = wxString_in_helper(obj4);
4401 if (arg5 == NULL) SWIG_fail;
4402 temp5 = true;
4403 }
4404 }
4405 if (obj5) {
4406 {
4407 arg6 = (int)(SWIG_As_int(obj5));
4408 if (SWIG_arg_fail(6)) SWIG_fail;
4409 }
4410 }
4411 if (obj6) {
4412 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4413 if (SWIG_arg_fail(7)) SWIG_fail;
4414 }
4415 if (obj7) {
4416 {
4417 arg8 = (int)(SWIG_As_int(obj7));
4418 if (SWIG_arg_fail(8)) SWIG_fail;
4419 }
4420 }
4421 if (obj8) {
4422 {
4423 arg9 = (int)(SWIG_As_int(obj8));
4424 if (SWIG_arg_fail(9)) SWIG_fail;
4425 }
4426 }
4427 {
4428 if (!wxPyCheckForApp()) SWIG_fail;
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4431
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 {
4436 #if wxUSE_UNICODE
4437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4438 #else
4439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4440 #endif
4441 }
4442 {
4443 if (temp1)
4444 delete arg1;
4445 }
4446 {
4447 if (temp2)
4448 delete arg2;
4449 }
4450 {
4451 if (temp3)
4452 delete arg3;
4453 }
4454 {
4455 if (temp4)
4456 delete arg4;
4457 }
4458 {
4459 if (temp5)
4460 delete arg5;
4461 }
4462 return resultobj;
4463 fail:
4464 {
4465 if (temp1)
4466 delete arg1;
4467 }
4468 {
4469 if (temp2)
4470 delete arg2;
4471 }
4472 {
4473 if (temp3)
4474 delete arg3;
4475 }
4476 {
4477 if (temp4)
4478 delete arg4;
4479 }
4480 {
4481 if (temp5)
4482 delete arg5;
4483 }
4484 return NULL;
4485 }
4486
4487
4488 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4489 PyObject *resultobj;
4490 wxString *arg1 = 0 ;
4491 wxString *arg2 = 0 ;
4492 wxString const &arg3_defvalue = wxPyEmptyString ;
4493 wxString *arg3 = (wxString *) &arg3_defvalue ;
4494 wxWindow *arg4 = (wxWindow *) NULL ;
4495 wxString result;
4496 bool temp1 = false ;
4497 bool temp2 = false ;
4498 bool temp3 = false ;
4499 PyObject * obj0 = 0 ;
4500 PyObject * obj1 = 0 ;
4501 PyObject * obj2 = 0 ;
4502 PyObject * obj3 = 0 ;
4503 char *kwnames[] = {
4504 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4505 };
4506
4507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4508 {
4509 arg1 = wxString_in_helper(obj0);
4510 if (arg1 == NULL) SWIG_fail;
4511 temp1 = true;
4512 }
4513 {
4514 arg2 = wxString_in_helper(obj1);
4515 if (arg2 == NULL) SWIG_fail;
4516 temp2 = true;
4517 }
4518 if (obj2) {
4519 {
4520 arg3 = wxString_in_helper(obj2);
4521 if (arg3 == NULL) SWIG_fail;
4522 temp3 = true;
4523 }
4524 }
4525 if (obj3) {
4526 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4527 if (SWIG_arg_fail(4)) SWIG_fail;
4528 }
4529 {
4530 if (!wxPyCheckForApp()) SWIG_fail;
4531 PyThreadState* __tstate = wxPyBeginAllowThreads();
4532 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4533
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 {
4538 #if wxUSE_UNICODE
4539 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4540 #else
4541 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4542 #endif
4543 }
4544 {
4545 if (temp1)
4546 delete arg1;
4547 }
4548 {
4549 if (temp2)
4550 delete arg2;
4551 }
4552 {
4553 if (temp3)
4554 delete arg3;
4555 }
4556 return resultobj;
4557 fail:
4558 {
4559 if (temp1)
4560 delete arg1;
4561 }
4562 {
4563 if (temp2)
4564 delete arg2;
4565 }
4566 {
4567 if (temp3)
4568 delete arg3;
4569 }
4570 return NULL;
4571 }
4572
4573
4574 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4575 PyObject *resultobj;
4576 wxString *arg1 = 0 ;
4577 wxString *arg2 = 0 ;
4578 wxString const &arg3_defvalue = wxPyEmptyString ;
4579 wxString *arg3 = (wxString *) &arg3_defvalue ;
4580 wxWindow *arg4 = (wxWindow *) NULL ;
4581 wxString result;
4582 bool temp1 = false ;
4583 bool temp2 = false ;
4584 bool temp3 = false ;
4585 PyObject * obj0 = 0 ;
4586 PyObject * obj1 = 0 ;
4587 PyObject * obj2 = 0 ;
4588 PyObject * obj3 = 0 ;
4589 char *kwnames[] = {
4590 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4591 };
4592
4593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4594 {
4595 arg1 = wxString_in_helper(obj0);
4596 if (arg1 == NULL) SWIG_fail;
4597 temp1 = true;
4598 }
4599 {
4600 arg2 = wxString_in_helper(obj1);
4601 if (arg2 == NULL) SWIG_fail;
4602 temp2 = true;
4603 }
4604 if (obj2) {
4605 {
4606 arg3 = wxString_in_helper(obj2);
4607 if (arg3 == NULL) SWIG_fail;
4608 temp3 = true;
4609 }
4610 }
4611 if (obj3) {
4612 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4613 if (SWIG_arg_fail(4)) SWIG_fail;
4614 }
4615 {
4616 if (!wxPyCheckForApp()) SWIG_fail;
4617 PyThreadState* __tstate = wxPyBeginAllowThreads();
4618 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4619
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 {
4624 #if wxUSE_UNICODE
4625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4626 #else
4627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4628 #endif
4629 }
4630 {
4631 if (temp1)
4632 delete arg1;
4633 }
4634 {
4635 if (temp2)
4636 delete arg2;
4637 }
4638 {
4639 if (temp3)
4640 delete arg3;
4641 }
4642 return resultobj;
4643 fail:
4644 {
4645 if (temp1)
4646 delete arg1;
4647 }
4648 {
4649 if (temp2)
4650 delete arg2;
4651 }
4652 {
4653 if (temp3)
4654 delete arg3;
4655 }
4656 return NULL;
4657 }
4658
4659
4660 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj;
4662 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4663 wxString *arg1 = (wxString *) &arg1_defvalue ;
4664 wxString const &arg2_defvalue = wxPyEmptyString ;
4665 wxString *arg2 = (wxString *) &arg2_defvalue ;
4666 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4667 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4668 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4669 wxWindow *arg5 = (wxWindow *) NULL ;
4670 wxString result;
4671 bool temp1 = false ;
4672 bool temp2 = false ;
4673 wxPoint temp4 ;
4674 PyObject * obj0 = 0 ;
4675 PyObject * obj1 = 0 ;
4676 PyObject * obj2 = 0 ;
4677 PyObject * obj3 = 0 ;
4678 PyObject * obj4 = 0 ;
4679 char *kwnames[] = {
4680 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4681 };
4682
4683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4684 if (obj0) {
4685 {
4686 arg1 = wxString_in_helper(obj0);
4687 if (arg1 == NULL) SWIG_fail;
4688 temp1 = true;
4689 }
4690 }
4691 if (obj1) {
4692 {
4693 arg2 = wxString_in_helper(obj1);
4694 if (arg2 == NULL) SWIG_fail;
4695 temp2 = true;
4696 }
4697 }
4698 if (obj2) {
4699 {
4700 arg3 = (long)(SWIG_As_long(obj2));
4701 if (SWIG_arg_fail(3)) SWIG_fail;
4702 }
4703 }
4704 if (obj3) {
4705 {
4706 arg4 = &temp4;
4707 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4708 }
4709 }
4710 if (obj4) {
4711 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4712 if (SWIG_arg_fail(5)) SWIG_fail;
4713 }
4714 {
4715 if (!wxPyCheckForApp()) SWIG_fail;
4716 PyThreadState* __tstate = wxPyBeginAllowThreads();
4717 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4718
4719 wxPyEndAllowThreads(__tstate);
4720 if (PyErr_Occurred()) SWIG_fail;
4721 }
4722 {
4723 #if wxUSE_UNICODE
4724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4725 #else
4726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4727 #endif
4728 }
4729 {
4730 if (temp1)
4731 delete arg1;
4732 }
4733 {
4734 if (temp2)
4735 delete arg2;
4736 }
4737 return resultobj;
4738 fail:
4739 {
4740 if (temp1)
4741 delete arg1;
4742 }
4743 {
4744 if (temp2)
4745 delete arg2;
4746 }
4747 return NULL;
4748 }
4749
4750
4751 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4752 PyObject *resultobj;
4753 wxString *arg1 = 0 ;
4754 wxString const &arg2_defvalue = wxPyEmptyString ;
4755 wxString *arg2 = (wxString *) &arg2_defvalue ;
4756 wxString const &arg3_defvalue = wxPyEmptyString ;
4757 wxString *arg3 = (wxString *) &arg3_defvalue ;
4758 wxWindow *arg4 = (wxWindow *) NULL ;
4759 int arg5 = (int) -1 ;
4760 int arg6 = (int) -1 ;
4761 bool arg7 = (bool) true ;
4762 wxString result;
4763 bool temp1 = false ;
4764 bool temp2 = false ;
4765 bool temp3 = false ;
4766 PyObject * obj0 = 0 ;
4767 PyObject * obj1 = 0 ;
4768 PyObject * obj2 = 0 ;
4769 PyObject * obj3 = 0 ;
4770 PyObject * obj4 = 0 ;
4771 PyObject * obj5 = 0 ;
4772 PyObject * obj6 = 0 ;
4773 char *kwnames[] = {
4774 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4775 };
4776
4777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4778 {
4779 arg1 = wxString_in_helper(obj0);
4780 if (arg1 == NULL) SWIG_fail;
4781 temp1 = true;
4782 }
4783 if (obj1) {
4784 {
4785 arg2 = wxString_in_helper(obj1);
4786 if (arg2 == NULL) SWIG_fail;
4787 temp2 = true;
4788 }
4789 }
4790 if (obj2) {
4791 {
4792 arg3 = wxString_in_helper(obj2);
4793 if (arg3 == NULL) SWIG_fail;
4794 temp3 = true;
4795 }
4796 }
4797 if (obj3) {
4798 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4799 if (SWIG_arg_fail(4)) SWIG_fail;
4800 }
4801 if (obj4) {
4802 {
4803 arg5 = (int)(SWIG_As_int(obj4));
4804 if (SWIG_arg_fail(5)) SWIG_fail;
4805 }
4806 }
4807 if (obj5) {
4808 {
4809 arg6 = (int)(SWIG_As_int(obj5));
4810 if (SWIG_arg_fail(6)) SWIG_fail;
4811 }
4812 }
4813 if (obj6) {
4814 {
4815 arg7 = (bool)(SWIG_As_bool(obj6));
4816 if (SWIG_arg_fail(7)) SWIG_fail;
4817 }
4818 }
4819 {
4820 if (!wxPyCheckForApp()) SWIG_fail;
4821 PyThreadState* __tstate = wxPyBeginAllowThreads();
4822 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4823
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 {
4828 #if wxUSE_UNICODE
4829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4830 #else
4831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4832 #endif
4833 }
4834 {
4835 if (temp1)
4836 delete arg1;
4837 }
4838 {
4839 if (temp2)
4840 delete arg2;
4841 }
4842 {
4843 if (temp3)
4844 delete arg3;
4845 }
4846 return resultobj;
4847 fail:
4848 {
4849 if (temp1)
4850 delete arg1;
4851 }
4852 {
4853 if (temp2)
4854 delete arg2;
4855 }
4856 {
4857 if (temp3)
4858 delete arg3;
4859 }
4860 return NULL;
4861 }
4862
4863
4864 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4865 PyObject *resultobj;
4866 wxString *arg1 = 0 ;
4867 wxString const &arg2_defvalue = wxPyEmptyString ;
4868 wxString *arg2 = (wxString *) &arg2_defvalue ;
4869 wxString const &arg3_defvalue = wxPyEmptyString ;
4870 wxString *arg3 = (wxString *) &arg3_defvalue ;
4871 wxWindow *arg4 = (wxWindow *) NULL ;
4872 wxString result;
4873 bool temp1 = false ;
4874 bool temp2 = false ;
4875 bool temp3 = false ;
4876 PyObject * obj0 = 0 ;
4877 PyObject * obj1 = 0 ;
4878 PyObject * obj2 = 0 ;
4879 PyObject * obj3 = 0 ;
4880 char *kwnames[] = {
4881 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4882 };
4883
4884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4885 {
4886 arg1 = wxString_in_helper(obj0);
4887 if (arg1 == NULL) SWIG_fail;
4888 temp1 = true;
4889 }
4890 if (obj1) {
4891 {
4892 arg2 = wxString_in_helper(obj1);
4893 if (arg2 == NULL) SWIG_fail;
4894 temp2 = true;
4895 }
4896 }
4897 if (obj2) {
4898 {
4899 arg3 = wxString_in_helper(obj2);
4900 if (arg3 == NULL) SWIG_fail;
4901 temp3 = true;
4902 }
4903 }
4904 if (obj3) {
4905 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4906 if (SWIG_arg_fail(4)) SWIG_fail;
4907 }
4908 {
4909 if (!wxPyCheckForApp()) SWIG_fail;
4910 PyThreadState* __tstate = wxPyBeginAllowThreads();
4911 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4912
4913 wxPyEndAllowThreads(__tstate);
4914 if (PyErr_Occurred()) SWIG_fail;
4915 }
4916 {
4917 #if wxUSE_UNICODE
4918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4919 #else
4920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4921 #endif
4922 }
4923 {
4924 if (temp1)
4925 delete arg1;
4926 }
4927 {
4928 if (temp2)
4929 delete arg2;
4930 }
4931 {
4932 if (temp3)
4933 delete arg3;
4934 }
4935 return resultobj;
4936 fail:
4937 {
4938 if (temp1)
4939 delete arg1;
4940 }
4941 {
4942 if (temp2)
4943 delete arg2;
4944 }
4945 {
4946 if (temp3)
4947 delete arg3;
4948 }
4949 return NULL;
4950 }
4951
4952
4953 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4954 PyObject *resultobj;
4955 wxString *arg1 = 0 ;
4956 wxString *arg2 = 0 ;
4957 int arg3 ;
4958 wxString *arg4 = (wxString *) 0 ;
4959 wxWindow *arg5 = (wxWindow *) NULL ;
4960 int arg6 = (int) -1 ;
4961 int arg7 = (int) -1 ;
4962 bool arg8 = (bool) true ;
4963 int arg9 = (int) 150 ;
4964 int arg10 = (int) 200 ;
4965 wxString result;
4966 bool temp1 = false ;
4967 bool temp2 = false ;
4968 PyObject * obj0 = 0 ;
4969 PyObject * obj1 = 0 ;
4970 PyObject * obj2 = 0 ;
4971 PyObject * obj3 = 0 ;
4972 PyObject * obj4 = 0 ;
4973 PyObject * obj5 = 0 ;
4974 PyObject * obj6 = 0 ;
4975 PyObject * obj7 = 0 ;
4976 PyObject * obj8 = 0 ;
4977 char *kwnames[] = {
4978 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
4979 };
4980
4981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4982 {
4983 arg1 = wxString_in_helper(obj0);
4984 if (arg1 == NULL) SWIG_fail;
4985 temp1 = true;
4986 }
4987 {
4988 arg2 = wxString_in_helper(obj1);
4989 if (arg2 == NULL) SWIG_fail;
4990 temp2 = true;
4991 }
4992 {
4993 arg3 = PyList_Size(obj2);
4994 arg4 = wxString_LIST_helper(obj2);
4995 if (arg4 == NULL) SWIG_fail;
4996 }
4997 if (obj3) {
4998 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4999 if (SWIG_arg_fail(5)) SWIG_fail;
5000 }
5001 if (obj4) {
5002 {
5003 arg6 = (int)(SWIG_As_int(obj4));
5004 if (SWIG_arg_fail(6)) SWIG_fail;
5005 }
5006 }
5007 if (obj5) {
5008 {
5009 arg7 = (int)(SWIG_As_int(obj5));
5010 if (SWIG_arg_fail(7)) SWIG_fail;
5011 }
5012 }
5013 if (obj6) {
5014 {
5015 arg8 = (bool)(SWIG_As_bool(obj6));
5016 if (SWIG_arg_fail(8)) SWIG_fail;
5017 }
5018 }
5019 if (obj7) {
5020 {
5021 arg9 = (int)(SWIG_As_int(obj7));
5022 if (SWIG_arg_fail(9)) SWIG_fail;
5023 }
5024 }
5025 if (obj8) {
5026 {
5027 arg10 = (int)(SWIG_As_int(obj8));
5028 if (SWIG_arg_fail(10)) SWIG_fail;
5029 }
5030 }
5031 {
5032 if (!wxPyCheckForApp()) SWIG_fail;
5033 PyThreadState* __tstate = wxPyBeginAllowThreads();
5034 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5035
5036 wxPyEndAllowThreads(__tstate);
5037 if (PyErr_Occurred()) SWIG_fail;
5038 }
5039 {
5040 #if wxUSE_UNICODE
5041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5042 #else
5043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5044 #endif
5045 }
5046 {
5047 if (temp1)
5048 delete arg1;
5049 }
5050 {
5051 if (temp2)
5052 delete arg2;
5053 }
5054 {
5055 if (arg4) delete [] arg4;
5056 }
5057 return resultobj;
5058 fail:
5059 {
5060 if (temp1)
5061 delete arg1;
5062 }
5063 {
5064 if (temp2)
5065 delete arg2;
5066 }
5067 {
5068 if (arg4) delete [] arg4;
5069 }
5070 return NULL;
5071 }
5072
5073
5074 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5075 PyObject *resultobj;
5076 wxString *arg1 = 0 ;
5077 wxString *arg2 = 0 ;
5078 int arg3 ;
5079 wxString *arg4 = (wxString *) 0 ;
5080 wxWindow *arg5 = (wxWindow *) NULL ;
5081 int arg6 = (int) -1 ;
5082 int arg7 = (int) -1 ;
5083 bool arg8 = (bool) true ;
5084 int arg9 = (int) 150 ;
5085 int arg10 = (int) 200 ;
5086 int result;
5087 bool temp1 = false ;
5088 bool temp2 = false ;
5089 PyObject * obj0 = 0 ;
5090 PyObject * obj1 = 0 ;
5091 PyObject * obj2 = 0 ;
5092 PyObject * obj3 = 0 ;
5093 PyObject * obj4 = 0 ;
5094 PyObject * obj5 = 0 ;
5095 PyObject * obj6 = 0 ;
5096 PyObject * obj7 = 0 ;
5097 PyObject * obj8 = 0 ;
5098 char *kwnames[] = {
5099 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5100 };
5101
5102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5103 {
5104 arg1 = wxString_in_helper(obj0);
5105 if (arg1 == NULL) SWIG_fail;
5106 temp1 = true;
5107 }
5108 {
5109 arg2 = wxString_in_helper(obj1);
5110 if (arg2 == NULL) SWIG_fail;
5111 temp2 = true;
5112 }
5113 {
5114 arg3 = PyList_Size(obj2);
5115 arg4 = wxString_LIST_helper(obj2);
5116 if (arg4 == NULL) SWIG_fail;
5117 }
5118 if (obj3) {
5119 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5120 if (SWIG_arg_fail(5)) SWIG_fail;
5121 }
5122 if (obj4) {
5123 {
5124 arg6 = (int)(SWIG_As_int(obj4));
5125 if (SWIG_arg_fail(6)) SWIG_fail;
5126 }
5127 }
5128 if (obj5) {
5129 {
5130 arg7 = (int)(SWIG_As_int(obj5));
5131 if (SWIG_arg_fail(7)) SWIG_fail;
5132 }
5133 }
5134 if (obj6) {
5135 {
5136 arg8 = (bool)(SWIG_As_bool(obj6));
5137 if (SWIG_arg_fail(8)) SWIG_fail;
5138 }
5139 }
5140 if (obj7) {
5141 {
5142 arg9 = (int)(SWIG_As_int(obj7));
5143 if (SWIG_arg_fail(9)) SWIG_fail;
5144 }
5145 }
5146 if (obj8) {
5147 {
5148 arg10 = (int)(SWIG_As_int(obj8));
5149 if (SWIG_arg_fail(10)) SWIG_fail;
5150 }
5151 }
5152 {
5153 if (!wxPyCheckForApp()) SWIG_fail;
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5156
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 {
5161 resultobj = SWIG_From_int((int)(result));
5162 }
5163 {
5164 if (temp1)
5165 delete arg1;
5166 }
5167 {
5168 if (temp2)
5169 delete arg2;
5170 }
5171 {
5172 if (arg4) delete [] arg4;
5173 }
5174 return resultobj;
5175 fail:
5176 {
5177 if (temp1)
5178 delete arg1;
5179 }
5180 {
5181 if (temp2)
5182 delete arg2;
5183 }
5184 {
5185 if (arg4) delete [] arg4;
5186 }
5187 return NULL;
5188 }
5189
5190
5191 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5192 PyObject *resultobj;
5193 wxString *arg1 = 0 ;
5194 wxString const &arg2_defvalue = wxPyEmptyString ;
5195 wxString *arg2 = (wxString *) &arg2_defvalue ;
5196 int arg3 = (int) wxOK|wxCENTRE ;
5197 wxWindow *arg4 = (wxWindow *) NULL ;
5198 int arg5 = (int) -1 ;
5199 int arg6 = (int) -1 ;
5200 int result;
5201 bool temp1 = false ;
5202 bool temp2 = false ;
5203 PyObject * obj0 = 0 ;
5204 PyObject * obj1 = 0 ;
5205 PyObject * obj2 = 0 ;
5206 PyObject * obj3 = 0 ;
5207 PyObject * obj4 = 0 ;
5208 PyObject * obj5 = 0 ;
5209 char *kwnames[] = {
5210 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5211 };
5212
5213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5214 {
5215 arg1 = wxString_in_helper(obj0);
5216 if (arg1 == NULL) SWIG_fail;
5217 temp1 = true;
5218 }
5219 if (obj1) {
5220 {
5221 arg2 = wxString_in_helper(obj1);
5222 if (arg2 == NULL) SWIG_fail;
5223 temp2 = true;
5224 }
5225 }
5226 if (obj2) {
5227 {
5228 arg3 = (int)(SWIG_As_int(obj2));
5229 if (SWIG_arg_fail(3)) SWIG_fail;
5230 }
5231 }
5232 if (obj3) {
5233 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5234 if (SWIG_arg_fail(4)) SWIG_fail;
5235 }
5236 if (obj4) {
5237 {
5238 arg5 = (int)(SWIG_As_int(obj4));
5239 if (SWIG_arg_fail(5)) SWIG_fail;
5240 }
5241 }
5242 if (obj5) {
5243 {
5244 arg6 = (int)(SWIG_As_int(obj5));
5245 if (SWIG_arg_fail(6)) SWIG_fail;
5246 }
5247 }
5248 {
5249 if (!wxPyCheckForApp()) SWIG_fail;
5250 PyThreadState* __tstate = wxPyBeginAllowThreads();
5251 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5252
5253 wxPyEndAllowThreads(__tstate);
5254 if (PyErr_Occurred()) SWIG_fail;
5255 }
5256 {
5257 resultobj = SWIG_From_int((int)(result));
5258 }
5259 {
5260 if (temp1)
5261 delete arg1;
5262 }
5263 {
5264 if (temp2)
5265 delete arg2;
5266 }
5267 return resultobj;
5268 fail:
5269 {
5270 if (temp1)
5271 delete arg1;
5272 }
5273 {
5274 if (temp2)
5275 delete arg2;
5276 }
5277 return NULL;
5278 }
5279
5280
5281 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5282 PyObject *resultobj;
5283 wxString *arg1 = 0 ;
5284 wxString *arg2 = 0 ;
5285 wxString *arg3 = 0 ;
5286 long arg4 ;
5287 long arg5 = (long) 0 ;
5288 long arg6 = (long) 100 ;
5289 wxWindow *arg7 = (wxWindow *) NULL ;
5290 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5291 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5292 long result;
5293 bool temp1 = false ;
5294 bool temp2 = false ;
5295 bool temp3 = false ;
5296 wxPoint temp8 ;
5297 PyObject * obj0 = 0 ;
5298 PyObject * obj1 = 0 ;
5299 PyObject * obj2 = 0 ;
5300 PyObject * obj3 = 0 ;
5301 PyObject * obj4 = 0 ;
5302 PyObject * obj5 = 0 ;
5303 PyObject * obj6 = 0 ;
5304 PyObject * obj7 = 0 ;
5305 char *kwnames[] = {
5306 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5307 };
5308
5309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5310 {
5311 arg1 = wxString_in_helper(obj0);
5312 if (arg1 == NULL) SWIG_fail;
5313 temp1 = true;
5314 }
5315 {
5316 arg2 = wxString_in_helper(obj1);
5317 if (arg2 == NULL) SWIG_fail;
5318 temp2 = true;
5319 }
5320 {
5321 arg3 = wxString_in_helper(obj2);
5322 if (arg3 == NULL) SWIG_fail;
5323 temp3 = true;
5324 }
5325 {
5326 arg4 = (long)(SWIG_As_long(obj3));
5327 if (SWIG_arg_fail(4)) SWIG_fail;
5328 }
5329 if (obj4) {
5330 {
5331 arg5 = (long)(SWIG_As_long(obj4));
5332 if (SWIG_arg_fail(5)) SWIG_fail;
5333 }
5334 }
5335 if (obj5) {
5336 {
5337 arg6 = (long)(SWIG_As_long(obj5));
5338 if (SWIG_arg_fail(6)) SWIG_fail;
5339 }
5340 }
5341 if (obj6) {
5342 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5343 if (SWIG_arg_fail(7)) SWIG_fail;
5344 }
5345 if (obj7) {
5346 {
5347 arg8 = &temp8;
5348 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5349 }
5350 }
5351 {
5352 if (!wxPyCheckForApp()) SWIG_fail;
5353 PyThreadState* __tstate = wxPyBeginAllowThreads();
5354 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5355
5356 wxPyEndAllowThreads(__tstate);
5357 if (PyErr_Occurred()) SWIG_fail;
5358 }
5359 {
5360 resultobj = SWIG_From_long((long)(result));
5361 }
5362 {
5363 if (temp1)
5364 delete arg1;
5365 }
5366 {
5367 if (temp2)
5368 delete arg2;
5369 }
5370 {
5371 if (temp3)
5372 delete arg3;
5373 }
5374 return resultobj;
5375 fail:
5376 {
5377 if (temp1)
5378 delete arg1;
5379 }
5380 {
5381 if (temp2)
5382 delete arg2;
5383 }
5384 {
5385 if (temp3)
5386 delete arg3;
5387 }
5388 return NULL;
5389 }
5390
5391
5392 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5393 PyObject *resultobj;
5394 bool result;
5395 char *kwnames[] = {
5396 NULL
5397 };
5398
5399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5400 {
5401 if (!wxPyCheckForApp()) SWIG_fail;
5402 PyThreadState* __tstate = wxPyBeginAllowThreads();
5403 result = (bool)wxColourDisplay();
5404
5405 wxPyEndAllowThreads(__tstate);
5406 if (PyErr_Occurred()) SWIG_fail;
5407 }
5408 {
5409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5410 }
5411 return resultobj;
5412 fail:
5413 return NULL;
5414 }
5415
5416
5417 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5418 PyObject *resultobj;
5419 int result;
5420 char *kwnames[] = {
5421 NULL
5422 };
5423
5424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5425 {
5426 if (!wxPyCheckForApp()) SWIG_fail;
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 result = (int)wxDisplayDepth();
5429
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 {
5434 resultobj = SWIG_From_int((int)(result));
5435 }
5436 return resultobj;
5437 fail:
5438 return NULL;
5439 }
5440
5441
5442 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5443 PyObject *resultobj;
5444 int result;
5445 char *kwnames[] = {
5446 NULL
5447 };
5448
5449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5450 {
5451 if (!wxPyCheckForApp()) SWIG_fail;
5452 PyThreadState* __tstate = wxPyBeginAllowThreads();
5453 result = (int)wxGetDisplayDepth();
5454
5455 wxPyEndAllowThreads(__tstate);
5456 if (PyErr_Occurred()) SWIG_fail;
5457 }
5458 {
5459 resultobj = SWIG_From_int((int)(result));
5460 }
5461 return resultobj;
5462 fail:
5463 return NULL;
5464 }
5465
5466
5467 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5468 PyObject *resultobj;
5469 int *arg1 = (int *) 0 ;
5470 int *arg2 = (int *) 0 ;
5471 int temp1 ;
5472 int res1 = 0 ;
5473 int temp2 ;
5474 int res2 = 0 ;
5475 char *kwnames[] = {
5476 NULL
5477 };
5478
5479 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5480 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5482 {
5483 if (!wxPyCheckForApp()) SWIG_fail;
5484 PyThreadState* __tstate = wxPyBeginAllowThreads();
5485 wxDisplaySize(arg1,arg2);
5486
5487 wxPyEndAllowThreads(__tstate);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 Py_INCREF(Py_None); resultobj = Py_None;
5491 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5492 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5493 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5494 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5495 return resultobj;
5496 fail:
5497 return NULL;
5498 }
5499
5500
5501 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5502 PyObject *resultobj;
5503 wxSize result;
5504 char *kwnames[] = {
5505 NULL
5506 };
5507
5508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5509 {
5510 if (!wxPyCheckForApp()) SWIG_fail;
5511 PyThreadState* __tstate = wxPyBeginAllowThreads();
5512 result = wxGetDisplaySize();
5513
5514 wxPyEndAllowThreads(__tstate);
5515 if (PyErr_Occurred()) SWIG_fail;
5516 }
5517 {
5518 wxSize * resultptr;
5519 resultptr = new wxSize((wxSize &)(result));
5520 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5521 }
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj;
5530 int *arg1 = (int *) 0 ;
5531 int *arg2 = (int *) 0 ;
5532 int temp1 ;
5533 int res1 = 0 ;
5534 int temp2 ;
5535 int res2 = 0 ;
5536 char *kwnames[] = {
5537 NULL
5538 };
5539
5540 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5541 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5543 {
5544 if (!wxPyCheckForApp()) SWIG_fail;
5545 PyThreadState* __tstate = wxPyBeginAllowThreads();
5546 wxDisplaySizeMM(arg1,arg2);
5547
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 Py_INCREF(Py_None); resultobj = Py_None;
5552 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5553 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5554 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5555 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj;
5564 wxSize result;
5565 char *kwnames[] = {
5566 NULL
5567 };
5568
5569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5570 {
5571 if (!wxPyCheckForApp()) SWIG_fail;
5572 PyThreadState* __tstate = wxPyBeginAllowThreads();
5573 result = wxGetDisplaySizeMM();
5574
5575 wxPyEndAllowThreads(__tstate);
5576 if (PyErr_Occurred()) SWIG_fail;
5577 }
5578 {
5579 wxSize * resultptr;
5580 resultptr = new wxSize((wxSize &)(result));
5581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5582 }
5583 return resultobj;
5584 fail:
5585 return NULL;
5586 }
5587
5588
5589 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5590 PyObject *resultobj;
5591 int *arg1 = (int *) 0 ;
5592 int *arg2 = (int *) 0 ;
5593 int *arg3 = (int *) 0 ;
5594 int *arg4 = (int *) 0 ;
5595 int temp1 ;
5596 int res1 = 0 ;
5597 int temp2 ;
5598 int res2 = 0 ;
5599 int temp3 ;
5600 int res3 = 0 ;
5601 int temp4 ;
5602 int res4 = 0 ;
5603 char *kwnames[] = {
5604 NULL
5605 };
5606
5607 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5608 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5609 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5610 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5612 {
5613 if (!wxPyCheckForApp()) SWIG_fail;
5614 PyThreadState* __tstate = wxPyBeginAllowThreads();
5615 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5616
5617 wxPyEndAllowThreads(__tstate);
5618 if (PyErr_Occurred()) SWIG_fail;
5619 }
5620 Py_INCREF(Py_None); resultobj = Py_None;
5621 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5622 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5623 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5624 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5625 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5626 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5627 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5628 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5629 return resultobj;
5630 fail:
5631 return NULL;
5632 }
5633
5634
5635 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5636 PyObject *resultobj;
5637 wxRect result;
5638 char *kwnames[] = {
5639 NULL
5640 };
5641
5642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5643 {
5644 if (!wxPyCheckForApp()) SWIG_fail;
5645 PyThreadState* __tstate = wxPyBeginAllowThreads();
5646 result = wxGetClientDisplayRect();
5647
5648 wxPyEndAllowThreads(__tstate);
5649 if (PyErr_Occurred()) SWIG_fail;
5650 }
5651 {
5652 wxRect * resultptr;
5653 resultptr = new wxRect((wxRect &)(result));
5654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5655 }
5656 return resultobj;
5657 fail:
5658 return NULL;
5659 }
5660
5661
5662 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5663 PyObject *resultobj;
5664 wxCursor *arg1 = 0 ;
5665 PyObject * obj0 = 0 ;
5666 char *kwnames[] = {
5667 (char *) "cursor", NULL
5668 };
5669
5670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5671 {
5672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5673 if (SWIG_arg_fail(1)) SWIG_fail;
5674 if (arg1 == NULL) {
5675 SWIG_null_ref("wxCursor");
5676 }
5677 if (SWIG_arg_fail(1)) SWIG_fail;
5678 }
5679 {
5680 if (!wxPyCheckForApp()) SWIG_fail;
5681 PyThreadState* __tstate = wxPyBeginAllowThreads();
5682 wxSetCursor(*arg1);
5683
5684 wxPyEndAllowThreads(__tstate);
5685 if (PyErr_Occurred()) SWIG_fail;
5686 }
5687 Py_INCREF(Py_None); resultobj = Py_None;
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj;
5696 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5697 PyObject * obj0 = 0 ;
5698 char *kwnames[] = {
5699 (char *) "cursor", NULL
5700 };
5701
5702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5703 if (obj0) {
5704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5705 if (SWIG_arg_fail(1)) SWIG_fail;
5706 }
5707 {
5708 if (!wxPyCheckForApp()) SWIG_fail;
5709 PyThreadState* __tstate = wxPyBeginAllowThreads();
5710 wxBeginBusyCursor(arg1);
5711
5712 wxPyEndAllowThreads(__tstate);
5713 if (PyErr_Occurred()) SWIG_fail;
5714 }
5715 Py_INCREF(Py_None); resultobj = Py_None;
5716 return resultobj;
5717 fail:
5718 return NULL;
5719 }
5720
5721
5722 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5723 PyObject *resultobj;
5724 wxWindow *result;
5725 char *kwnames[] = {
5726 NULL
5727 };
5728
5729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5730 {
5731 if (!wxPyCheckForApp()) SWIG_fail;
5732 PyThreadState* __tstate = wxPyBeginAllowThreads();
5733 result = (wxWindow *)wxGetActiveWindow();
5734
5735 wxPyEndAllowThreads(__tstate);
5736 if (PyErr_Occurred()) SWIG_fail;
5737 }
5738 {
5739 resultobj = wxPyMake_wxObject(result, 0);
5740 }
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj;
5749 wxPoint *arg1 = 0 ;
5750 wxWindow *result;
5751 wxPoint temp1 ;
5752 PyObject * obj0 = 0 ;
5753 char *kwnames[] = {
5754 (char *) "pt", NULL
5755 };
5756
5757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5758 {
5759 arg1 = &temp1;
5760 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5761 }
5762 {
5763 if (!wxPyCheckForApp()) SWIG_fail;
5764 PyThreadState* __tstate = wxPyBeginAllowThreads();
5765 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5766
5767 wxPyEndAllowThreads(__tstate);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 {
5771 resultobj = wxPyMake_wxObject(result, 0);
5772 }
5773 return resultobj;
5774 fail:
5775 return NULL;
5776 }
5777
5778
5779 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj;
5781 wxPoint *arg1 = 0 ;
5782 wxWindow *result;
5783 wxPoint temp1 ;
5784 PyObject * obj0 = 0 ;
5785 char *kwnames[] = {
5786 (char *) "pt", NULL
5787 };
5788
5789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5790 {
5791 arg1 = &temp1;
5792 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5793 }
5794 {
5795 if (!wxPyCheckForApp()) SWIG_fail;
5796 PyThreadState* __tstate = wxPyBeginAllowThreads();
5797 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5798
5799 wxPyEndAllowThreads(__tstate);
5800 if (PyErr_Occurred()) SWIG_fail;
5801 }
5802 {
5803 resultobj = wxPyMake_wxObject(result, 0);
5804 }
5805 return resultobj;
5806 fail:
5807 return NULL;
5808 }
5809
5810
5811 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5812 PyObject *resultobj;
5813 wxWindow *arg1 = (wxWindow *) 0 ;
5814 wxWindow *result;
5815 PyObject * obj0 = 0 ;
5816 char *kwnames[] = {
5817 (char *) "win", NULL
5818 };
5819
5820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5822 if (SWIG_arg_fail(1)) SWIG_fail;
5823 {
5824 if (!wxPyCheckForApp()) SWIG_fail;
5825 PyThreadState* __tstate = wxPyBeginAllowThreads();
5826 result = (wxWindow *)wxGetTopLevelParent(arg1);
5827
5828 wxPyEndAllowThreads(__tstate);
5829 if (PyErr_Occurred()) SWIG_fail;
5830 }
5831 {
5832 resultobj = wxPyMake_wxObject(result, 0);
5833 }
5834 return resultobj;
5835 fail:
5836 return NULL;
5837 }
5838
5839
5840 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5841 PyObject *resultobj;
5842 wxKeyCode arg1 ;
5843 bool result;
5844 PyObject * obj0 = 0 ;
5845 char *kwnames[] = {
5846 (char *) "key", NULL
5847 };
5848
5849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5850 {
5851 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5852 if (SWIG_arg_fail(1)) SWIG_fail;
5853 }
5854 {
5855 if (!wxPyCheckForApp()) SWIG_fail;
5856 PyThreadState* __tstate = wxPyBeginAllowThreads();
5857 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5858
5859 wxPyEndAllowThreads(__tstate);
5860 if (PyErr_Occurred()) SWIG_fail;
5861 }
5862 {
5863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5864 }
5865 return resultobj;
5866 fail:
5867 return NULL;
5868 }
5869
5870
5871 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5872 PyObject *resultobj;
5873 char *kwnames[] = {
5874 NULL
5875 };
5876
5877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5878 {
5879 if (!wxPyCheckForApp()) SWIG_fail;
5880 PyThreadState* __tstate = wxPyBeginAllowThreads();
5881 wxWakeUpMainThread();
5882
5883 wxPyEndAllowThreads(__tstate);
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 Py_INCREF(Py_None); resultobj = Py_None;
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5894 PyObject *resultobj;
5895 char *kwnames[] = {
5896 NULL
5897 };
5898
5899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5900 {
5901 if (!wxPyCheckForApp()) SWIG_fail;
5902 PyThreadState* __tstate = wxPyBeginAllowThreads();
5903 wxMutexGuiEnter();
5904
5905 wxPyEndAllowThreads(__tstate);
5906 if (PyErr_Occurred()) SWIG_fail;
5907 }
5908 Py_INCREF(Py_None); resultobj = Py_None;
5909 return resultobj;
5910 fail:
5911 return NULL;
5912 }
5913
5914
5915 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5916 PyObject *resultobj;
5917 char *kwnames[] = {
5918 NULL
5919 };
5920
5921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5922 {
5923 if (!wxPyCheckForApp()) SWIG_fail;
5924 PyThreadState* __tstate = wxPyBeginAllowThreads();
5925 wxMutexGuiLeave();
5926
5927 wxPyEndAllowThreads(__tstate);
5928 if (PyErr_Occurred()) SWIG_fail;
5929 }
5930 Py_INCREF(Py_None); resultobj = Py_None;
5931 return resultobj;
5932 fail:
5933 return NULL;
5934 }
5935
5936
5937 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5938 PyObject *resultobj;
5939 wxMutexGuiLocker *result;
5940 char *kwnames[] = {
5941 NULL
5942 };
5943
5944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5945 {
5946 if (!wxPyCheckForApp()) SWIG_fail;
5947 PyThreadState* __tstate = wxPyBeginAllowThreads();
5948 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5949
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5961 PyObject *resultobj;
5962 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5963 PyObject * obj0 = 0 ;
5964 char *kwnames[] = {
5965 (char *) "self", NULL
5966 };
5967
5968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5970 if (SWIG_arg_fail(1)) SWIG_fail;
5971 {
5972 PyThreadState* __tstate = wxPyBeginAllowThreads();
5973 delete arg1;
5974
5975 wxPyEndAllowThreads(__tstate);
5976 if (PyErr_Occurred()) SWIG_fail;
5977 }
5978 Py_INCREF(Py_None); resultobj = Py_None;
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
5986 PyObject *obj;
5987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5988 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
5989 Py_INCREF(obj);
5990 return Py_BuildValue((char *)"");
5991 }
5992 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
5993 PyObject *resultobj;
5994 bool result;
5995 char *kwnames[] = {
5996 NULL
5997 };
5998
5999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6000 {
6001 PyThreadState* __tstate = wxPyBeginAllowThreads();
6002 result = (bool)wxThread_IsMain();
6003
6004 wxPyEndAllowThreads(__tstate);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 {
6008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6009 }
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj;
6018 wxString *arg1 = 0 ;
6019 wxToolTip *result;
6020 bool temp1 = false ;
6021 PyObject * obj0 = 0 ;
6022 char *kwnames[] = {
6023 (char *) "tip", NULL
6024 };
6025
6026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6027 {
6028 arg1 = wxString_in_helper(obj0);
6029 if (arg1 == NULL) SWIG_fail;
6030 temp1 = true;
6031 }
6032 {
6033 if (!wxPyCheckForApp()) SWIG_fail;
6034 PyThreadState* __tstate = wxPyBeginAllowThreads();
6035 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6036
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 {
6041 resultobj = wxPyMake_wxObject(result, 1);
6042 }
6043 {
6044 if (temp1)
6045 delete arg1;
6046 }
6047 return resultobj;
6048 fail:
6049 {
6050 if (temp1)
6051 delete arg1;
6052 }
6053 return NULL;
6054 }
6055
6056
6057 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6058 PyObject *resultobj;
6059 wxToolTip *arg1 = (wxToolTip *) 0 ;
6060 wxString *arg2 = 0 ;
6061 bool temp2 = false ;
6062 PyObject * obj0 = 0 ;
6063 PyObject * obj1 = 0 ;
6064 char *kwnames[] = {
6065 (char *) "self",(char *) "tip", NULL
6066 };
6067
6068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6070 if (SWIG_arg_fail(1)) SWIG_fail;
6071 {
6072 arg2 = wxString_in_helper(obj1);
6073 if (arg2 == NULL) SWIG_fail;
6074 temp2 = true;
6075 }
6076 {
6077 PyThreadState* __tstate = wxPyBeginAllowThreads();
6078 (arg1)->SetTip((wxString const &)*arg2);
6079
6080 wxPyEndAllowThreads(__tstate);
6081 if (PyErr_Occurred()) SWIG_fail;
6082 }
6083 Py_INCREF(Py_None); resultobj = Py_None;
6084 {
6085 if (temp2)
6086 delete arg2;
6087 }
6088 return resultobj;
6089 fail:
6090 {
6091 if (temp2)
6092 delete arg2;
6093 }
6094 return NULL;
6095 }
6096
6097
6098 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6099 PyObject *resultobj;
6100 wxToolTip *arg1 = (wxToolTip *) 0 ;
6101 wxString result;
6102 PyObject * obj0 = 0 ;
6103 char *kwnames[] = {
6104 (char *) "self", NULL
6105 };
6106
6107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6109 if (SWIG_arg_fail(1)) SWIG_fail;
6110 {
6111 PyThreadState* __tstate = wxPyBeginAllowThreads();
6112 result = (arg1)->GetTip();
6113
6114 wxPyEndAllowThreads(__tstate);
6115 if (PyErr_Occurred()) SWIG_fail;
6116 }
6117 {
6118 #if wxUSE_UNICODE
6119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6120 #else
6121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6122 #endif
6123 }
6124 return resultobj;
6125 fail:
6126 return NULL;
6127 }
6128
6129
6130 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6131 PyObject *resultobj;
6132 wxToolTip *arg1 = (wxToolTip *) 0 ;
6133 wxWindow *result;
6134 PyObject * obj0 = 0 ;
6135 char *kwnames[] = {
6136 (char *) "self", NULL
6137 };
6138
6139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6141 if (SWIG_arg_fail(1)) SWIG_fail;
6142 {
6143 PyThreadState* __tstate = wxPyBeginAllowThreads();
6144 result = (wxWindow *)(arg1)->GetWindow();
6145
6146 wxPyEndAllowThreads(__tstate);
6147 if (PyErr_Occurred()) SWIG_fail;
6148 }
6149 {
6150 resultobj = wxPyMake_wxObject(result, 0);
6151 }
6152 return resultobj;
6153 fail:
6154 return NULL;
6155 }
6156
6157
6158 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6159 PyObject *resultobj;
6160 bool arg1 ;
6161 PyObject * obj0 = 0 ;
6162 char *kwnames[] = {
6163 (char *) "flag", NULL
6164 };
6165
6166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6167 {
6168 arg1 = (bool)(SWIG_As_bool(obj0));
6169 if (SWIG_arg_fail(1)) SWIG_fail;
6170 }
6171 {
6172 PyThreadState* __tstate = wxPyBeginAllowThreads();
6173 wxToolTip::Enable(arg1);
6174
6175 wxPyEndAllowThreads(__tstate);
6176 if (PyErr_Occurred()) SWIG_fail;
6177 }
6178 Py_INCREF(Py_None); resultobj = Py_None;
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj;
6187 long arg1 ;
6188 PyObject * obj0 = 0 ;
6189 char *kwnames[] = {
6190 (char *) "milliseconds", NULL
6191 };
6192
6193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6194 {
6195 arg1 = (long)(SWIG_As_long(obj0));
6196 if (SWIG_arg_fail(1)) SWIG_fail;
6197 }
6198 {
6199 PyThreadState* __tstate = wxPyBeginAllowThreads();
6200 wxToolTip::SetDelay(arg1);
6201
6202 wxPyEndAllowThreads(__tstate);
6203 if (PyErr_Occurred()) SWIG_fail;
6204 }
6205 Py_INCREF(Py_None); resultobj = Py_None;
6206 return resultobj;
6207 fail:
6208 return NULL;
6209 }
6210
6211
6212 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6213 PyObject *obj;
6214 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6215 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6216 Py_INCREF(obj);
6217 return Py_BuildValue((char *)"");
6218 }
6219 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6220 PyObject *resultobj;
6221 wxWindow *arg1 = (wxWindow *) 0 ;
6222 wxSize *arg2 = 0 ;
6223 wxCaret *result;
6224 wxSize temp2 ;
6225 PyObject * obj0 = 0 ;
6226 PyObject * obj1 = 0 ;
6227 char *kwnames[] = {
6228 (char *) "window",(char *) "size", NULL
6229 };
6230
6231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6233 if (SWIG_arg_fail(1)) SWIG_fail;
6234 {
6235 arg2 = &temp2;
6236 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6237 }
6238 {
6239 if (!wxPyCheckForApp()) SWIG_fail;
6240 PyThreadState* __tstate = wxPyBeginAllowThreads();
6241 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6242
6243 wxPyEndAllowThreads(__tstate);
6244 if (PyErr_Occurred()) SWIG_fail;
6245 }
6246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6247 return resultobj;
6248 fail:
6249 return NULL;
6250 }
6251
6252
6253 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6254 PyObject *resultobj;
6255 wxCaret *arg1 = (wxCaret *) 0 ;
6256 PyObject * obj0 = 0 ;
6257 char *kwnames[] = {
6258 (char *) "self", NULL
6259 };
6260
6261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
6262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6263 if (SWIG_arg_fail(1)) SWIG_fail;
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 delete arg1;
6267
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 Py_INCREF(Py_None); resultobj = Py_None;
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj;
6280 wxCaret *arg1 = (wxCaret *) 0 ;
6281 bool result;
6282 PyObject * obj0 = 0 ;
6283 char *kwnames[] = {
6284 (char *) "self", NULL
6285 };
6286
6287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6289 if (SWIG_arg_fail(1)) SWIG_fail;
6290 {
6291 PyThreadState* __tstate = wxPyBeginAllowThreads();
6292 result = (bool)(arg1)->IsOk();
6293
6294 wxPyEndAllowThreads(__tstate);
6295 if (PyErr_Occurred()) SWIG_fail;
6296 }
6297 {
6298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6299 }
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj;
6308 wxCaret *arg1 = (wxCaret *) 0 ;
6309 bool result;
6310 PyObject * obj0 = 0 ;
6311 char *kwnames[] = {
6312 (char *) "self", NULL
6313 };
6314
6315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6317 if (SWIG_arg_fail(1)) SWIG_fail;
6318 {
6319 PyThreadState* __tstate = wxPyBeginAllowThreads();
6320 result = (bool)(arg1)->IsVisible();
6321
6322 wxPyEndAllowThreads(__tstate);
6323 if (PyErr_Occurred()) SWIG_fail;
6324 }
6325 {
6326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6327 }
6328 return resultobj;
6329 fail:
6330 return NULL;
6331 }
6332
6333
6334 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6335 PyObject *resultobj;
6336 wxCaret *arg1 = (wxCaret *) 0 ;
6337 wxPoint result;
6338 PyObject * obj0 = 0 ;
6339 char *kwnames[] = {
6340 (char *) "self", NULL
6341 };
6342
6343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6345 if (SWIG_arg_fail(1)) SWIG_fail;
6346 {
6347 PyThreadState* __tstate = wxPyBeginAllowThreads();
6348 result = (arg1)->GetPosition();
6349
6350 wxPyEndAllowThreads(__tstate);
6351 if (PyErr_Occurred()) SWIG_fail;
6352 }
6353 {
6354 wxPoint * resultptr;
6355 resultptr = new wxPoint((wxPoint &)(result));
6356 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6357 }
6358 return resultobj;
6359 fail:
6360 return NULL;
6361 }
6362
6363
6364 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6365 PyObject *resultobj;
6366 wxCaret *arg1 = (wxCaret *) 0 ;
6367 int *arg2 = (int *) 0 ;
6368 int *arg3 = (int *) 0 ;
6369 int temp2 ;
6370 int res2 = 0 ;
6371 int temp3 ;
6372 int res3 = 0 ;
6373 PyObject * obj0 = 0 ;
6374 char *kwnames[] = {
6375 (char *) "self", NULL
6376 };
6377
6378 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6379 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6382 if (SWIG_arg_fail(1)) SWIG_fail;
6383 {
6384 PyThreadState* __tstate = wxPyBeginAllowThreads();
6385 (arg1)->GetPosition(arg2,arg3);
6386
6387 wxPyEndAllowThreads(__tstate);
6388 if (PyErr_Occurred()) SWIG_fail;
6389 }
6390 Py_INCREF(Py_None); resultobj = Py_None;
6391 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6392 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6393 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6394 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj;
6403 wxCaret *arg1 = (wxCaret *) 0 ;
6404 wxSize result;
6405 PyObject * obj0 = 0 ;
6406 char *kwnames[] = {
6407 (char *) "self", NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6412 if (SWIG_arg_fail(1)) SWIG_fail;
6413 {
6414 PyThreadState* __tstate = wxPyBeginAllowThreads();
6415 result = (arg1)->GetSize();
6416
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 {
6421 wxSize * resultptr;
6422 resultptr = new wxSize((wxSize &)(result));
6423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6424 }
6425 return resultobj;
6426 fail:
6427 return NULL;
6428 }
6429
6430
6431 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6432 PyObject *resultobj;
6433 wxCaret *arg1 = (wxCaret *) 0 ;
6434 int *arg2 = (int *) 0 ;
6435 int *arg3 = (int *) 0 ;
6436 int temp2 ;
6437 int res2 = 0 ;
6438 int temp3 ;
6439 int res3 = 0 ;
6440 PyObject * obj0 = 0 ;
6441 char *kwnames[] = {
6442 (char *) "self", NULL
6443 };
6444
6445 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6446 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6449 if (SWIG_arg_fail(1)) SWIG_fail;
6450 {
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 (arg1)->GetSize(arg2,arg3);
6453
6454 wxPyEndAllowThreads(__tstate);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 Py_INCREF(Py_None); resultobj = Py_None;
6458 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6459 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6460 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6461 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6462 return resultobj;
6463 fail:
6464 return NULL;
6465 }
6466
6467
6468 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6469 PyObject *resultobj;
6470 wxCaret *arg1 = (wxCaret *) 0 ;
6471 wxWindow *result;
6472 PyObject * obj0 = 0 ;
6473 char *kwnames[] = {
6474 (char *) "self", NULL
6475 };
6476
6477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6479 if (SWIG_arg_fail(1)) SWIG_fail;
6480 {
6481 PyThreadState* __tstate = wxPyBeginAllowThreads();
6482 result = (wxWindow *)(arg1)->GetWindow();
6483
6484 wxPyEndAllowThreads(__tstate);
6485 if (PyErr_Occurred()) SWIG_fail;
6486 }
6487 {
6488 resultobj = wxPyMake_wxObject(result, 0);
6489 }
6490 return resultobj;
6491 fail:
6492 return NULL;
6493 }
6494
6495
6496 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6497 PyObject *resultobj;
6498 wxCaret *arg1 = (wxCaret *) 0 ;
6499 int arg2 ;
6500 int arg3 ;
6501 PyObject * obj0 = 0 ;
6502 PyObject * obj1 = 0 ;
6503 PyObject * obj2 = 0 ;
6504 char *kwnames[] = {
6505 (char *) "self",(char *) "x",(char *) "y", NULL
6506 };
6507
6508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6510 if (SWIG_arg_fail(1)) SWIG_fail;
6511 {
6512 arg2 = (int)(SWIG_As_int(obj1));
6513 if (SWIG_arg_fail(2)) SWIG_fail;
6514 }
6515 {
6516 arg3 = (int)(SWIG_As_int(obj2));
6517 if (SWIG_arg_fail(3)) SWIG_fail;
6518 }
6519 {
6520 PyThreadState* __tstate = wxPyBeginAllowThreads();
6521 (arg1)->Move(arg2,arg3);
6522
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 Py_INCREF(Py_None); resultobj = Py_None;
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj;
6535 wxCaret *arg1 = (wxCaret *) 0 ;
6536 wxPoint *arg2 = 0 ;
6537 wxPoint temp2 ;
6538 PyObject * obj0 = 0 ;
6539 PyObject * obj1 = 0 ;
6540 char *kwnames[] = {
6541 (char *) "self",(char *) "pt", NULL
6542 };
6543
6544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6546 if (SWIG_arg_fail(1)) SWIG_fail;
6547 {
6548 arg2 = &temp2;
6549 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6550 }
6551 {
6552 PyThreadState* __tstate = wxPyBeginAllowThreads();
6553 (arg1)->Move((wxPoint const &)*arg2);
6554
6555 wxPyEndAllowThreads(__tstate);
6556 if (PyErr_Occurred()) SWIG_fail;
6557 }
6558 Py_INCREF(Py_None); resultobj = Py_None;
6559 return resultobj;
6560 fail:
6561 return NULL;
6562 }
6563
6564
6565 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6566 PyObject *resultobj;
6567 wxCaret *arg1 = (wxCaret *) 0 ;
6568 int arg2 ;
6569 int arg3 ;
6570 PyObject * obj0 = 0 ;
6571 PyObject * obj1 = 0 ;
6572 PyObject * obj2 = 0 ;
6573 char *kwnames[] = {
6574 (char *) "self",(char *) "width",(char *) "height", NULL
6575 };
6576
6577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6579 if (SWIG_arg_fail(1)) SWIG_fail;
6580 {
6581 arg2 = (int)(SWIG_As_int(obj1));
6582 if (SWIG_arg_fail(2)) SWIG_fail;
6583 }
6584 {
6585 arg3 = (int)(SWIG_As_int(obj2));
6586 if (SWIG_arg_fail(3)) SWIG_fail;
6587 }
6588 {
6589 PyThreadState* __tstate = wxPyBeginAllowThreads();
6590 (arg1)->SetSize(arg2,arg3);
6591
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 Py_INCREF(Py_None); resultobj = Py_None;
6596 return resultobj;
6597 fail:
6598 return NULL;
6599 }
6600
6601
6602 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6603 PyObject *resultobj;
6604 wxCaret *arg1 = (wxCaret *) 0 ;
6605 wxSize *arg2 = 0 ;
6606 wxSize temp2 ;
6607 PyObject * obj0 = 0 ;
6608 PyObject * obj1 = 0 ;
6609 char *kwnames[] = {
6610 (char *) "self",(char *) "size", NULL
6611 };
6612
6613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6615 if (SWIG_arg_fail(1)) SWIG_fail;
6616 {
6617 arg2 = &temp2;
6618 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6619 }
6620 {
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 (arg1)->SetSize((wxSize const &)*arg2);
6623
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 Py_INCREF(Py_None); resultobj = Py_None;
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj;
6636 wxCaret *arg1 = (wxCaret *) 0 ;
6637 int arg2 = (int) true ;
6638 PyObject * obj0 = 0 ;
6639 PyObject * obj1 = 0 ;
6640 char *kwnames[] = {
6641 (char *) "self",(char *) "show", NULL
6642 };
6643
6644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6646 if (SWIG_arg_fail(1)) SWIG_fail;
6647 if (obj1) {
6648 {
6649 arg2 = (int)(SWIG_As_int(obj1));
6650 if (SWIG_arg_fail(2)) SWIG_fail;
6651 }
6652 }
6653 {
6654 PyThreadState* __tstate = wxPyBeginAllowThreads();
6655 (arg1)->Show(arg2);
6656
6657 wxPyEndAllowThreads(__tstate);
6658 if (PyErr_Occurred()) SWIG_fail;
6659 }
6660 Py_INCREF(Py_None); resultobj = Py_None;
6661 return resultobj;
6662 fail:
6663 return NULL;
6664 }
6665
6666
6667 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6668 PyObject *resultobj;
6669 wxCaret *arg1 = (wxCaret *) 0 ;
6670 PyObject * obj0 = 0 ;
6671 char *kwnames[] = {
6672 (char *) "self", NULL
6673 };
6674
6675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6677 if (SWIG_arg_fail(1)) SWIG_fail;
6678 {
6679 PyThreadState* __tstate = wxPyBeginAllowThreads();
6680 (arg1)->Hide();
6681
6682 wxPyEndAllowThreads(__tstate);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 Py_INCREF(Py_None); resultobj = Py_None;
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6693 PyObject *obj;
6694 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6695 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6696 Py_INCREF(obj);
6697 return Py_BuildValue((char *)"");
6698 }
6699 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6700 PyObject *resultobj;
6701 int result;
6702 char *kwnames[] = {
6703 NULL
6704 };
6705
6706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = (int)wxCaret_GetBlinkTime();
6710
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 {
6715 resultobj = SWIG_From_int((int)(result));
6716 }
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 int arg1 ;
6726 PyObject * obj0 = 0 ;
6727 char *kwnames[] = {
6728 (char *) "milliseconds", NULL
6729 };
6730
6731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6732 {
6733 arg1 = (int)(SWIG_As_int(obj0));
6734 if (SWIG_arg_fail(1)) SWIG_fail;
6735 }
6736 {
6737 PyThreadState* __tstate = wxPyBeginAllowThreads();
6738 wxCaret_SetBlinkTime(arg1);
6739
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 Py_INCREF(Py_None); resultobj = Py_None;
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6751 PyObject *resultobj;
6752 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6753 wxBusyCursor *result;
6754 PyObject * obj0 = 0 ;
6755 char *kwnames[] = {
6756 (char *) "cursor", NULL
6757 };
6758
6759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6760 if (obj0) {
6761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6762 if (SWIG_arg_fail(1)) SWIG_fail;
6763 }
6764 {
6765 if (!wxPyCheckForApp()) SWIG_fail;
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6768
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6780 PyObject *resultobj;
6781 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6782 PyObject * obj0 = 0 ;
6783 char *kwnames[] = {
6784 (char *) "self", NULL
6785 };
6786
6787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6789 if (SWIG_arg_fail(1)) SWIG_fail;
6790 {
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 delete arg1;
6793
6794 wxPyEndAllowThreads(__tstate);
6795 if (PyErr_Occurred()) SWIG_fail;
6796 }
6797 Py_INCREF(Py_None); resultobj = Py_None;
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6805 PyObject *obj;
6806 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6807 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6808 Py_INCREF(obj);
6809 return Py_BuildValue((char *)"");
6810 }
6811 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6812 PyObject *resultobj;
6813 wxWindow *arg1 = (wxWindow *) NULL ;
6814 wxWindowDisabler *result;
6815 PyObject * obj0 = 0 ;
6816 char *kwnames[] = {
6817 (char *) "winToSkip", NULL
6818 };
6819
6820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6821 if (obj0) {
6822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6823 if (SWIG_arg_fail(1)) SWIG_fail;
6824 }
6825 {
6826 if (!wxPyCheckForApp()) SWIG_fail;
6827 PyThreadState* __tstate = wxPyBeginAllowThreads();
6828 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6829
6830 wxPyEndAllowThreads(__tstate);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6841 PyObject *resultobj;
6842 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6843 PyObject * obj0 = 0 ;
6844 char *kwnames[] = {
6845 (char *) "self", NULL
6846 };
6847
6848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6850 if (SWIG_arg_fail(1)) SWIG_fail;
6851 {
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 delete arg1;
6854
6855 wxPyEndAllowThreads(__tstate);
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 Py_INCREF(Py_None); resultobj = Py_None;
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6866 PyObject *obj;
6867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6868 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6869 Py_INCREF(obj);
6870 return Py_BuildValue((char *)"");
6871 }
6872 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6873 PyObject *resultobj;
6874 wxString *arg1 = 0 ;
6875 wxBusyInfo *result;
6876 bool temp1 = false ;
6877 PyObject * obj0 = 0 ;
6878 char *kwnames[] = {
6879 (char *) "message", NULL
6880 };
6881
6882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6883 {
6884 arg1 = wxString_in_helper(obj0);
6885 if (arg1 == NULL) SWIG_fail;
6886 temp1 = true;
6887 }
6888 {
6889 if (!wxPyCheckForApp()) SWIG_fail;
6890 PyThreadState* __tstate = wxPyBeginAllowThreads();
6891 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6892
6893 wxPyEndAllowThreads(__tstate);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6897 {
6898 if (temp1)
6899 delete arg1;
6900 }
6901 return resultobj;
6902 fail:
6903 {
6904 if (temp1)
6905 delete arg1;
6906 }
6907 return NULL;
6908 }
6909
6910
6911 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6912 PyObject *resultobj;
6913 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6914 PyObject * obj0 = 0 ;
6915 char *kwnames[] = {
6916 (char *) "self", NULL
6917 };
6918
6919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6921 if (SWIG_arg_fail(1)) SWIG_fail;
6922 {
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 delete arg1;
6925
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 Py_INCREF(Py_None); resultobj = Py_None;
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6937 PyObject *obj;
6938 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6939 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6940 Py_INCREF(obj);
6941 return Py_BuildValue((char *)"");
6942 }
6943 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6944 PyObject *resultobj;
6945 wxStopWatch *result;
6946 char *kwnames[] = {
6947 NULL
6948 };
6949
6950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6951 {
6952 PyThreadState* __tstate = wxPyBeginAllowThreads();
6953 result = (wxStopWatch *)new wxStopWatch();
6954
6955 wxPyEndAllowThreads(__tstate);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6966 PyObject *resultobj;
6967 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6968 long arg2 = (long) 0 ;
6969 PyObject * obj0 = 0 ;
6970 PyObject * obj1 = 0 ;
6971 char *kwnames[] = {
6972 (char *) "self",(char *) "t0", NULL
6973 };
6974
6975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
6976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6977 if (SWIG_arg_fail(1)) SWIG_fail;
6978 if (obj1) {
6979 {
6980 arg2 = (long)(SWIG_As_long(obj1));
6981 if (SWIG_arg_fail(2)) SWIG_fail;
6982 }
6983 }
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 (arg1)->Start(arg2);
6987
6988 wxPyEndAllowThreads(__tstate);
6989 if (PyErr_Occurred()) SWIG_fail;
6990 }
6991 Py_INCREF(Py_None); resultobj = Py_None;
6992 return resultobj;
6993 fail:
6994 return NULL;
6995 }
6996
6997
6998 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
6999 PyObject *resultobj;
7000 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7001 PyObject * obj0 = 0 ;
7002 char *kwnames[] = {
7003 (char *) "self", NULL
7004 };
7005
7006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7008 if (SWIG_arg_fail(1)) SWIG_fail;
7009 {
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 (arg1)->Pause();
7012
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 Py_INCREF(Py_None); resultobj = Py_None;
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj;
7025 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7026 PyObject * obj0 = 0 ;
7027 char *kwnames[] = {
7028 (char *) "self", NULL
7029 };
7030
7031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7033 if (SWIG_arg_fail(1)) SWIG_fail;
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 (arg1)->Resume();
7037
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 Py_INCREF(Py_None); resultobj = Py_None;
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7049 PyObject *resultobj;
7050 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7051 long result;
7052 PyObject * obj0 = 0 ;
7053 char *kwnames[] = {
7054 (char *) "self", NULL
7055 };
7056
7057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7059 if (SWIG_arg_fail(1)) SWIG_fail;
7060 {
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 result = (long)((wxStopWatch const *)arg1)->Time();
7063
7064 wxPyEndAllowThreads(__tstate);
7065 if (PyErr_Occurred()) SWIG_fail;
7066 }
7067 {
7068 resultobj = SWIG_From_long((long)(result));
7069 }
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7077 PyObject *obj;
7078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7079 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7080 Py_INCREF(obj);
7081 return Py_BuildValue((char *)"");
7082 }
7083 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7084 PyObject *resultobj;
7085 int arg1 = (int) 9 ;
7086 int arg2 = (int) wxID_FILE1 ;
7087 wxFileHistory *result;
7088 PyObject * obj0 = 0 ;
7089 PyObject * obj1 = 0 ;
7090 char *kwnames[] = {
7091 (char *) "maxFiles",(char *) "idBase", NULL
7092 };
7093
7094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7095 if (obj0) {
7096 {
7097 arg1 = (int)(SWIG_As_int(obj0));
7098 if (SWIG_arg_fail(1)) SWIG_fail;
7099 }
7100 }
7101 if (obj1) {
7102 {
7103 arg2 = (int)(SWIG_As_int(obj1));
7104 if (SWIG_arg_fail(2)) SWIG_fail;
7105 }
7106 }
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7110
7111 wxPyEndAllowThreads(__tstate);
7112 if (PyErr_Occurred()) SWIG_fail;
7113 }
7114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj;
7123 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7124 PyObject * obj0 = 0 ;
7125 char *kwnames[] = {
7126 (char *) "self", NULL
7127 };
7128
7129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7131 if (SWIG_arg_fail(1)) SWIG_fail;
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 delete arg1;
7135
7136 wxPyEndAllowThreads(__tstate);
7137 if (PyErr_Occurred()) SWIG_fail;
7138 }
7139 Py_INCREF(Py_None); resultobj = Py_None;
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7147 PyObject *resultobj;
7148 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7149 wxString *arg2 = 0 ;
7150 bool temp2 = false ;
7151 PyObject * obj0 = 0 ;
7152 PyObject * obj1 = 0 ;
7153 char *kwnames[] = {
7154 (char *) "self",(char *) "file", NULL
7155 };
7156
7157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7159 if (SWIG_arg_fail(1)) SWIG_fail;
7160 {
7161 arg2 = wxString_in_helper(obj1);
7162 if (arg2 == NULL) SWIG_fail;
7163 temp2 = true;
7164 }
7165 {
7166 PyThreadState* __tstate = wxPyBeginAllowThreads();
7167 (arg1)->AddFileToHistory((wxString const &)*arg2);
7168
7169 wxPyEndAllowThreads(__tstate);
7170 if (PyErr_Occurred()) SWIG_fail;
7171 }
7172 Py_INCREF(Py_None); resultobj = Py_None;
7173 {
7174 if (temp2)
7175 delete arg2;
7176 }
7177 return resultobj;
7178 fail:
7179 {
7180 if (temp2)
7181 delete arg2;
7182 }
7183 return NULL;
7184 }
7185
7186
7187 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7188 PyObject *resultobj;
7189 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7190 int arg2 ;
7191 PyObject * obj0 = 0 ;
7192 PyObject * obj1 = 0 ;
7193 char *kwnames[] = {
7194 (char *) "self",(char *) "i", NULL
7195 };
7196
7197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7199 if (SWIG_arg_fail(1)) SWIG_fail;
7200 {
7201 arg2 = (int)(SWIG_As_int(obj1));
7202 if (SWIG_arg_fail(2)) SWIG_fail;
7203 }
7204 {
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 (arg1)->RemoveFileFromHistory(arg2);
7207
7208 wxPyEndAllowThreads(__tstate);
7209 if (PyErr_Occurred()) SWIG_fail;
7210 }
7211 Py_INCREF(Py_None); resultobj = Py_None;
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj;
7220 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7221 int result;
7222 PyObject * obj0 = 0 ;
7223 char *kwnames[] = {
7224 (char *) "self", NULL
7225 };
7226
7227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7229 if (SWIG_arg_fail(1)) SWIG_fail;
7230 {
7231 PyThreadState* __tstate = wxPyBeginAllowThreads();
7232 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7233
7234 wxPyEndAllowThreads(__tstate);
7235 if (PyErr_Occurred()) SWIG_fail;
7236 }
7237 {
7238 resultobj = SWIG_From_int((int)(result));
7239 }
7240 return resultobj;
7241 fail:
7242 return NULL;
7243 }
7244
7245
7246 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7247 PyObject *resultobj;
7248 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7249 wxMenu *arg2 = (wxMenu *) 0 ;
7250 PyObject * obj0 = 0 ;
7251 PyObject * obj1 = 0 ;
7252 char *kwnames[] = {
7253 (char *) "self",(char *) "menu", NULL
7254 };
7255
7256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7258 if (SWIG_arg_fail(1)) SWIG_fail;
7259 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7260 if (SWIG_arg_fail(2)) SWIG_fail;
7261 {
7262 PyThreadState* __tstate = wxPyBeginAllowThreads();
7263 (arg1)->UseMenu(arg2);
7264
7265 wxPyEndAllowThreads(__tstate);
7266 if (PyErr_Occurred()) SWIG_fail;
7267 }
7268 Py_INCREF(Py_None); resultobj = Py_None;
7269 return resultobj;
7270 fail:
7271 return NULL;
7272 }
7273
7274
7275 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7276 PyObject *resultobj;
7277 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7278 wxMenu *arg2 = (wxMenu *) 0 ;
7279 PyObject * obj0 = 0 ;
7280 PyObject * obj1 = 0 ;
7281 char *kwnames[] = {
7282 (char *) "self",(char *) "menu", NULL
7283 };
7284
7285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7287 if (SWIG_arg_fail(1)) SWIG_fail;
7288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7289 if (SWIG_arg_fail(2)) SWIG_fail;
7290 {
7291 PyThreadState* __tstate = wxPyBeginAllowThreads();
7292 (arg1)->RemoveMenu(arg2);
7293
7294 wxPyEndAllowThreads(__tstate);
7295 if (PyErr_Occurred()) SWIG_fail;
7296 }
7297 Py_INCREF(Py_None); resultobj = Py_None;
7298 return resultobj;
7299 fail:
7300 return NULL;
7301 }
7302
7303
7304 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7305 PyObject *resultobj;
7306 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7307 wxConfigBase *arg2 = 0 ;
7308 PyObject * obj0 = 0 ;
7309 PyObject * obj1 = 0 ;
7310 char *kwnames[] = {
7311 (char *) "self",(char *) "config", NULL
7312 };
7313
7314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7316 if (SWIG_arg_fail(1)) SWIG_fail;
7317 {
7318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7319 if (SWIG_arg_fail(2)) SWIG_fail;
7320 if (arg2 == NULL) {
7321 SWIG_null_ref("wxConfigBase");
7322 }
7323 if (SWIG_arg_fail(2)) SWIG_fail;
7324 }
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 (arg1)->Load(*arg2);
7328
7329 wxPyEndAllowThreads(__tstate);
7330 if (PyErr_Occurred()) SWIG_fail;
7331 }
7332 Py_INCREF(Py_None); resultobj = Py_None;
7333 return resultobj;
7334 fail:
7335 return NULL;
7336 }
7337
7338
7339 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7340 PyObject *resultobj;
7341 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7342 wxConfigBase *arg2 = 0 ;
7343 PyObject * obj0 = 0 ;
7344 PyObject * obj1 = 0 ;
7345 char *kwnames[] = {
7346 (char *) "self",(char *) "config", NULL
7347 };
7348
7349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7351 if (SWIG_arg_fail(1)) SWIG_fail;
7352 {
7353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7354 if (SWIG_arg_fail(2)) SWIG_fail;
7355 if (arg2 == NULL) {
7356 SWIG_null_ref("wxConfigBase");
7357 }
7358 if (SWIG_arg_fail(2)) SWIG_fail;
7359 }
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 (arg1)->Save(*arg2);
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 Py_INCREF(Py_None); resultobj = Py_None;
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj;
7376 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7377 PyObject * obj0 = 0 ;
7378 char *kwnames[] = {
7379 (char *) "self", NULL
7380 };
7381
7382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(1)) SWIG_fail;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 (arg1)->AddFilesToMenu();
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 Py_INCREF(Py_None); resultobj = Py_None;
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7402 wxMenu *arg2 = (wxMenu *) 0 ;
7403 PyObject * obj0 = 0 ;
7404 PyObject * obj1 = 0 ;
7405 char *kwnames[] = {
7406 (char *) "self",(char *) "menu", NULL
7407 };
7408
7409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7411 if (SWIG_arg_fail(1)) SWIG_fail;
7412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7413 if (SWIG_arg_fail(2)) SWIG_fail;
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 (arg1)->AddFilesToMenu(arg2);
7417
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 Py_INCREF(Py_None); resultobj = Py_None;
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj;
7430 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7431 int arg2 ;
7432 wxString result;
7433 PyObject * obj0 = 0 ;
7434 PyObject * obj1 = 0 ;
7435 char *kwnames[] = {
7436 (char *) "self",(char *) "i", NULL
7437 };
7438
7439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7441 if (SWIG_arg_fail(1)) SWIG_fail;
7442 {
7443 arg2 = (int)(SWIG_As_int(obj1));
7444 if (SWIG_arg_fail(2)) SWIG_fail;
7445 }
7446 {
7447 PyThreadState* __tstate = wxPyBeginAllowThreads();
7448 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7449
7450 wxPyEndAllowThreads(__tstate);
7451 if (PyErr_Occurred()) SWIG_fail;
7452 }
7453 {
7454 #if wxUSE_UNICODE
7455 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7456 #else
7457 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7458 #endif
7459 }
7460 return resultobj;
7461 fail:
7462 return NULL;
7463 }
7464
7465
7466 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7467 PyObject *resultobj;
7468 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7469 int result;
7470 PyObject * obj0 = 0 ;
7471 char *kwnames[] = {
7472 (char *) "self", NULL
7473 };
7474
7475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7477 if (SWIG_arg_fail(1)) SWIG_fail;
7478 {
7479 PyThreadState* __tstate = wxPyBeginAllowThreads();
7480 result = (int)((wxFileHistory const *)arg1)->GetCount();
7481
7482 wxPyEndAllowThreads(__tstate);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = SWIG_From_int((int)(result));
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7495 PyObject *obj;
7496 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7497 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7498 Py_INCREF(obj);
7499 return Py_BuildValue((char *)"");
7500 }
7501 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7502 PyObject *resultobj;
7503 wxString *arg1 = 0 ;
7504 wxString const &arg2_defvalue = wxPyEmptyString ;
7505 wxString *arg2 = (wxString *) &arg2_defvalue ;
7506 wxSingleInstanceChecker *result;
7507 bool temp1 = false ;
7508 bool temp2 = false ;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 char *kwnames[] = {
7512 (char *) "name",(char *) "path", NULL
7513 };
7514
7515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7516 {
7517 arg1 = wxString_in_helper(obj0);
7518 if (arg1 == NULL) SWIG_fail;
7519 temp1 = true;
7520 }
7521 if (obj1) {
7522 {
7523 arg2 = wxString_in_helper(obj1);
7524 if (arg2 == NULL) SWIG_fail;
7525 temp2 = true;
7526 }
7527 }
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7531
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7536 {
7537 if (temp1)
7538 delete arg1;
7539 }
7540 {
7541 if (temp2)
7542 delete arg2;
7543 }
7544 return resultobj;
7545 fail:
7546 {
7547 if (temp1)
7548 delete arg1;
7549 }
7550 {
7551 if (temp2)
7552 delete arg2;
7553 }
7554 return NULL;
7555 }
7556
7557
7558 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7559 PyObject *resultobj;
7560 wxSingleInstanceChecker *result;
7561 char *kwnames[] = {
7562 NULL
7563 };
7564
7565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7566 {
7567 PyThreadState* __tstate = wxPyBeginAllowThreads();
7568 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7569
7570 wxPyEndAllowThreads(__tstate);
7571 if (PyErr_Occurred()) SWIG_fail;
7572 }
7573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7574 return resultobj;
7575 fail:
7576 return NULL;
7577 }
7578
7579
7580 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7581 PyObject *resultobj;
7582 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7583 PyObject * obj0 = 0 ;
7584 char *kwnames[] = {
7585 (char *) "self", NULL
7586 };
7587
7588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7590 if (SWIG_arg_fail(1)) SWIG_fail;
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 delete arg1;
7594
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 Py_INCREF(Py_None); resultobj = Py_None;
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7606 PyObject *resultobj;
7607 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7608 wxString *arg2 = 0 ;
7609 wxString const &arg3_defvalue = wxPyEmptyString ;
7610 wxString *arg3 = (wxString *) &arg3_defvalue ;
7611 bool result;
7612 bool temp2 = false ;
7613 bool temp3 = false ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 PyObject * obj2 = 0 ;
7617 char *kwnames[] = {
7618 (char *) "self",(char *) "name",(char *) "path", NULL
7619 };
7620
7621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7623 if (SWIG_arg_fail(1)) SWIG_fail;
7624 {
7625 arg2 = wxString_in_helper(obj1);
7626 if (arg2 == NULL) SWIG_fail;
7627 temp2 = true;
7628 }
7629 if (obj2) {
7630 {
7631 arg3 = wxString_in_helper(obj2);
7632 if (arg3 == NULL) SWIG_fail;
7633 temp3 = true;
7634 }
7635 }
7636 {
7637 PyThreadState* __tstate = wxPyBeginAllowThreads();
7638 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7639
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 {
7644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7645 }
7646 {
7647 if (temp2)
7648 delete arg2;
7649 }
7650 {
7651 if (temp3)
7652 delete arg3;
7653 }
7654 return resultobj;
7655 fail:
7656 {
7657 if (temp2)
7658 delete arg2;
7659 }
7660 {
7661 if (temp3)
7662 delete arg3;
7663 }
7664 return NULL;
7665 }
7666
7667
7668 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7669 PyObject *resultobj;
7670 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7671 bool result;
7672 PyObject * obj0 = 0 ;
7673 char *kwnames[] = {
7674 (char *) "self", NULL
7675 };
7676
7677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7679 if (SWIG_arg_fail(1)) SWIG_fail;
7680 {
7681 PyThreadState* __tstate = wxPyBeginAllowThreads();
7682 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7683
7684 wxPyEndAllowThreads(__tstate);
7685 if (PyErr_Occurred()) SWIG_fail;
7686 }
7687 {
7688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7689 }
7690 return resultobj;
7691 fail:
7692 return NULL;
7693 }
7694
7695
7696 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7697 PyObject *obj;
7698 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7699 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7700 Py_INCREF(obj);
7701 return Py_BuildValue((char *)"");
7702 }
7703 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7704 PyObject *resultobj;
7705 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7706 PyObject * obj0 = 0 ;
7707 char *kwnames[] = {
7708 (char *) "self", NULL
7709 };
7710
7711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7713 if (SWIG_arg_fail(1)) SWIG_fail;
7714 {
7715 PyThreadState* __tstate = wxPyBeginAllowThreads();
7716 delete arg1;
7717
7718 wxPyEndAllowThreads(__tstate);
7719 if (PyErr_Occurred()) SWIG_fail;
7720 }
7721 Py_INCREF(Py_None); resultobj = Py_None;
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj;
7730 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7731 wxString result;
7732 PyObject * obj0 = 0 ;
7733 char *kwnames[] = {
7734 (char *) "self", NULL
7735 };
7736
7737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7739 if (SWIG_arg_fail(1)) SWIG_fail;
7740 {
7741 PyThreadState* __tstate = wxPyBeginAllowThreads();
7742 result = (arg1)->GetTip();
7743
7744 wxPyEndAllowThreads(__tstate);
7745 if (PyErr_Occurred()) SWIG_fail;
7746 }
7747 {
7748 #if wxUSE_UNICODE
7749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7750 #else
7751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7752 #endif
7753 }
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj;
7762 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7763 size_t result;
7764 PyObject * obj0 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 {
7773 PyThreadState* __tstate = wxPyBeginAllowThreads();
7774 result = (size_t)(arg1)->GetCurrentTip();
7775
7776 wxPyEndAllowThreads(__tstate);
7777 if (PyErr_Occurred()) SWIG_fail;
7778 }
7779 {
7780 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7781 }
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj;
7790 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7791 wxString *arg2 = 0 ;
7792 wxString result;
7793 bool temp2 = false ;
7794 PyObject * obj0 = 0 ;
7795 PyObject * obj1 = 0 ;
7796 char *kwnames[] = {
7797 (char *) "self",(char *) "tip", NULL
7798 };
7799
7800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7802 if (SWIG_arg_fail(1)) SWIG_fail;
7803 {
7804 arg2 = wxString_in_helper(obj1);
7805 if (arg2 == NULL) SWIG_fail;
7806 temp2 = true;
7807 }
7808 {
7809 PyThreadState* __tstate = wxPyBeginAllowThreads();
7810 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7811
7812 wxPyEndAllowThreads(__tstate);
7813 if (PyErr_Occurred()) SWIG_fail;
7814 }
7815 {
7816 #if wxUSE_UNICODE
7817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7818 #else
7819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7820 #endif
7821 }
7822 {
7823 if (temp2)
7824 delete arg2;
7825 }
7826 return resultobj;
7827 fail:
7828 {
7829 if (temp2)
7830 delete arg2;
7831 }
7832 return NULL;
7833 }
7834
7835
7836 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7837 PyObject *obj;
7838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7839 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7840 Py_INCREF(obj);
7841 return Py_BuildValue((char *)"");
7842 }
7843 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7844 PyObject *resultobj;
7845 size_t arg1 ;
7846 wxPyTipProvider *result;
7847 PyObject * obj0 = 0 ;
7848 char *kwnames[] = {
7849 (char *) "currentTip", NULL
7850 };
7851
7852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7853 {
7854 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7855 if (SWIG_arg_fail(1)) SWIG_fail;
7856 }
7857 {
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7860
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7872 PyObject *resultobj;
7873 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7874 PyObject *arg2 = (PyObject *) 0 ;
7875 PyObject *arg3 = (PyObject *) 0 ;
7876 PyObject * obj0 = 0 ;
7877 PyObject * obj1 = 0 ;
7878 PyObject * obj2 = 0 ;
7879 char *kwnames[] = {
7880 (char *) "self",(char *) "self",(char *) "_class", NULL
7881 };
7882
7883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7885 if (SWIG_arg_fail(1)) SWIG_fail;
7886 arg2 = obj1;
7887 arg3 = obj2;
7888 {
7889 PyThreadState* __tstate = wxPyBeginAllowThreads();
7890 (arg1)->_setCallbackInfo(arg2,arg3);
7891
7892 wxPyEndAllowThreads(__tstate);
7893 if (PyErr_Occurred()) SWIG_fail;
7894 }
7895 Py_INCREF(Py_None); resultobj = Py_None;
7896 return resultobj;
7897 fail:
7898 return NULL;
7899 }
7900
7901
7902 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7903 PyObject *obj;
7904 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7905 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7906 Py_INCREF(obj);
7907 return Py_BuildValue((char *)"");
7908 }
7909 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7910 PyObject *resultobj;
7911 wxWindow *arg1 = (wxWindow *) 0 ;
7912 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7913 bool arg3 = (bool) true ;
7914 bool result;
7915 PyObject * obj0 = 0 ;
7916 PyObject * obj1 = 0 ;
7917 PyObject * obj2 = 0 ;
7918 char *kwnames[] = {
7919 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7920 };
7921
7922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7924 if (SWIG_arg_fail(1)) SWIG_fail;
7925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7926 if (SWIG_arg_fail(2)) SWIG_fail;
7927 if (obj2) {
7928 {
7929 arg3 = (bool)(SWIG_As_bool(obj2));
7930 if (SWIG_arg_fail(3)) SWIG_fail;
7931 }
7932 }
7933 {
7934 if (!wxPyCheckForApp()) SWIG_fail;
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 result = (bool)wxShowTip(arg1,arg2,arg3);
7937
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 {
7942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7943 }
7944 return resultobj;
7945 fail:
7946 return NULL;
7947 }
7948
7949
7950 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7951 PyObject *resultobj;
7952 wxString *arg1 = 0 ;
7953 size_t arg2 ;
7954 wxTipProvider *result;
7955 bool temp1 = false ;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char *kwnames[] = {
7959 (char *) "filename",(char *) "currentTip", NULL
7960 };
7961
7962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7963 {
7964 arg1 = wxString_in_helper(obj0);
7965 if (arg1 == NULL) SWIG_fail;
7966 temp1 = true;
7967 }
7968 {
7969 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7970 if (SWIG_arg_fail(2)) SWIG_fail;
7971 }
7972 {
7973 if (!wxPyCheckForApp()) SWIG_fail;
7974 PyThreadState* __tstate = wxPyBeginAllowThreads();
7975 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
7976
7977 wxPyEndAllowThreads(__tstate);
7978 if (PyErr_Occurred()) SWIG_fail;
7979 }
7980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
7981 {
7982 if (temp1)
7983 delete arg1;
7984 }
7985 return resultobj;
7986 fail:
7987 {
7988 if (temp1)
7989 delete arg1;
7990 }
7991 return NULL;
7992 }
7993
7994
7995 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
7996 PyObject *resultobj;
7997 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
7998 int arg2 = (int) -1 ;
7999 wxPyTimer *result;
8000 PyObject * obj0 = 0 ;
8001 PyObject * obj1 = 0 ;
8002 char *kwnames[] = {
8003 (char *) "owner",(char *) "id", NULL
8004 };
8005
8006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8007 if (obj0) {
8008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8009 if (SWIG_arg_fail(1)) SWIG_fail;
8010 }
8011 if (obj1) {
8012 {
8013 arg2 = (int)(SWIG_As_int(obj1));
8014 if (SWIG_arg_fail(2)) SWIG_fail;
8015 }
8016 }
8017 {
8018 if (!wxPyCheckForApp()) SWIG_fail;
8019 PyThreadState* __tstate = wxPyBeginAllowThreads();
8020 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8021
8022 wxPyEndAllowThreads(__tstate);
8023 if (PyErr_Occurred()) SWIG_fail;
8024 }
8025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8026 return resultobj;
8027 fail:
8028 return NULL;
8029 }
8030
8031
8032 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8033 PyObject *resultobj;
8034 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8035 PyObject * obj0 = 0 ;
8036 char *kwnames[] = {
8037 (char *) "self", NULL
8038 };
8039
8040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8042 if (SWIG_arg_fail(1)) SWIG_fail;
8043 {
8044 PyThreadState* __tstate = wxPyBeginAllowThreads();
8045 delete arg1;
8046
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 Py_INCREF(Py_None); resultobj = Py_None;
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj;
8059 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8060 PyObject *arg2 = (PyObject *) 0 ;
8061 PyObject *arg3 = (PyObject *) 0 ;
8062 int arg4 = (int) 1 ;
8063 PyObject * obj0 = 0 ;
8064 PyObject * obj1 = 0 ;
8065 PyObject * obj2 = 0 ;
8066 PyObject * obj3 = 0 ;
8067 char *kwnames[] = {
8068 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8069 };
8070
8071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8073 if (SWIG_arg_fail(1)) SWIG_fail;
8074 arg2 = obj1;
8075 arg3 = obj2;
8076 if (obj3) {
8077 {
8078 arg4 = (int)(SWIG_As_int(obj3));
8079 if (SWIG_arg_fail(4)) SWIG_fail;
8080 }
8081 }
8082 {
8083 PyThreadState* __tstate = wxPyBeginAllowThreads();
8084 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8085
8086 wxPyEndAllowThreads(__tstate);
8087 if (PyErr_Occurred()) SWIG_fail;
8088 }
8089 Py_INCREF(Py_None); resultobj = Py_None;
8090 return resultobj;
8091 fail:
8092 return NULL;
8093 }
8094
8095
8096 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8097 PyObject *resultobj;
8098 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8099 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8100 int arg3 = (int) -1 ;
8101 PyObject * obj0 = 0 ;
8102 PyObject * obj1 = 0 ;
8103 PyObject * obj2 = 0 ;
8104 char *kwnames[] = {
8105 (char *) "self",(char *) "owner",(char *) "id", NULL
8106 };
8107
8108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8110 if (SWIG_arg_fail(1)) SWIG_fail;
8111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8112 if (SWIG_arg_fail(2)) SWIG_fail;
8113 if (obj2) {
8114 {
8115 arg3 = (int)(SWIG_As_int(obj2));
8116 if (SWIG_arg_fail(3)) SWIG_fail;
8117 }
8118 }
8119 {
8120 PyThreadState* __tstate = wxPyBeginAllowThreads();
8121 (arg1)->SetOwner(arg2,arg3);
8122
8123 wxPyEndAllowThreads(__tstate);
8124 if (PyErr_Occurred()) SWIG_fail;
8125 }
8126 Py_INCREF(Py_None); resultobj = Py_None;
8127 return resultobj;
8128 fail:
8129 return NULL;
8130 }
8131
8132
8133 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8134 PyObject *resultobj;
8135 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8136 wxEvtHandler *result;
8137 PyObject * obj0 = 0 ;
8138 char *kwnames[] = {
8139 (char *) "self", NULL
8140 };
8141
8142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8144 if (SWIG_arg_fail(1)) SWIG_fail;
8145 {
8146 PyThreadState* __tstate = wxPyBeginAllowThreads();
8147 result = (wxEvtHandler *)(arg1)->GetOwner();
8148
8149 wxPyEndAllowThreads(__tstate);
8150 if (PyErr_Occurred()) SWIG_fail;
8151 }
8152 {
8153 resultobj = wxPyMake_wxObject(result, 0);
8154 }
8155 return resultobj;
8156 fail:
8157 return NULL;
8158 }
8159
8160
8161 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8162 PyObject *resultobj;
8163 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8164 int arg2 = (int) -1 ;
8165 bool arg3 = (bool) false ;
8166 bool result;
8167 PyObject * obj0 = 0 ;
8168 PyObject * obj1 = 0 ;
8169 PyObject * obj2 = 0 ;
8170 char *kwnames[] = {
8171 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8172 };
8173
8174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8176 if (SWIG_arg_fail(1)) SWIG_fail;
8177 if (obj1) {
8178 {
8179 arg2 = (int)(SWIG_As_int(obj1));
8180 if (SWIG_arg_fail(2)) SWIG_fail;
8181 }
8182 }
8183 if (obj2) {
8184 {
8185 arg3 = (bool)(SWIG_As_bool(obj2));
8186 if (SWIG_arg_fail(3)) SWIG_fail;
8187 }
8188 }
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 result = (bool)(arg1)->Start(arg2,arg3);
8192
8193 wxPyEndAllowThreads(__tstate);
8194 if (PyErr_Occurred()) SWIG_fail;
8195 }
8196 {
8197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8198 }
8199 return resultobj;
8200 fail:
8201 return NULL;
8202 }
8203
8204
8205 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8206 PyObject *resultobj;
8207 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8208 PyObject * obj0 = 0 ;
8209 char *kwnames[] = {
8210 (char *) "self", NULL
8211 };
8212
8213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8215 if (SWIG_arg_fail(1)) SWIG_fail;
8216 {
8217 PyThreadState* __tstate = wxPyBeginAllowThreads();
8218 (arg1)->Stop();
8219
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 Py_INCREF(Py_None); resultobj = Py_None;
8224 return resultobj;
8225 fail:
8226 return NULL;
8227 }
8228
8229
8230 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8231 PyObject *resultobj;
8232 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8233 bool result;
8234 PyObject * obj0 = 0 ;
8235 char *kwnames[] = {
8236 (char *) "self", NULL
8237 };
8238
8239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8241 if (SWIG_arg_fail(1)) SWIG_fail;
8242 {
8243 PyThreadState* __tstate = wxPyBeginAllowThreads();
8244 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8245
8246 wxPyEndAllowThreads(__tstate);
8247 if (PyErr_Occurred()) SWIG_fail;
8248 }
8249 {
8250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8251 }
8252 return resultobj;
8253 fail:
8254 return NULL;
8255 }
8256
8257
8258 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8259 PyObject *resultobj;
8260 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8261 int result;
8262 PyObject * obj0 = 0 ;
8263 char *kwnames[] = {
8264 (char *) "self", NULL
8265 };
8266
8267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8269 if (SWIG_arg_fail(1)) SWIG_fail;
8270 {
8271 PyThreadState* __tstate = wxPyBeginAllowThreads();
8272 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8273
8274 wxPyEndAllowThreads(__tstate);
8275 if (PyErr_Occurred()) SWIG_fail;
8276 }
8277 {
8278 resultobj = SWIG_From_int((int)(result));
8279 }
8280 return resultobj;
8281 fail:
8282 return NULL;
8283 }
8284
8285
8286 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8287 PyObject *resultobj;
8288 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8289 bool result;
8290 PyObject * obj0 = 0 ;
8291 char *kwnames[] = {
8292 (char *) "self", NULL
8293 };
8294
8295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8297 if (SWIG_arg_fail(1)) SWIG_fail;
8298 {
8299 PyThreadState* __tstate = wxPyBeginAllowThreads();
8300 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8301
8302 wxPyEndAllowThreads(__tstate);
8303 if (PyErr_Occurred()) SWIG_fail;
8304 }
8305 {
8306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8307 }
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8315 PyObject *resultobj;
8316 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8317 int result;
8318 PyObject * obj0 = 0 ;
8319 char *kwnames[] = {
8320 (char *) "self", NULL
8321 };
8322
8323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8325 if (SWIG_arg_fail(1)) SWIG_fail;
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 result = (int)((wxPyTimer const *)arg1)->GetId();
8329
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 {
8334 resultobj = SWIG_From_int((int)(result));
8335 }
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8343 PyObject *obj;
8344 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8345 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8346 Py_INCREF(obj);
8347 return Py_BuildValue((char *)"");
8348 }
8349 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8350 PyObject *resultobj;
8351 int arg1 = (int) 0 ;
8352 int arg2 = (int) 0 ;
8353 wxTimerEvent *result;
8354 PyObject * obj0 = 0 ;
8355 PyObject * obj1 = 0 ;
8356 char *kwnames[] = {
8357 (char *) "timerid",(char *) "interval", NULL
8358 };
8359
8360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8361 if (obj0) {
8362 {
8363 arg1 = (int)(SWIG_As_int(obj0));
8364 if (SWIG_arg_fail(1)) SWIG_fail;
8365 }
8366 }
8367 if (obj1) {
8368 {
8369 arg2 = (int)(SWIG_As_int(obj1));
8370 if (SWIG_arg_fail(2)) SWIG_fail;
8371 }
8372 }
8373 {
8374 PyThreadState* __tstate = wxPyBeginAllowThreads();
8375 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8376
8377 wxPyEndAllowThreads(__tstate);
8378 if (PyErr_Occurred()) SWIG_fail;
8379 }
8380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8381 return resultobj;
8382 fail:
8383 return NULL;
8384 }
8385
8386
8387 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8388 PyObject *resultobj;
8389 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8390 int result;
8391 PyObject * obj0 = 0 ;
8392 char *kwnames[] = {
8393 (char *) "self", NULL
8394 };
8395
8396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8398 if (SWIG_arg_fail(1)) SWIG_fail;
8399 {
8400 PyThreadState* __tstate = wxPyBeginAllowThreads();
8401 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8402
8403 wxPyEndAllowThreads(__tstate);
8404 if (PyErr_Occurred()) SWIG_fail;
8405 }
8406 {
8407 resultobj = SWIG_From_int((int)(result));
8408 }
8409 return resultobj;
8410 fail:
8411 return NULL;
8412 }
8413
8414
8415 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8416 PyObject *obj;
8417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8418 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8419 Py_INCREF(obj);
8420 return Py_BuildValue((char *)"");
8421 }
8422 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8423 PyObject *resultobj;
8424 wxTimer *arg1 = 0 ;
8425 wxTimerRunner *result;
8426 PyObject * obj0 = 0 ;
8427
8428 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8429 {
8430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8431 if (SWIG_arg_fail(1)) SWIG_fail;
8432 if (arg1 == NULL) {
8433 SWIG_null_ref("wxTimer");
8434 }
8435 if (SWIG_arg_fail(1)) SWIG_fail;
8436 }
8437 {
8438 if (!wxPyCheckForApp()) SWIG_fail;
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8441
8442 wxPyEndAllowThreads(__tstate);
8443 if (PyErr_Occurred()) SWIG_fail;
8444 }
8445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8446 return resultobj;
8447 fail:
8448 return NULL;
8449 }
8450
8451
8452 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8453 PyObject *resultobj;
8454 wxTimer *arg1 = 0 ;
8455 int arg2 ;
8456 bool arg3 = (bool) false ;
8457 wxTimerRunner *result;
8458 PyObject * obj0 = 0 ;
8459 PyObject * obj1 = 0 ;
8460 PyObject * obj2 = 0 ;
8461
8462 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8463 {
8464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8465 if (SWIG_arg_fail(1)) SWIG_fail;
8466 if (arg1 == NULL) {
8467 SWIG_null_ref("wxTimer");
8468 }
8469 if (SWIG_arg_fail(1)) SWIG_fail;
8470 }
8471 {
8472 arg2 = (int)(SWIG_As_int(obj1));
8473 if (SWIG_arg_fail(2)) SWIG_fail;
8474 }
8475 if (obj2) {
8476 {
8477 arg3 = (bool)(SWIG_As_bool(obj2));
8478 if (SWIG_arg_fail(3)) SWIG_fail;
8479 }
8480 }
8481 {
8482 if (!wxPyCheckForApp()) SWIG_fail;
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8485
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8490 return resultobj;
8491 fail:
8492 return NULL;
8493 }
8494
8495
8496 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8497 int argc;
8498 PyObject *argv[4];
8499 int ii;
8500
8501 argc = PyObject_Length(args);
8502 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8503 argv[ii] = PyTuple_GetItem(args,ii);
8504 }
8505 if (argc == 1) {
8506 int _v;
8507 {
8508 void *ptr = 0;
8509 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8510 _v = 0;
8511 PyErr_Clear();
8512 } else {
8513 _v = (ptr != 0);
8514 }
8515 }
8516 if (_v) {
8517 return _wrap_new_TimerRunner__SWIG_0(self,args);
8518 }
8519 }
8520 if ((argc >= 2) && (argc <= 3)) {
8521 int _v;
8522 {
8523 void *ptr = 0;
8524 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8525 _v = 0;
8526 PyErr_Clear();
8527 } else {
8528 _v = (ptr != 0);
8529 }
8530 }
8531 if (_v) {
8532 _v = SWIG_Check_int(argv[1]);
8533 if (_v) {
8534 if (argc <= 2) {
8535 return _wrap_new_TimerRunner__SWIG_1(self,args);
8536 }
8537 _v = SWIG_Check_bool(argv[2]);
8538 if (_v) {
8539 return _wrap_new_TimerRunner__SWIG_1(self,args);
8540 }
8541 }
8542 }
8543 }
8544
8545 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8546 return NULL;
8547 }
8548
8549
8550 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8551 PyObject *resultobj;
8552 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8553 PyObject * obj0 = 0 ;
8554 char *kwnames[] = {
8555 (char *) "self", NULL
8556 };
8557
8558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8560 if (SWIG_arg_fail(1)) SWIG_fail;
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 delete arg1;
8564
8565 wxPyEndAllowThreads(__tstate);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 Py_INCREF(Py_None); resultobj = Py_None;
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj;
8577 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8578 int arg2 ;
8579 bool arg3 = (bool) false ;
8580 PyObject * obj0 = 0 ;
8581 PyObject * obj1 = 0 ;
8582 PyObject * obj2 = 0 ;
8583 char *kwnames[] = {
8584 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8585 };
8586
8587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8589 if (SWIG_arg_fail(1)) SWIG_fail;
8590 {
8591 arg2 = (int)(SWIG_As_int(obj1));
8592 if (SWIG_arg_fail(2)) SWIG_fail;
8593 }
8594 if (obj2) {
8595 {
8596 arg3 = (bool)(SWIG_As_bool(obj2));
8597 if (SWIG_arg_fail(3)) SWIG_fail;
8598 }
8599 }
8600 {
8601 PyThreadState* __tstate = wxPyBeginAllowThreads();
8602 (arg1)->Start(arg2,arg3);
8603
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 Py_INCREF(Py_None); resultobj = Py_None;
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8615 PyObject *obj;
8616 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8617 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8618 Py_INCREF(obj);
8619 return Py_BuildValue((char *)"");
8620 }
8621 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8622 PyObject *resultobj;
8623 wxLog *result;
8624 char *kwnames[] = {
8625 NULL
8626 };
8627
8628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8629 {
8630 PyThreadState* __tstate = wxPyBeginAllowThreads();
8631 result = (wxLog *)new wxLog();
8632
8633 wxPyEndAllowThreads(__tstate);
8634 if (PyErr_Occurred()) SWIG_fail;
8635 }
8636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8637 return resultobj;
8638 fail:
8639 return NULL;
8640 }
8641
8642
8643 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8644 PyObject *resultobj;
8645 bool result;
8646 char *kwnames[] = {
8647 NULL
8648 };
8649
8650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8651 {
8652 PyThreadState* __tstate = wxPyBeginAllowThreads();
8653 result = (bool)wxLog::IsEnabled();
8654
8655 wxPyEndAllowThreads(__tstate);
8656 if (PyErr_Occurred()) SWIG_fail;
8657 }
8658 {
8659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8660 }
8661 return resultobj;
8662 fail:
8663 return NULL;
8664 }
8665
8666
8667 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8668 PyObject *resultobj;
8669 bool arg1 = (bool) true ;
8670 bool result;
8671 PyObject * obj0 = 0 ;
8672 char *kwnames[] = {
8673 (char *) "doIt", NULL
8674 };
8675
8676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8677 if (obj0) {
8678 {
8679 arg1 = (bool)(SWIG_As_bool(obj0));
8680 if (SWIG_arg_fail(1)) SWIG_fail;
8681 }
8682 }
8683 {
8684 PyThreadState* __tstate = wxPyBeginAllowThreads();
8685 result = (bool)wxLog::EnableLogging(arg1);
8686
8687 wxPyEndAllowThreads(__tstate);
8688 if (PyErr_Occurred()) SWIG_fail;
8689 }
8690 {
8691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8692 }
8693 return resultobj;
8694 fail:
8695 return NULL;
8696 }
8697
8698
8699 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8700 PyObject *resultobj;
8701 wxLogLevel arg1 ;
8702 wxChar *arg2 = (wxChar *) 0 ;
8703 time_t arg3 ;
8704 PyObject * obj0 = 0 ;
8705 PyObject * obj1 = 0 ;
8706 PyObject * obj2 = 0 ;
8707 char *kwnames[] = {
8708 (char *) "level",(char *) "szString",(char *) "t", NULL
8709 };
8710
8711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8712 {
8713 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8714 if (SWIG_arg_fail(1)) SWIG_fail;
8715 }
8716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8717 if (SWIG_arg_fail(2)) SWIG_fail;
8718 {
8719 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8720 if (SWIG_arg_fail(3)) SWIG_fail;
8721 }
8722 {
8723 PyThreadState* __tstate = wxPyBeginAllowThreads();
8724 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8725
8726 wxPyEndAllowThreads(__tstate);
8727 if (PyErr_Occurred()) SWIG_fail;
8728 }
8729 Py_INCREF(Py_None); resultobj = Py_None;
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8737 PyObject *resultobj;
8738 wxLog *arg1 = (wxLog *) 0 ;
8739 PyObject * obj0 = 0 ;
8740 char *kwnames[] = {
8741 (char *) "self", NULL
8742 };
8743
8744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8746 if (SWIG_arg_fail(1)) SWIG_fail;
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 (arg1)->Flush();
8750
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 Py_INCREF(Py_None); resultobj = Py_None;
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj;
8763 char *kwnames[] = {
8764 NULL
8765 };
8766
8767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8768 {
8769 PyThreadState* __tstate = wxPyBeginAllowThreads();
8770 wxLog::FlushActive();
8771
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 Py_INCREF(Py_None); resultobj = Py_None;
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj;
8784 wxLog *result;
8785 char *kwnames[] = {
8786 NULL
8787 };
8788
8789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8790 {
8791 PyThreadState* __tstate = wxPyBeginAllowThreads();
8792 result = (wxLog *)wxLog::GetActiveTarget();
8793
8794 wxPyEndAllowThreads(__tstate);
8795 if (PyErr_Occurred()) SWIG_fail;
8796 }
8797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8798 return resultobj;
8799 fail:
8800 return NULL;
8801 }
8802
8803
8804 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj;
8806 wxLog *arg1 = (wxLog *) 0 ;
8807 wxLog *result;
8808 PyObject * obj0 = 0 ;
8809 char *kwnames[] = {
8810 (char *) "pLogger", NULL
8811 };
8812
8813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8815 if (SWIG_arg_fail(1)) SWIG_fail;
8816 {
8817 PyThreadState* __tstate = wxPyBeginAllowThreads();
8818 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8819
8820 wxPyEndAllowThreads(__tstate);
8821 if (PyErr_Occurred()) SWIG_fail;
8822 }
8823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8831 PyObject *resultobj;
8832 char *kwnames[] = {
8833 NULL
8834 };
8835
8836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8837 {
8838 PyThreadState* __tstate = wxPyBeginAllowThreads();
8839 wxLog::Suspend();
8840
8841 wxPyEndAllowThreads(__tstate);
8842 if (PyErr_Occurred()) SWIG_fail;
8843 }
8844 Py_INCREF(Py_None); resultobj = Py_None;
8845 return resultobj;
8846 fail:
8847 return NULL;
8848 }
8849
8850
8851 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8852 PyObject *resultobj;
8853 char *kwnames[] = {
8854 NULL
8855 };
8856
8857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8858 {
8859 PyThreadState* __tstate = wxPyBeginAllowThreads();
8860 wxLog::Resume();
8861
8862 wxPyEndAllowThreads(__tstate);
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 Py_INCREF(Py_None); resultobj = Py_None;
8866 return resultobj;
8867 fail:
8868 return NULL;
8869 }
8870
8871
8872 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8873 PyObject *resultobj;
8874 bool arg1 = (bool) true ;
8875 PyObject * obj0 = 0 ;
8876 char *kwnames[] = {
8877 (char *) "bVerbose", NULL
8878 };
8879
8880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8881 if (obj0) {
8882 {
8883 arg1 = (bool)(SWIG_As_bool(obj0));
8884 if (SWIG_arg_fail(1)) SWIG_fail;
8885 }
8886 }
8887 {
8888 PyThreadState* __tstate = wxPyBeginAllowThreads();
8889 wxLog::SetVerbose(arg1);
8890
8891 wxPyEndAllowThreads(__tstate);
8892 if (PyErr_Occurred()) SWIG_fail;
8893 }
8894 Py_INCREF(Py_None); resultobj = Py_None;
8895 return resultobj;
8896 fail:
8897 return NULL;
8898 }
8899
8900
8901 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8902 PyObject *resultobj;
8903 wxLogLevel arg1 ;
8904 PyObject * obj0 = 0 ;
8905 char *kwnames[] = {
8906 (char *) "logLevel", NULL
8907 };
8908
8909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8910 {
8911 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8912 if (SWIG_arg_fail(1)) SWIG_fail;
8913 }
8914 {
8915 PyThreadState* __tstate = wxPyBeginAllowThreads();
8916 wxLog::SetLogLevel(arg1);
8917
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 Py_INCREF(Py_None); resultobj = Py_None;
8922 return resultobj;
8923 fail:
8924 return NULL;
8925 }
8926
8927
8928 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj;
8930 char *kwnames[] = {
8931 NULL
8932 };
8933
8934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 wxLog::DontCreateOnDemand();
8938
8939 wxPyEndAllowThreads(__tstate);
8940 if (PyErr_Occurred()) SWIG_fail;
8941 }
8942 Py_INCREF(Py_None); resultobj = Py_None;
8943 return resultobj;
8944 fail:
8945 return NULL;
8946 }
8947
8948
8949 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8950 PyObject *resultobj;
8951 wxTraceMask arg1 ;
8952 PyObject * obj0 = 0 ;
8953 char *kwnames[] = {
8954 (char *) "ulMask", NULL
8955 };
8956
8957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8958 {
8959 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8960 if (SWIG_arg_fail(1)) SWIG_fail;
8961 }
8962 {
8963 PyThreadState* __tstate = wxPyBeginAllowThreads();
8964 wxLog::SetTraceMask(arg1);
8965
8966 wxPyEndAllowThreads(__tstate);
8967 if (PyErr_Occurred()) SWIG_fail;
8968 }
8969 Py_INCREF(Py_None); resultobj = Py_None;
8970 return resultobj;
8971 fail:
8972 return NULL;
8973 }
8974
8975
8976 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8977 PyObject *resultobj;
8978 wxString *arg1 = 0 ;
8979 bool temp1 = false ;
8980 PyObject * obj0 = 0 ;
8981 char *kwnames[] = {
8982 (char *) "str", NULL
8983 };
8984
8985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
8986 {
8987 arg1 = wxString_in_helper(obj0);
8988 if (arg1 == NULL) SWIG_fail;
8989 temp1 = true;
8990 }
8991 {
8992 PyThreadState* __tstate = wxPyBeginAllowThreads();
8993 wxLog::AddTraceMask((wxString const &)*arg1);
8994
8995 wxPyEndAllowThreads(__tstate);
8996 if (PyErr_Occurred()) SWIG_fail;
8997 }
8998 Py_INCREF(Py_None); resultobj = Py_None;
8999 {
9000 if (temp1)
9001 delete arg1;
9002 }
9003 return resultobj;
9004 fail:
9005 {
9006 if (temp1)
9007 delete arg1;
9008 }
9009 return NULL;
9010 }
9011
9012
9013 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9014 PyObject *resultobj;
9015 wxString *arg1 = 0 ;
9016 bool temp1 = false ;
9017 PyObject * obj0 = 0 ;
9018 char *kwnames[] = {
9019 (char *) "str", NULL
9020 };
9021
9022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9023 {
9024 arg1 = wxString_in_helper(obj0);
9025 if (arg1 == NULL) SWIG_fail;
9026 temp1 = true;
9027 }
9028 {
9029 PyThreadState* __tstate = wxPyBeginAllowThreads();
9030 wxLog::RemoveTraceMask((wxString const &)*arg1);
9031
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 Py_INCREF(Py_None); resultobj = Py_None;
9036 {
9037 if (temp1)
9038 delete arg1;
9039 }
9040 return resultobj;
9041 fail:
9042 {
9043 if (temp1)
9044 delete arg1;
9045 }
9046 return NULL;
9047 }
9048
9049
9050 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9051 PyObject *resultobj;
9052 char *kwnames[] = {
9053 NULL
9054 };
9055
9056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9057 {
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 wxLog::ClearTraceMasks();
9060
9061 wxPyEndAllowThreads(__tstate);
9062 if (PyErr_Occurred()) SWIG_fail;
9063 }
9064 Py_INCREF(Py_None); resultobj = Py_None;
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9072 PyObject *resultobj;
9073 wxArrayString *result;
9074 char *kwnames[] = {
9075 NULL
9076 };
9077
9078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9079 {
9080 PyThreadState* __tstate = wxPyBeginAllowThreads();
9081 {
9082 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9083 result = (wxArrayString *) &_result_ref;
9084 }
9085
9086 wxPyEndAllowThreads(__tstate);
9087 if (PyErr_Occurred()) SWIG_fail;
9088 }
9089 {
9090 resultobj = wxArrayString2PyList_helper(*result);
9091 }
9092 return resultobj;
9093 fail:
9094 return NULL;
9095 }
9096
9097
9098 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9099 PyObject *resultobj;
9100 wxChar *arg1 = (wxChar *) 0 ;
9101 PyObject * obj0 = 0 ;
9102 char *kwnames[] = {
9103 (char *) "ts", NULL
9104 };
9105
9106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9108 if (SWIG_arg_fail(1)) SWIG_fail;
9109 {
9110 PyThreadState* __tstate = wxPyBeginAllowThreads();
9111 wxLog::SetTimestamp((wxChar const *)arg1);
9112
9113 wxPyEndAllowThreads(__tstate);
9114 if (PyErr_Occurred()) SWIG_fail;
9115 }
9116 Py_INCREF(Py_None); resultobj = Py_None;
9117 return resultobj;
9118 fail:
9119 return NULL;
9120 }
9121
9122
9123 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9124 PyObject *resultobj;
9125 bool result;
9126 char *kwnames[] = {
9127 NULL
9128 };
9129
9130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9131 {
9132 PyThreadState* __tstate = wxPyBeginAllowThreads();
9133 result = (bool)wxLog::GetVerbose();
9134
9135 wxPyEndAllowThreads(__tstate);
9136 if (PyErr_Occurred()) SWIG_fail;
9137 }
9138 {
9139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9140 }
9141 return resultobj;
9142 fail:
9143 return NULL;
9144 }
9145
9146
9147 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9148 PyObject *resultobj;
9149 wxTraceMask result;
9150 char *kwnames[] = {
9151 NULL
9152 };
9153
9154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (wxTraceMask)wxLog::GetTraceMask();
9158
9159 wxPyEndAllowThreads(__tstate);
9160 if (PyErr_Occurred()) SWIG_fail;
9161 }
9162 {
9163 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9164 }
9165 return resultobj;
9166 fail:
9167 return NULL;
9168 }
9169
9170
9171 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9172 PyObject *resultobj;
9173 wxChar *arg1 = (wxChar *) 0 ;
9174 bool result;
9175 PyObject * obj0 = 0 ;
9176 char *kwnames[] = {
9177 (char *) "mask", NULL
9178 };
9179
9180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9182 if (SWIG_arg_fail(1)) SWIG_fail;
9183 {
9184 PyThreadState* __tstate = wxPyBeginAllowThreads();
9185 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9186
9187 wxPyEndAllowThreads(__tstate);
9188 if (PyErr_Occurred()) SWIG_fail;
9189 }
9190 {
9191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9192 }
9193 return resultobj;
9194 fail:
9195 return NULL;
9196 }
9197
9198
9199 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9200 PyObject *resultobj;
9201 wxLogLevel result;
9202 char *kwnames[] = {
9203 NULL
9204 };
9205
9206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9207 {
9208 PyThreadState* __tstate = wxPyBeginAllowThreads();
9209 result = (wxLogLevel)wxLog::GetLogLevel();
9210
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 {
9215 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9216 }
9217 return resultobj;
9218 fail:
9219 return NULL;
9220 }
9221
9222
9223 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9224 PyObject *resultobj;
9225 wxChar *result;
9226 char *kwnames[] = {
9227 NULL
9228 };
9229
9230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9231 {
9232 PyThreadState* __tstate = wxPyBeginAllowThreads();
9233 result = (wxChar *)wxLog::GetTimestamp();
9234
9235 wxPyEndAllowThreads(__tstate);
9236 if (PyErr_Occurred()) SWIG_fail;
9237 }
9238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9239 return resultobj;
9240 fail:
9241 return NULL;
9242 }
9243
9244
9245 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9246 PyObject *resultobj;
9247 wxString result;
9248 char *kwnames[] = {
9249 NULL
9250 };
9251
9252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 result = Log_TimeStamp();
9256
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 {
9261 #if wxUSE_UNICODE
9262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9263 #else
9264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9265 #endif
9266 }
9267 return resultobj;
9268 fail:
9269 return NULL;
9270 }
9271
9272
9273 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9274 PyObject *resultobj;
9275 wxLog *arg1 = (wxLog *) 0 ;
9276 PyObject * obj0 = 0 ;
9277 char *kwnames[] = {
9278 (char *) "self", NULL
9279 };
9280
9281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9283 if (SWIG_arg_fail(1)) SWIG_fail;
9284 {
9285 PyThreadState* __tstate = wxPyBeginAllowThreads();
9286 wxLog_Destroy(arg1);
9287
9288 wxPyEndAllowThreads(__tstate);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 Py_INCREF(Py_None); resultobj = Py_None;
9292 return resultobj;
9293 fail:
9294 return NULL;
9295 }
9296
9297
9298 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9299 PyObject *obj;
9300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9301 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9302 Py_INCREF(obj);
9303 return Py_BuildValue((char *)"");
9304 }
9305 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9306 PyObject *resultobj;
9307 wxLogStderr *result;
9308 char *kwnames[] = {
9309 NULL
9310 };
9311
9312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9313 {
9314 PyThreadState* __tstate = wxPyBeginAllowThreads();
9315 result = (wxLogStderr *)new wxLogStderr();
9316
9317 wxPyEndAllowThreads(__tstate);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9321 return resultobj;
9322 fail:
9323 return NULL;
9324 }
9325
9326
9327 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9328 PyObject *obj;
9329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9330 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9331 Py_INCREF(obj);
9332 return Py_BuildValue((char *)"");
9333 }
9334 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9335 PyObject *resultobj;
9336 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9337 wxLogTextCtrl *result;
9338 PyObject * obj0 = 0 ;
9339 char *kwnames[] = {
9340 (char *) "pTextCtrl", NULL
9341 };
9342
9343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9345 if (SWIG_arg_fail(1)) SWIG_fail;
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9349
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9361 PyObject *obj;
9362 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9363 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9364 Py_INCREF(obj);
9365 return Py_BuildValue((char *)"");
9366 }
9367 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9368 PyObject *resultobj;
9369 wxLogGui *result;
9370 char *kwnames[] = {
9371 NULL
9372 };
9373
9374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (wxLogGui *)new wxLogGui();
9378
9379 wxPyEndAllowThreads(__tstate);
9380 if (PyErr_Occurred()) SWIG_fail;
9381 }
9382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9383 return resultobj;
9384 fail:
9385 return NULL;
9386 }
9387
9388
9389 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9390 PyObject *obj;
9391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9392 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9393 Py_INCREF(obj);
9394 return Py_BuildValue((char *)"");
9395 }
9396 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj;
9398 wxFrame *arg1 = (wxFrame *) 0 ;
9399 wxString *arg2 = 0 ;
9400 bool arg3 = (bool) true ;
9401 bool arg4 = (bool) true ;
9402 wxLogWindow *result;
9403 bool temp2 = false ;
9404 PyObject * obj0 = 0 ;
9405 PyObject * obj1 = 0 ;
9406 PyObject * obj2 = 0 ;
9407 PyObject * obj3 = 0 ;
9408 char *kwnames[] = {
9409 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9410 };
9411
9412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9414 if (SWIG_arg_fail(1)) SWIG_fail;
9415 {
9416 arg2 = wxString_in_helper(obj1);
9417 if (arg2 == NULL) SWIG_fail;
9418 temp2 = true;
9419 }
9420 if (obj2) {
9421 {
9422 arg3 = (bool)(SWIG_As_bool(obj2));
9423 if (SWIG_arg_fail(3)) SWIG_fail;
9424 }
9425 }
9426 if (obj3) {
9427 {
9428 arg4 = (bool)(SWIG_As_bool(obj3));
9429 if (SWIG_arg_fail(4)) SWIG_fail;
9430 }
9431 }
9432 {
9433 PyThreadState* __tstate = wxPyBeginAllowThreads();
9434 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9435
9436 wxPyEndAllowThreads(__tstate);
9437 if (PyErr_Occurred()) SWIG_fail;
9438 }
9439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9440 {
9441 if (temp2)
9442 delete arg2;
9443 }
9444 return resultobj;
9445 fail:
9446 {
9447 if (temp2)
9448 delete arg2;
9449 }
9450 return NULL;
9451 }
9452
9453
9454 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9455 PyObject *resultobj;
9456 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9457 bool arg2 = (bool) true ;
9458 PyObject * obj0 = 0 ;
9459 PyObject * obj1 = 0 ;
9460 char *kwnames[] = {
9461 (char *) "self",(char *) "bShow", NULL
9462 };
9463
9464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9466 if (SWIG_arg_fail(1)) SWIG_fail;
9467 if (obj1) {
9468 {
9469 arg2 = (bool)(SWIG_As_bool(obj1));
9470 if (SWIG_arg_fail(2)) SWIG_fail;
9471 }
9472 }
9473 {
9474 PyThreadState* __tstate = wxPyBeginAllowThreads();
9475 (arg1)->Show(arg2);
9476
9477 wxPyEndAllowThreads(__tstate);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 Py_INCREF(Py_None); resultobj = Py_None;
9481 return resultobj;
9482 fail:
9483 return NULL;
9484 }
9485
9486
9487 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9488 PyObject *resultobj;
9489 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9490 wxFrame *result;
9491 PyObject * obj0 = 0 ;
9492 char *kwnames[] = {
9493 (char *) "self", NULL
9494 };
9495
9496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9498 if (SWIG_arg_fail(1)) SWIG_fail;
9499 {
9500 PyThreadState* __tstate = wxPyBeginAllowThreads();
9501 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9502
9503 wxPyEndAllowThreads(__tstate);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 {
9507 resultobj = wxPyMake_wxObject(result, 0);
9508 }
9509 return resultobj;
9510 fail:
9511 return NULL;
9512 }
9513
9514
9515 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9516 PyObject *resultobj;
9517 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9518 wxLog *result;
9519 PyObject * obj0 = 0 ;
9520 char *kwnames[] = {
9521 (char *) "self", NULL
9522 };
9523
9524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9526 if (SWIG_arg_fail(1)) SWIG_fail;
9527 {
9528 PyThreadState* __tstate = wxPyBeginAllowThreads();
9529 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9530
9531 wxPyEndAllowThreads(__tstate);
9532 if (PyErr_Occurred()) SWIG_fail;
9533 }
9534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9535 return resultobj;
9536 fail:
9537 return NULL;
9538 }
9539
9540
9541 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9542 PyObject *resultobj;
9543 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9544 bool result;
9545 PyObject * obj0 = 0 ;
9546 char *kwnames[] = {
9547 (char *) "self", NULL
9548 };
9549
9550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9552 if (SWIG_arg_fail(1)) SWIG_fail;
9553 {
9554 PyThreadState* __tstate = wxPyBeginAllowThreads();
9555 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9556
9557 wxPyEndAllowThreads(__tstate);
9558 if (PyErr_Occurred()) SWIG_fail;
9559 }
9560 {
9561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9562 }
9563 return resultobj;
9564 fail:
9565 return NULL;
9566 }
9567
9568
9569 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9570 PyObject *resultobj;
9571 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9572 bool arg2 ;
9573 PyObject * obj0 = 0 ;
9574 PyObject * obj1 = 0 ;
9575 char *kwnames[] = {
9576 (char *) "self",(char *) "bDoPass", NULL
9577 };
9578
9579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9581 if (SWIG_arg_fail(1)) SWIG_fail;
9582 {
9583 arg2 = (bool)(SWIG_As_bool(obj1));
9584 if (SWIG_arg_fail(2)) SWIG_fail;
9585 }
9586 {
9587 PyThreadState* __tstate = wxPyBeginAllowThreads();
9588 (arg1)->PassMessages(arg2);
9589
9590 wxPyEndAllowThreads(__tstate);
9591 if (PyErr_Occurred()) SWIG_fail;
9592 }
9593 Py_INCREF(Py_None); resultobj = Py_None;
9594 return resultobj;
9595 fail:
9596 return NULL;
9597 }
9598
9599
9600 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9601 PyObject *obj;
9602 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9603 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9604 Py_INCREF(obj);
9605 return Py_BuildValue((char *)"");
9606 }
9607 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9608 PyObject *resultobj;
9609 wxLog *arg1 = (wxLog *) 0 ;
9610 wxLogChain *result;
9611 PyObject * obj0 = 0 ;
9612 char *kwnames[] = {
9613 (char *) "logger", NULL
9614 };
9615
9616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9618 if (SWIG_arg_fail(1)) SWIG_fail;
9619 {
9620 PyThreadState* __tstate = wxPyBeginAllowThreads();
9621 result = (wxLogChain *)new wxLogChain(arg1);
9622
9623 wxPyEndAllowThreads(__tstate);
9624 if (PyErr_Occurred()) SWIG_fail;
9625 }
9626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9627 return resultobj;
9628 fail:
9629 return NULL;
9630 }
9631
9632
9633 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj;
9635 wxLogChain *arg1 = (wxLogChain *) 0 ;
9636 wxLog *arg2 = (wxLog *) 0 ;
9637 PyObject * obj0 = 0 ;
9638 PyObject * obj1 = 0 ;
9639 char *kwnames[] = {
9640 (char *) "self",(char *) "logger", NULL
9641 };
9642
9643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9645 if (SWIG_arg_fail(1)) SWIG_fail;
9646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9647 if (SWIG_arg_fail(2)) SWIG_fail;
9648 {
9649 PyThreadState* __tstate = wxPyBeginAllowThreads();
9650 (arg1)->SetLog(arg2);
9651
9652 wxPyEndAllowThreads(__tstate);
9653 if (PyErr_Occurred()) SWIG_fail;
9654 }
9655 Py_INCREF(Py_None); resultobj = Py_None;
9656 return resultobj;
9657 fail:
9658 return NULL;
9659 }
9660
9661
9662 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9663 PyObject *resultobj;
9664 wxLogChain *arg1 = (wxLogChain *) 0 ;
9665 bool arg2 ;
9666 PyObject * obj0 = 0 ;
9667 PyObject * obj1 = 0 ;
9668 char *kwnames[] = {
9669 (char *) "self",(char *) "bDoPass", NULL
9670 };
9671
9672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9674 if (SWIG_arg_fail(1)) SWIG_fail;
9675 {
9676 arg2 = (bool)(SWIG_As_bool(obj1));
9677 if (SWIG_arg_fail(2)) SWIG_fail;
9678 }
9679 {
9680 PyThreadState* __tstate = wxPyBeginAllowThreads();
9681 (arg1)->PassMessages(arg2);
9682
9683 wxPyEndAllowThreads(__tstate);
9684 if (PyErr_Occurred()) SWIG_fail;
9685 }
9686 Py_INCREF(Py_None); resultobj = Py_None;
9687 return resultobj;
9688 fail:
9689 return NULL;
9690 }
9691
9692
9693 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9694 PyObject *resultobj;
9695 wxLogChain *arg1 = (wxLogChain *) 0 ;
9696 bool result;
9697 PyObject * obj0 = 0 ;
9698 char *kwnames[] = {
9699 (char *) "self", NULL
9700 };
9701
9702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9704 if (SWIG_arg_fail(1)) SWIG_fail;
9705 {
9706 PyThreadState* __tstate = wxPyBeginAllowThreads();
9707 result = (bool)(arg1)->IsPassingMessages();
9708
9709 wxPyEndAllowThreads(__tstate);
9710 if (PyErr_Occurred()) SWIG_fail;
9711 }
9712 {
9713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9714 }
9715 return resultobj;
9716 fail:
9717 return NULL;
9718 }
9719
9720
9721 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9722 PyObject *resultobj;
9723 wxLogChain *arg1 = (wxLogChain *) 0 ;
9724 wxLog *result;
9725 PyObject * obj0 = 0 ;
9726 char *kwnames[] = {
9727 (char *) "self", NULL
9728 };
9729
9730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9732 if (SWIG_arg_fail(1)) SWIG_fail;
9733 {
9734 PyThreadState* __tstate = wxPyBeginAllowThreads();
9735 result = (wxLog *)(arg1)->GetOldLog();
9736
9737 wxPyEndAllowThreads(__tstate);
9738 if (PyErr_Occurred()) SWIG_fail;
9739 }
9740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9741 return resultobj;
9742 fail:
9743 return NULL;
9744 }
9745
9746
9747 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9748 PyObject *obj;
9749 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9750 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9751 Py_INCREF(obj);
9752 return Py_BuildValue((char *)"");
9753 }
9754 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9755 PyObject *resultobj;
9756 unsigned long result;
9757 char *kwnames[] = {
9758 NULL
9759 };
9760
9761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9762 {
9763 PyThreadState* __tstate = wxPyBeginAllowThreads();
9764 result = (unsigned long)wxSysErrorCode();
9765
9766 wxPyEndAllowThreads(__tstate);
9767 if (PyErr_Occurred()) SWIG_fail;
9768 }
9769 {
9770 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9771 }
9772 return resultobj;
9773 fail:
9774 return NULL;
9775 }
9776
9777
9778 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9779 PyObject *resultobj;
9780 unsigned long arg1 = (unsigned long) 0 ;
9781 wxString result;
9782 PyObject * obj0 = 0 ;
9783 char *kwnames[] = {
9784 (char *) "nErrCode", NULL
9785 };
9786
9787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9788 if (obj0) {
9789 {
9790 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9791 if (SWIG_arg_fail(1)) SWIG_fail;
9792 }
9793 }
9794 {
9795 PyThreadState* __tstate = wxPyBeginAllowThreads();
9796 result = wxSysErrorMsg(arg1);
9797
9798 wxPyEndAllowThreads(__tstate);
9799 if (PyErr_Occurred()) SWIG_fail;
9800 }
9801 {
9802 #if wxUSE_UNICODE
9803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9804 #else
9805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9806 #endif
9807 }
9808 return resultobj;
9809 fail:
9810 return NULL;
9811 }
9812
9813
9814 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9815 PyObject *resultobj;
9816 wxString *arg1 = 0 ;
9817 bool temp1 = false ;
9818 PyObject * obj0 = 0 ;
9819 char *kwnames[] = {
9820 (char *) "msg", NULL
9821 };
9822
9823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9824 {
9825 arg1 = wxString_in_helper(obj0);
9826 if (arg1 == NULL) SWIG_fail;
9827 temp1 = true;
9828 }
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 wxPyLogFatalError((wxString const &)*arg1);
9832
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 Py_INCREF(Py_None); resultobj = Py_None;
9837 {
9838 if (temp1)
9839 delete arg1;
9840 }
9841 return resultobj;
9842 fail:
9843 {
9844 if (temp1)
9845 delete arg1;
9846 }
9847 return NULL;
9848 }
9849
9850
9851 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9852 PyObject *resultobj;
9853 wxString *arg1 = 0 ;
9854 bool temp1 = false ;
9855 PyObject * obj0 = 0 ;
9856 char *kwnames[] = {
9857 (char *) "msg", NULL
9858 };
9859
9860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9861 {
9862 arg1 = wxString_in_helper(obj0);
9863 if (arg1 == NULL) SWIG_fail;
9864 temp1 = true;
9865 }
9866 {
9867 PyThreadState* __tstate = wxPyBeginAllowThreads();
9868 wxPyLogError((wxString const &)*arg1);
9869
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 Py_INCREF(Py_None); resultobj = Py_None;
9874 {
9875 if (temp1)
9876 delete arg1;
9877 }
9878 return resultobj;
9879 fail:
9880 {
9881 if (temp1)
9882 delete arg1;
9883 }
9884 return NULL;
9885 }
9886
9887
9888 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9889 PyObject *resultobj;
9890 wxString *arg1 = 0 ;
9891 bool temp1 = false ;
9892 PyObject * obj0 = 0 ;
9893 char *kwnames[] = {
9894 (char *) "msg", NULL
9895 };
9896
9897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9898 {
9899 arg1 = wxString_in_helper(obj0);
9900 if (arg1 == NULL) SWIG_fail;
9901 temp1 = true;
9902 }
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 wxPyLogWarning((wxString const &)*arg1);
9906
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 Py_INCREF(Py_None); resultobj = Py_None;
9911 {
9912 if (temp1)
9913 delete arg1;
9914 }
9915 return resultobj;
9916 fail:
9917 {
9918 if (temp1)
9919 delete arg1;
9920 }
9921 return NULL;
9922 }
9923
9924
9925 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9926 PyObject *resultobj;
9927 wxString *arg1 = 0 ;
9928 bool temp1 = false ;
9929 PyObject * obj0 = 0 ;
9930 char *kwnames[] = {
9931 (char *) "msg", NULL
9932 };
9933
9934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9935 {
9936 arg1 = wxString_in_helper(obj0);
9937 if (arg1 == NULL) SWIG_fail;
9938 temp1 = true;
9939 }
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 wxPyLogMessage((wxString const &)*arg1);
9943
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 Py_INCREF(Py_None); resultobj = Py_None;
9948 {
9949 if (temp1)
9950 delete arg1;
9951 }
9952 return resultobj;
9953 fail:
9954 {
9955 if (temp1)
9956 delete arg1;
9957 }
9958 return NULL;
9959 }
9960
9961
9962 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9963 PyObject *resultobj;
9964 wxString *arg1 = 0 ;
9965 bool temp1 = false ;
9966 PyObject * obj0 = 0 ;
9967 char *kwnames[] = {
9968 (char *) "msg", NULL
9969 };
9970
9971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9972 {
9973 arg1 = wxString_in_helper(obj0);
9974 if (arg1 == NULL) SWIG_fail;
9975 temp1 = true;
9976 }
9977 {
9978 PyThreadState* __tstate = wxPyBeginAllowThreads();
9979 wxPyLogInfo((wxString const &)*arg1);
9980
9981 wxPyEndAllowThreads(__tstate);
9982 if (PyErr_Occurred()) SWIG_fail;
9983 }
9984 Py_INCREF(Py_None); resultobj = Py_None;
9985 {
9986 if (temp1)
9987 delete arg1;
9988 }
9989 return resultobj;
9990 fail:
9991 {
9992 if (temp1)
9993 delete arg1;
9994 }
9995 return NULL;
9996 }
9997
9998
9999 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10000 PyObject *resultobj;
10001 wxString *arg1 = 0 ;
10002 bool temp1 = false ;
10003 PyObject * obj0 = 0 ;
10004 char *kwnames[] = {
10005 (char *) "msg", NULL
10006 };
10007
10008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10009 {
10010 arg1 = wxString_in_helper(obj0);
10011 if (arg1 == NULL) SWIG_fail;
10012 temp1 = true;
10013 }
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 wxPyLogDebug((wxString const &)*arg1);
10017
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 Py_INCREF(Py_None); resultobj = Py_None;
10022 {
10023 if (temp1)
10024 delete arg1;
10025 }
10026 return resultobj;
10027 fail:
10028 {
10029 if (temp1)
10030 delete arg1;
10031 }
10032 return NULL;
10033 }
10034
10035
10036 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10037 PyObject *resultobj;
10038 wxString *arg1 = 0 ;
10039 bool temp1 = false ;
10040 PyObject * obj0 = 0 ;
10041 char *kwnames[] = {
10042 (char *) "msg", NULL
10043 };
10044
10045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10046 {
10047 arg1 = wxString_in_helper(obj0);
10048 if (arg1 == NULL) SWIG_fail;
10049 temp1 = true;
10050 }
10051 {
10052 PyThreadState* __tstate = wxPyBeginAllowThreads();
10053 wxPyLogVerbose((wxString const &)*arg1);
10054
10055 wxPyEndAllowThreads(__tstate);
10056 if (PyErr_Occurred()) SWIG_fail;
10057 }
10058 Py_INCREF(Py_None); resultobj = Py_None;
10059 {
10060 if (temp1)
10061 delete arg1;
10062 }
10063 return resultobj;
10064 fail:
10065 {
10066 if (temp1)
10067 delete arg1;
10068 }
10069 return NULL;
10070 }
10071
10072
10073 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10074 PyObject *resultobj;
10075 wxString *arg1 = 0 ;
10076 bool temp1 = false ;
10077 PyObject * obj0 = 0 ;
10078 char *kwnames[] = {
10079 (char *) "msg", NULL
10080 };
10081
10082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10083 {
10084 arg1 = wxString_in_helper(obj0);
10085 if (arg1 == NULL) SWIG_fail;
10086 temp1 = true;
10087 }
10088 {
10089 PyThreadState* __tstate = wxPyBeginAllowThreads();
10090 wxPyLogStatus((wxString const &)*arg1);
10091
10092 wxPyEndAllowThreads(__tstate);
10093 if (PyErr_Occurred()) SWIG_fail;
10094 }
10095 Py_INCREF(Py_None); resultobj = Py_None;
10096 {
10097 if (temp1)
10098 delete arg1;
10099 }
10100 return resultobj;
10101 fail:
10102 {
10103 if (temp1)
10104 delete arg1;
10105 }
10106 return NULL;
10107 }
10108
10109
10110 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10111 PyObject *resultobj;
10112 wxFrame *arg1 = (wxFrame *) 0 ;
10113 wxString *arg2 = 0 ;
10114 bool temp2 = false ;
10115 PyObject * obj0 = 0 ;
10116 PyObject * obj1 = 0 ;
10117 char *kwnames[] = {
10118 (char *) "pFrame",(char *) "msg", NULL
10119 };
10120
10121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10123 if (SWIG_arg_fail(1)) SWIG_fail;
10124 {
10125 arg2 = wxString_in_helper(obj1);
10126 if (arg2 == NULL) SWIG_fail;
10127 temp2 = true;
10128 }
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10132
10133 wxPyEndAllowThreads(__tstate);
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 Py_INCREF(Py_None); resultobj = Py_None;
10137 {
10138 if (temp2)
10139 delete arg2;
10140 }
10141 return resultobj;
10142 fail:
10143 {
10144 if (temp2)
10145 delete arg2;
10146 }
10147 return NULL;
10148 }
10149
10150
10151 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj;
10153 wxString *arg1 = 0 ;
10154 bool temp1 = false ;
10155 PyObject * obj0 = 0 ;
10156 char *kwnames[] = {
10157 (char *) "msg", NULL
10158 };
10159
10160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10161 {
10162 arg1 = wxString_in_helper(obj0);
10163 if (arg1 == NULL) SWIG_fail;
10164 temp1 = true;
10165 }
10166 {
10167 PyThreadState* __tstate = wxPyBeginAllowThreads();
10168 wxPyLogSysError((wxString const &)*arg1);
10169
10170 wxPyEndAllowThreads(__tstate);
10171 if (PyErr_Occurred()) SWIG_fail;
10172 }
10173 Py_INCREF(Py_None); resultobj = Py_None;
10174 {
10175 if (temp1)
10176 delete arg1;
10177 }
10178 return resultobj;
10179 fail:
10180 {
10181 if (temp1)
10182 delete arg1;
10183 }
10184 return NULL;
10185 }
10186
10187
10188 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10189 PyObject *resultobj;
10190 unsigned long arg1 ;
10191 wxString *arg2 = 0 ;
10192 bool temp2 = false ;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 char *kwnames[] = {
10196 (char *) "level",(char *) "msg", NULL
10197 };
10198
10199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10200 {
10201 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10202 if (SWIG_arg_fail(1)) SWIG_fail;
10203 }
10204 {
10205 arg2 = wxString_in_helper(obj1);
10206 if (arg2 == NULL) SWIG_fail;
10207 temp2 = true;
10208 }
10209 {
10210 PyThreadState* __tstate = wxPyBeginAllowThreads();
10211 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10212
10213 wxPyEndAllowThreads(__tstate);
10214 if (PyErr_Occurred()) SWIG_fail;
10215 }
10216 Py_INCREF(Py_None); resultobj = Py_None;
10217 {
10218 if (temp2)
10219 delete arg2;
10220 }
10221 return resultobj;
10222 fail:
10223 {
10224 if (temp2)
10225 delete arg2;
10226 }
10227 return NULL;
10228 }
10229
10230
10231 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10232 PyObject *resultobj;
10233 unsigned long arg1 ;
10234 wxString *arg2 = 0 ;
10235 bool temp2 = false ;
10236 PyObject * obj0 = 0 ;
10237 PyObject * obj1 = 0 ;
10238
10239 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10240 {
10241 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10242 if (SWIG_arg_fail(1)) SWIG_fail;
10243 }
10244 {
10245 arg2 = wxString_in_helper(obj1);
10246 if (arg2 == NULL) SWIG_fail;
10247 temp2 = true;
10248 }
10249 {
10250 PyThreadState* __tstate = wxPyBeginAllowThreads();
10251 wxPyLogTrace(arg1,(wxString const &)*arg2);
10252
10253 wxPyEndAllowThreads(__tstate);
10254 if (PyErr_Occurred()) SWIG_fail;
10255 }
10256 Py_INCREF(Py_None); resultobj = Py_None;
10257 {
10258 if (temp2)
10259 delete arg2;
10260 }
10261 return resultobj;
10262 fail:
10263 {
10264 if (temp2)
10265 delete arg2;
10266 }
10267 return NULL;
10268 }
10269
10270
10271 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10272 PyObject *resultobj;
10273 wxString *arg1 = 0 ;
10274 wxString *arg2 = 0 ;
10275 bool temp1 = false ;
10276 bool temp2 = false ;
10277 PyObject * obj0 = 0 ;
10278 PyObject * obj1 = 0 ;
10279
10280 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10281 {
10282 arg1 = wxString_in_helper(obj0);
10283 if (arg1 == NULL) SWIG_fail;
10284 temp1 = true;
10285 }
10286 {
10287 arg2 = wxString_in_helper(obj1);
10288 if (arg2 == NULL) SWIG_fail;
10289 temp2 = true;
10290 }
10291 {
10292 PyThreadState* __tstate = wxPyBeginAllowThreads();
10293 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10294
10295 wxPyEndAllowThreads(__tstate);
10296 if (PyErr_Occurred()) SWIG_fail;
10297 }
10298 Py_INCREF(Py_None); resultobj = Py_None;
10299 {
10300 if (temp1)
10301 delete arg1;
10302 }
10303 {
10304 if (temp2)
10305 delete arg2;
10306 }
10307 return resultobj;
10308 fail:
10309 {
10310 if (temp1)
10311 delete arg1;
10312 }
10313 {
10314 if (temp2)
10315 delete arg2;
10316 }
10317 return NULL;
10318 }
10319
10320
10321 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10322 int argc;
10323 PyObject *argv[3];
10324 int ii;
10325
10326 argc = PyObject_Length(args);
10327 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10328 argv[ii] = PyTuple_GetItem(args,ii);
10329 }
10330 if (argc == 2) {
10331 int _v;
10332 {
10333 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10334 }
10335 if (_v) {
10336 {
10337 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10338 }
10339 if (_v) {
10340 return _wrap_LogTrace__SWIG_1(self,args);
10341 }
10342 }
10343 }
10344 if (argc == 2) {
10345 int _v;
10346 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10347 if (_v) {
10348 {
10349 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10350 }
10351 if (_v) {
10352 return _wrap_LogTrace__SWIG_0(self,args);
10353 }
10354 }
10355 }
10356
10357 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10358 return NULL;
10359 }
10360
10361
10362 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10363 PyObject *resultobj;
10364 wxString *arg1 = 0 ;
10365 wxString *arg2 = 0 ;
10366 bool temp1 = false ;
10367 bool temp2 = false ;
10368 PyObject * obj0 = 0 ;
10369 PyObject * obj1 = 0 ;
10370 char *kwnames[] = {
10371 (char *) "title",(char *) "text", NULL
10372 };
10373
10374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10375 {
10376 arg1 = wxString_in_helper(obj0);
10377 if (arg1 == NULL) SWIG_fail;
10378 temp1 = true;
10379 }
10380 {
10381 arg2 = wxString_in_helper(obj1);
10382 if (arg2 == NULL) SWIG_fail;
10383 temp2 = true;
10384 }
10385 {
10386 PyThreadState* __tstate = wxPyBeginAllowThreads();
10387 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10388
10389 wxPyEndAllowThreads(__tstate);
10390 if (PyErr_Occurred()) SWIG_fail;
10391 }
10392 Py_INCREF(Py_None); resultobj = Py_None;
10393 {
10394 if (temp1)
10395 delete arg1;
10396 }
10397 {
10398 if (temp2)
10399 delete arg2;
10400 }
10401 return resultobj;
10402 fail:
10403 {
10404 if (temp1)
10405 delete arg1;
10406 }
10407 {
10408 if (temp2)
10409 delete arg2;
10410 }
10411 return NULL;
10412 }
10413
10414
10415 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10416 PyObject *resultobj;
10417 wxLogNull *result;
10418 char *kwnames[] = {
10419 NULL
10420 };
10421
10422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10423 {
10424 PyThreadState* __tstate = wxPyBeginAllowThreads();
10425 result = (wxLogNull *)new wxLogNull();
10426
10427 wxPyEndAllowThreads(__tstate);
10428 if (PyErr_Occurred()) SWIG_fail;
10429 }
10430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10431 return resultobj;
10432 fail:
10433 return NULL;
10434 }
10435
10436
10437 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10438 PyObject *resultobj;
10439 wxLogNull *arg1 = (wxLogNull *) 0 ;
10440 PyObject * obj0 = 0 ;
10441 char *kwnames[] = {
10442 (char *) "self", NULL
10443 };
10444
10445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10447 if (SWIG_arg_fail(1)) SWIG_fail;
10448 {
10449 PyThreadState* __tstate = wxPyBeginAllowThreads();
10450 delete arg1;
10451
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 Py_INCREF(Py_None); resultobj = Py_None;
10456 return resultobj;
10457 fail:
10458 return NULL;
10459 }
10460
10461
10462 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10463 PyObject *obj;
10464 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10465 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10466 Py_INCREF(obj);
10467 return Py_BuildValue((char *)"");
10468 }
10469 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10470 PyObject *resultobj;
10471 wxPyLog *result;
10472 char *kwnames[] = {
10473 NULL
10474 };
10475
10476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10477 {
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (wxPyLog *)new wxPyLog();
10480
10481 wxPyEndAllowThreads(__tstate);
10482 if (PyErr_Occurred()) SWIG_fail;
10483 }
10484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10485 return resultobj;
10486 fail:
10487 return NULL;
10488 }
10489
10490
10491 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10492 PyObject *resultobj;
10493 wxPyLog *arg1 = (wxPyLog *) 0 ;
10494 PyObject *arg2 = (PyObject *) 0 ;
10495 PyObject *arg3 = (PyObject *) 0 ;
10496 PyObject * obj0 = 0 ;
10497 PyObject * obj1 = 0 ;
10498 PyObject * obj2 = 0 ;
10499 char *kwnames[] = {
10500 (char *) "self",(char *) "self",(char *) "_class", NULL
10501 };
10502
10503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10505 if (SWIG_arg_fail(1)) SWIG_fail;
10506 arg2 = obj1;
10507 arg3 = obj2;
10508 {
10509 PyThreadState* __tstate = wxPyBeginAllowThreads();
10510 (arg1)->_setCallbackInfo(arg2,arg3);
10511
10512 wxPyEndAllowThreads(__tstate);
10513 if (PyErr_Occurred()) SWIG_fail;
10514 }
10515 Py_INCREF(Py_None); resultobj = Py_None;
10516 return resultobj;
10517 fail:
10518 return NULL;
10519 }
10520
10521
10522 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10523 PyObject *obj;
10524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10525 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10526 Py_INCREF(obj);
10527 return Py_BuildValue((char *)"");
10528 }
10529 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10530 PyObject *resultobj;
10531 int arg1 ;
10532 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10533 int arg3 = (int) wxKILL_NOCHILDREN ;
10534 wxKillError result;
10535 PyObject * obj0 = 0 ;
10536 PyObject * obj1 = 0 ;
10537 PyObject * obj2 = 0 ;
10538 char *kwnames[] = {
10539 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10540 };
10541
10542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10543 {
10544 arg1 = (int)(SWIG_As_int(obj0));
10545 if (SWIG_arg_fail(1)) SWIG_fail;
10546 }
10547 if (obj1) {
10548 {
10549 arg2 = (wxSignal)(SWIG_As_int(obj1));
10550 if (SWIG_arg_fail(2)) SWIG_fail;
10551 }
10552 }
10553 if (obj2) {
10554 {
10555 arg3 = (int)(SWIG_As_int(obj2));
10556 if (SWIG_arg_fail(3)) SWIG_fail;
10557 }
10558 }
10559 {
10560 PyThreadState* __tstate = wxPyBeginAllowThreads();
10561 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10562
10563 wxPyEndAllowThreads(__tstate);
10564 if (PyErr_Occurred()) SWIG_fail;
10565 }
10566 resultobj = SWIG_From_int((result));
10567 return resultobj;
10568 fail:
10569 return NULL;
10570 }
10571
10572
10573 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10574 PyObject *resultobj;
10575 int arg1 ;
10576 bool result;
10577 PyObject * obj0 = 0 ;
10578 char *kwnames[] = {
10579 (char *) "pid", NULL
10580 };
10581
10582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10583 {
10584 arg1 = (int)(SWIG_As_int(obj0));
10585 if (SWIG_arg_fail(1)) SWIG_fail;
10586 }
10587 {
10588 PyThreadState* __tstate = wxPyBeginAllowThreads();
10589 result = (bool)wxPyProcess::Exists(arg1);
10590
10591 wxPyEndAllowThreads(__tstate);
10592 if (PyErr_Occurred()) SWIG_fail;
10593 }
10594 {
10595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10596 }
10597 return resultobj;
10598 fail:
10599 return NULL;
10600 }
10601
10602
10603 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10604 PyObject *resultobj;
10605 wxString *arg1 = 0 ;
10606 int arg2 = (int) wxEXEC_ASYNC ;
10607 wxPyProcess *result;
10608 bool temp1 = false ;
10609 PyObject * obj0 = 0 ;
10610 PyObject * obj1 = 0 ;
10611 char *kwnames[] = {
10612 (char *) "cmd",(char *) "flags", NULL
10613 };
10614
10615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10616 {
10617 arg1 = wxString_in_helper(obj0);
10618 if (arg1 == NULL) SWIG_fail;
10619 temp1 = true;
10620 }
10621 if (obj1) {
10622 {
10623 arg2 = (int)(SWIG_As_int(obj1));
10624 if (SWIG_arg_fail(2)) SWIG_fail;
10625 }
10626 }
10627 {
10628 PyThreadState* __tstate = wxPyBeginAllowThreads();
10629 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10630
10631 wxPyEndAllowThreads(__tstate);
10632 if (PyErr_Occurred()) SWIG_fail;
10633 }
10634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10635 {
10636 if (temp1)
10637 delete arg1;
10638 }
10639 return resultobj;
10640 fail:
10641 {
10642 if (temp1)
10643 delete arg1;
10644 }
10645 return NULL;
10646 }
10647
10648
10649 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10650 PyObject *resultobj;
10651 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10652 int arg2 = (int) -1 ;
10653 wxPyProcess *result;
10654 PyObject * obj0 = 0 ;
10655 PyObject * obj1 = 0 ;
10656 char *kwnames[] = {
10657 (char *) "parent",(char *) "id", NULL
10658 };
10659
10660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10661 if (obj0) {
10662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10663 if (SWIG_arg_fail(1)) SWIG_fail;
10664 }
10665 if (obj1) {
10666 {
10667 arg2 = (int)(SWIG_As_int(obj1));
10668 if (SWIG_arg_fail(2)) SWIG_fail;
10669 }
10670 }
10671 {
10672 PyThreadState* __tstate = wxPyBeginAllowThreads();
10673 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10674
10675 wxPyEndAllowThreads(__tstate);
10676 if (PyErr_Occurred()) SWIG_fail;
10677 }
10678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10679 return resultobj;
10680 fail:
10681 return NULL;
10682 }
10683
10684
10685 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10686 PyObject *resultobj;
10687 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10688 PyObject *arg2 = (PyObject *) 0 ;
10689 PyObject *arg3 = (PyObject *) 0 ;
10690 PyObject * obj0 = 0 ;
10691 PyObject * obj1 = 0 ;
10692 PyObject * obj2 = 0 ;
10693 char *kwnames[] = {
10694 (char *) "self",(char *) "self",(char *) "_class", NULL
10695 };
10696
10697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10699 if (SWIG_arg_fail(1)) SWIG_fail;
10700 arg2 = obj1;
10701 arg3 = obj2;
10702 {
10703 PyThreadState* __tstate = wxPyBeginAllowThreads();
10704 (arg1)->_setCallbackInfo(arg2,arg3);
10705
10706 wxPyEndAllowThreads(__tstate);
10707 if (PyErr_Occurred()) SWIG_fail;
10708 }
10709 Py_INCREF(Py_None); resultobj = Py_None;
10710 return resultobj;
10711 fail:
10712 return NULL;
10713 }
10714
10715
10716 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10717 PyObject *resultobj;
10718 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10719 int arg2 ;
10720 int arg3 ;
10721 PyObject * obj0 = 0 ;
10722 PyObject * obj1 = 0 ;
10723 PyObject * obj2 = 0 ;
10724 char *kwnames[] = {
10725 (char *) "self",(char *) "pid",(char *) "status", NULL
10726 };
10727
10728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10730 if (SWIG_arg_fail(1)) SWIG_fail;
10731 {
10732 arg2 = (int)(SWIG_As_int(obj1));
10733 if (SWIG_arg_fail(2)) SWIG_fail;
10734 }
10735 {
10736 arg3 = (int)(SWIG_As_int(obj2));
10737 if (SWIG_arg_fail(3)) SWIG_fail;
10738 }
10739 {
10740 PyThreadState* __tstate = wxPyBeginAllowThreads();
10741 (arg1)->base_OnTerminate(arg2,arg3);
10742
10743 wxPyEndAllowThreads(__tstate);
10744 if (PyErr_Occurred()) SWIG_fail;
10745 }
10746 Py_INCREF(Py_None); resultobj = Py_None;
10747 return resultobj;
10748 fail:
10749 return NULL;
10750 }
10751
10752
10753 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10754 PyObject *resultobj;
10755 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10756 PyObject * obj0 = 0 ;
10757 char *kwnames[] = {
10758 (char *) "self", NULL
10759 };
10760
10761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10763 if (SWIG_arg_fail(1)) SWIG_fail;
10764 {
10765 PyThreadState* __tstate = wxPyBeginAllowThreads();
10766 (arg1)->Redirect();
10767
10768 wxPyEndAllowThreads(__tstate);
10769 if (PyErr_Occurred()) SWIG_fail;
10770 }
10771 Py_INCREF(Py_None); resultobj = Py_None;
10772 return resultobj;
10773 fail:
10774 return NULL;
10775 }
10776
10777
10778 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10779 PyObject *resultobj;
10780 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10781 bool result;
10782 PyObject * obj0 = 0 ;
10783 char *kwnames[] = {
10784 (char *) "self", NULL
10785 };
10786
10787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10789 if (SWIG_arg_fail(1)) SWIG_fail;
10790 {
10791 PyThreadState* __tstate = wxPyBeginAllowThreads();
10792 result = (bool)(arg1)->IsRedirected();
10793
10794 wxPyEndAllowThreads(__tstate);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 {
10798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10799 }
10800 return resultobj;
10801 fail:
10802 return NULL;
10803 }
10804
10805
10806 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10807 PyObject *resultobj;
10808 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10809 PyObject * obj0 = 0 ;
10810 char *kwnames[] = {
10811 (char *) "self", NULL
10812 };
10813
10814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10816 if (SWIG_arg_fail(1)) SWIG_fail;
10817 {
10818 PyThreadState* __tstate = wxPyBeginAllowThreads();
10819 (arg1)->Detach();
10820
10821 wxPyEndAllowThreads(__tstate);
10822 if (PyErr_Occurred()) SWIG_fail;
10823 }
10824 Py_INCREF(Py_None); resultobj = Py_None;
10825 return resultobj;
10826 fail:
10827 return NULL;
10828 }
10829
10830
10831 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10832 PyObject *resultobj;
10833 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10834 wxInputStream *result;
10835 PyObject * obj0 = 0 ;
10836 char *kwnames[] = {
10837 (char *) "self", NULL
10838 };
10839
10840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10842 if (SWIG_arg_fail(1)) SWIG_fail;
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (wxInputStream *)(arg1)->GetInputStream();
10846
10847 wxPyEndAllowThreads(__tstate);
10848 if (PyErr_Occurred()) SWIG_fail;
10849 }
10850 {
10851 wxPyInputStream * _ptr = NULL;
10852
10853 if (result) {
10854 _ptr = new wxPyInputStream(result);
10855 }
10856 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10857 }
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj;
10866 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10867 wxInputStream *result;
10868 PyObject * obj0 = 0 ;
10869 char *kwnames[] = {
10870 (char *) "self", NULL
10871 };
10872
10873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10875 if (SWIG_arg_fail(1)) SWIG_fail;
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 result = (wxInputStream *)(arg1)->GetErrorStream();
10879
10880 wxPyEndAllowThreads(__tstate);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 {
10884 wxPyInputStream * _ptr = NULL;
10885
10886 if (result) {
10887 _ptr = new wxPyInputStream(result);
10888 }
10889 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10890 }
10891 return resultobj;
10892 fail:
10893 return NULL;
10894 }
10895
10896
10897 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10898 PyObject *resultobj;
10899 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10900 wxOutputStream *result;
10901 PyObject * obj0 = 0 ;
10902 char *kwnames[] = {
10903 (char *) "self", NULL
10904 };
10905
10906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10908 if (SWIG_arg_fail(1)) SWIG_fail;
10909 {
10910 PyThreadState* __tstate = wxPyBeginAllowThreads();
10911 result = (wxOutputStream *)(arg1)->GetOutputStream();
10912
10913 wxPyEndAllowThreads(__tstate);
10914 if (PyErr_Occurred()) SWIG_fail;
10915 }
10916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10917 return resultobj;
10918 fail:
10919 return NULL;
10920 }
10921
10922
10923 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10924 PyObject *resultobj;
10925 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10926 PyObject * obj0 = 0 ;
10927 char *kwnames[] = {
10928 (char *) "self", NULL
10929 };
10930
10931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10933 if (SWIG_arg_fail(1)) SWIG_fail;
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 (arg1)->CloseOutput();
10937
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 Py_INCREF(Py_None); resultobj = Py_None;
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj;
10950 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10951 bool result;
10952 PyObject * obj0 = 0 ;
10953 char *kwnames[] = {
10954 (char *) "self", NULL
10955 };
10956
10957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10959 if (SWIG_arg_fail(1)) SWIG_fail;
10960 {
10961 PyThreadState* __tstate = wxPyBeginAllowThreads();
10962 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
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_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10977 PyObject *resultobj;
10978 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10979 bool result;
10980 PyObject * obj0 = 0 ;
10981 char *kwnames[] = {
10982 (char *) "self", NULL
10983 };
10984
10985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
10986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10987 if (SWIG_arg_fail(1)) SWIG_fail;
10988 {
10989 PyThreadState* __tstate = wxPyBeginAllowThreads();
10990 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
10991
10992 wxPyEndAllowThreads(__tstate);
10993 if (PyErr_Occurred()) SWIG_fail;
10994 }
10995 {
10996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10997 }
10998 return resultobj;
10999 fail:
11000 return NULL;
11001 }
11002
11003
11004 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11005 PyObject *resultobj;
11006 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11007 bool result;
11008 PyObject * obj0 = 0 ;
11009 char *kwnames[] = {
11010 (char *) "self", NULL
11011 };
11012
11013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11015 if (SWIG_arg_fail(1)) SWIG_fail;
11016 {
11017 PyThreadState* __tstate = wxPyBeginAllowThreads();
11018 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11019
11020 wxPyEndAllowThreads(__tstate);
11021 if (PyErr_Occurred()) SWIG_fail;
11022 }
11023 {
11024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11025 }
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11033 PyObject *obj;
11034 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11035 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11036 Py_INCREF(obj);
11037 return Py_BuildValue((char *)"");
11038 }
11039 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11040 PyObject *resultobj;
11041 int arg1 = (int) 0 ;
11042 int arg2 = (int) 0 ;
11043 int arg3 = (int) 0 ;
11044 wxProcessEvent *result;
11045 PyObject * obj0 = 0 ;
11046 PyObject * obj1 = 0 ;
11047 PyObject * obj2 = 0 ;
11048 char *kwnames[] = {
11049 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11050 };
11051
11052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11053 if (obj0) {
11054 {
11055 arg1 = (int)(SWIG_As_int(obj0));
11056 if (SWIG_arg_fail(1)) SWIG_fail;
11057 }
11058 }
11059 if (obj1) {
11060 {
11061 arg2 = (int)(SWIG_As_int(obj1));
11062 if (SWIG_arg_fail(2)) SWIG_fail;
11063 }
11064 }
11065 if (obj2) {
11066 {
11067 arg3 = (int)(SWIG_As_int(obj2));
11068 if (SWIG_arg_fail(3)) SWIG_fail;
11069 }
11070 }
11071 {
11072 PyThreadState* __tstate = wxPyBeginAllowThreads();
11073 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11074
11075 wxPyEndAllowThreads(__tstate);
11076 if (PyErr_Occurred()) SWIG_fail;
11077 }
11078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11079 return resultobj;
11080 fail:
11081 return NULL;
11082 }
11083
11084
11085 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11086 PyObject *resultobj;
11087 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11088 int result;
11089 PyObject * obj0 = 0 ;
11090 char *kwnames[] = {
11091 (char *) "self", NULL
11092 };
11093
11094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11096 if (SWIG_arg_fail(1)) SWIG_fail;
11097 {
11098 PyThreadState* __tstate = wxPyBeginAllowThreads();
11099 result = (int)(arg1)->GetPid();
11100
11101 wxPyEndAllowThreads(__tstate);
11102 if (PyErr_Occurred()) SWIG_fail;
11103 }
11104 {
11105 resultobj = SWIG_From_int((int)(result));
11106 }
11107 return resultobj;
11108 fail:
11109 return NULL;
11110 }
11111
11112
11113 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11114 PyObject *resultobj;
11115 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11116 int result;
11117 PyObject * obj0 = 0 ;
11118 char *kwnames[] = {
11119 (char *) "self", NULL
11120 };
11121
11122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11124 if (SWIG_arg_fail(1)) SWIG_fail;
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 result = (int)(arg1)->GetExitCode();
11128
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 {
11133 resultobj = SWIG_From_int((int)(result));
11134 }
11135 return resultobj;
11136 fail:
11137 return NULL;
11138 }
11139
11140
11141 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11142 PyObject *resultobj;
11143 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11144 int arg2 ;
11145 PyObject * obj0 = 0 ;
11146 PyObject * obj1 = 0 ;
11147 char *kwnames[] = {
11148 (char *) "self",(char *) "m_pid", NULL
11149 };
11150
11151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11153 if (SWIG_arg_fail(1)) SWIG_fail;
11154 {
11155 arg2 = (int)(SWIG_As_int(obj1));
11156 if (SWIG_arg_fail(2)) SWIG_fail;
11157 }
11158 if (arg1) (arg1)->m_pid = arg2;
11159
11160 Py_INCREF(Py_None); resultobj = Py_None;
11161 return resultobj;
11162 fail:
11163 return NULL;
11164 }
11165
11166
11167 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11168 PyObject *resultobj;
11169 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11170 int result;
11171 PyObject * obj0 = 0 ;
11172 char *kwnames[] = {
11173 (char *) "self", NULL
11174 };
11175
11176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11178 if (SWIG_arg_fail(1)) SWIG_fail;
11179 result = (int) ((arg1)->m_pid);
11180
11181 {
11182 resultobj = SWIG_From_int((int)(result));
11183 }
11184 return resultobj;
11185 fail:
11186 return NULL;
11187 }
11188
11189
11190 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11191 PyObject *resultobj;
11192 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11193 int arg2 ;
11194 PyObject * obj0 = 0 ;
11195 PyObject * obj1 = 0 ;
11196 char *kwnames[] = {
11197 (char *) "self",(char *) "m_exitcode", NULL
11198 };
11199
11200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11202 if (SWIG_arg_fail(1)) SWIG_fail;
11203 {
11204 arg2 = (int)(SWIG_As_int(obj1));
11205 if (SWIG_arg_fail(2)) SWIG_fail;
11206 }
11207 if (arg1) (arg1)->m_exitcode = arg2;
11208
11209 Py_INCREF(Py_None); resultobj = Py_None;
11210 return resultobj;
11211 fail:
11212 return NULL;
11213 }
11214
11215
11216 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11217 PyObject *resultobj;
11218 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11219 int result;
11220 PyObject * obj0 = 0 ;
11221 char *kwnames[] = {
11222 (char *) "self", NULL
11223 };
11224
11225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11227 if (SWIG_arg_fail(1)) SWIG_fail;
11228 result = (int) ((arg1)->m_exitcode);
11229
11230 {
11231 resultobj = SWIG_From_int((int)(result));
11232 }
11233 return resultobj;
11234 fail:
11235 return NULL;
11236 }
11237
11238
11239 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11240 PyObject *obj;
11241 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11242 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11243 Py_INCREF(obj);
11244 return Py_BuildValue((char *)"");
11245 }
11246 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11247 PyObject *resultobj;
11248 wxString *arg1 = 0 ;
11249 int arg2 = (int) wxEXEC_ASYNC ;
11250 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11251 long result;
11252 bool temp1 = false ;
11253 PyObject * obj0 = 0 ;
11254 PyObject * obj1 = 0 ;
11255 PyObject * obj2 = 0 ;
11256 char *kwnames[] = {
11257 (char *) "command",(char *) "flags",(char *) "process", NULL
11258 };
11259
11260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11261 {
11262 arg1 = wxString_in_helper(obj0);
11263 if (arg1 == NULL) SWIG_fail;
11264 temp1 = true;
11265 }
11266 if (obj1) {
11267 {
11268 arg2 = (int)(SWIG_As_int(obj1));
11269 if (SWIG_arg_fail(2)) SWIG_fail;
11270 }
11271 }
11272 if (obj2) {
11273 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11274 if (SWIG_arg_fail(3)) SWIG_fail;
11275 }
11276 {
11277 if (!wxPyCheckForApp()) SWIG_fail;
11278 PyThreadState* __tstate = wxPyBeginAllowThreads();
11279 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11280
11281 wxPyEndAllowThreads(__tstate);
11282 if (PyErr_Occurred()) SWIG_fail;
11283 }
11284 {
11285 resultobj = SWIG_From_long((long)(result));
11286 }
11287 {
11288 if (temp1)
11289 delete arg1;
11290 }
11291 return resultobj;
11292 fail:
11293 {
11294 if (temp1)
11295 delete arg1;
11296 }
11297 return NULL;
11298 }
11299
11300
11301 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11302 PyObject *resultobj;
11303 long arg1 ;
11304 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11305 wxKillError *arg3 = (wxKillError *) 0 ;
11306 int arg4 = (int) wxKILL_NOCHILDREN ;
11307 int result;
11308 wxKillError temp3 ;
11309 PyObject * obj0 = 0 ;
11310 PyObject * obj1 = 0 ;
11311 PyObject * obj2 = 0 ;
11312 char *kwnames[] = {
11313 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11314 };
11315
11316 {
11317 arg3 = &temp3;
11318 }
11319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11320 {
11321 arg1 = (long)(SWIG_As_long(obj0));
11322 if (SWIG_arg_fail(1)) SWIG_fail;
11323 }
11324 if (obj1) {
11325 {
11326 arg2 = (wxSignal)(SWIG_As_int(obj1));
11327 if (SWIG_arg_fail(2)) SWIG_fail;
11328 }
11329 }
11330 if (obj2) {
11331 {
11332 arg4 = (int)(SWIG_As_int(obj2));
11333 if (SWIG_arg_fail(4)) SWIG_fail;
11334 }
11335 }
11336 {
11337 PyThreadState* __tstate = wxPyBeginAllowThreads();
11338 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11339
11340 wxPyEndAllowThreads(__tstate);
11341 if (PyErr_Occurred()) SWIG_fail;
11342 }
11343 {
11344 resultobj = SWIG_From_int((int)(result));
11345 }
11346 {
11347 PyObject* o;
11348 o = PyInt_FromLong((long) (*arg3));
11349 resultobj = t_output_helper(resultobj, o);
11350 }
11351 return resultobj;
11352 fail:
11353 return NULL;
11354 }
11355
11356
11357 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11358 PyObject *resultobj;
11359 int arg1 = (int) wxJOYSTICK1 ;
11360 wxJoystick *result;
11361 PyObject * obj0 = 0 ;
11362 char *kwnames[] = {
11363 (char *) "joystick", NULL
11364 };
11365
11366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11367 if (obj0) {
11368 {
11369 arg1 = (int)(SWIG_As_int(obj0));
11370 if (SWIG_arg_fail(1)) SWIG_fail;
11371 }
11372 }
11373 {
11374 if (!wxPyCheckForApp()) SWIG_fail;
11375 PyThreadState* __tstate = wxPyBeginAllowThreads();
11376 result = (wxJoystick *)new wxJoystick(arg1);
11377
11378 wxPyEndAllowThreads(__tstate);
11379 if (PyErr_Occurred()) SWIG_fail;
11380 }
11381 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11382 return resultobj;
11383 fail:
11384 return NULL;
11385 }
11386
11387
11388 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11389 PyObject *resultobj;
11390 wxJoystick *arg1 = (wxJoystick *) 0 ;
11391 PyObject * obj0 = 0 ;
11392 char *kwnames[] = {
11393 (char *) "self", NULL
11394 };
11395
11396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11398 if (SWIG_arg_fail(1)) SWIG_fail;
11399 {
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 delete arg1;
11402
11403 wxPyEndAllowThreads(__tstate);
11404 if (PyErr_Occurred()) SWIG_fail;
11405 }
11406 Py_INCREF(Py_None); resultobj = Py_None;
11407 return resultobj;
11408 fail:
11409 return NULL;
11410 }
11411
11412
11413 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11414 PyObject *resultobj;
11415 wxJoystick *arg1 = (wxJoystick *) 0 ;
11416 wxPoint result;
11417 PyObject * obj0 = 0 ;
11418 char *kwnames[] = {
11419 (char *) "self", NULL
11420 };
11421
11422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11424 if (SWIG_arg_fail(1)) SWIG_fail;
11425 {
11426 PyThreadState* __tstate = wxPyBeginAllowThreads();
11427 result = (arg1)->GetPosition();
11428
11429 wxPyEndAllowThreads(__tstate);
11430 if (PyErr_Occurred()) SWIG_fail;
11431 }
11432 {
11433 wxPoint * resultptr;
11434 resultptr = new wxPoint((wxPoint &)(result));
11435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11436 }
11437 return resultobj;
11438 fail:
11439 return NULL;
11440 }
11441
11442
11443 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11444 PyObject *resultobj;
11445 wxJoystick *arg1 = (wxJoystick *) 0 ;
11446 int result;
11447 PyObject * obj0 = 0 ;
11448 char *kwnames[] = {
11449 (char *) "self", NULL
11450 };
11451
11452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11454 if (SWIG_arg_fail(1)) SWIG_fail;
11455 {
11456 PyThreadState* __tstate = wxPyBeginAllowThreads();
11457 result = (int)(arg1)->GetZPosition();
11458
11459 wxPyEndAllowThreads(__tstate);
11460 if (PyErr_Occurred()) SWIG_fail;
11461 }
11462 {
11463 resultobj = SWIG_From_int((int)(result));
11464 }
11465 return resultobj;
11466 fail:
11467 return NULL;
11468 }
11469
11470
11471 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj;
11473 wxJoystick *arg1 = (wxJoystick *) 0 ;
11474 int result;
11475 PyObject * obj0 = 0 ;
11476 char *kwnames[] = {
11477 (char *) "self", NULL
11478 };
11479
11480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11482 if (SWIG_arg_fail(1)) SWIG_fail;
11483 {
11484 PyThreadState* __tstate = wxPyBeginAllowThreads();
11485 result = (int)(arg1)->GetButtonState();
11486
11487 wxPyEndAllowThreads(__tstate);
11488 if (PyErr_Occurred()) SWIG_fail;
11489 }
11490 {
11491 resultobj = SWIG_From_int((int)(result));
11492 }
11493 return resultobj;
11494 fail:
11495 return NULL;
11496 }
11497
11498
11499 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj;
11501 wxJoystick *arg1 = (wxJoystick *) 0 ;
11502 int result;
11503 PyObject * obj0 = 0 ;
11504 char *kwnames[] = {
11505 (char *) "self", NULL
11506 };
11507
11508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11510 if (SWIG_arg_fail(1)) SWIG_fail;
11511 {
11512 PyThreadState* __tstate = wxPyBeginAllowThreads();
11513 result = (int)(arg1)->GetPOVPosition();
11514
11515 wxPyEndAllowThreads(__tstate);
11516 if (PyErr_Occurred()) SWIG_fail;
11517 }
11518 {
11519 resultobj = SWIG_From_int((int)(result));
11520 }
11521 return resultobj;
11522 fail:
11523 return NULL;
11524 }
11525
11526
11527 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11528 PyObject *resultobj;
11529 wxJoystick *arg1 = (wxJoystick *) 0 ;
11530 int result;
11531 PyObject * obj0 = 0 ;
11532 char *kwnames[] = {
11533 (char *) "self", NULL
11534 };
11535
11536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11538 if (SWIG_arg_fail(1)) SWIG_fail;
11539 {
11540 PyThreadState* __tstate = wxPyBeginAllowThreads();
11541 result = (int)(arg1)->GetPOVCTSPosition();
11542
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 {
11547 resultobj = SWIG_From_int((int)(result));
11548 }
11549 return resultobj;
11550 fail:
11551 return NULL;
11552 }
11553
11554
11555 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11556 PyObject *resultobj;
11557 wxJoystick *arg1 = (wxJoystick *) 0 ;
11558 int result;
11559 PyObject * obj0 = 0 ;
11560 char *kwnames[] = {
11561 (char *) "self", NULL
11562 };
11563
11564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11566 if (SWIG_arg_fail(1)) SWIG_fail;
11567 {
11568 PyThreadState* __tstate = wxPyBeginAllowThreads();
11569 result = (int)(arg1)->GetRudderPosition();
11570
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 {
11575 resultobj = SWIG_From_int((int)(result));
11576 }
11577 return resultobj;
11578 fail:
11579 return NULL;
11580 }
11581
11582
11583 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11584 PyObject *resultobj;
11585 wxJoystick *arg1 = (wxJoystick *) 0 ;
11586 int result;
11587 PyObject * obj0 = 0 ;
11588 char *kwnames[] = {
11589 (char *) "self", NULL
11590 };
11591
11592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11594 if (SWIG_arg_fail(1)) SWIG_fail;
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 result = (int)(arg1)->GetUPosition();
11598
11599 wxPyEndAllowThreads(__tstate);
11600 if (PyErr_Occurred()) SWIG_fail;
11601 }
11602 {
11603 resultobj = SWIG_From_int((int)(result));
11604 }
11605 return resultobj;
11606 fail:
11607 return NULL;
11608 }
11609
11610
11611 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11612 PyObject *resultobj;
11613 wxJoystick *arg1 = (wxJoystick *) 0 ;
11614 int result;
11615 PyObject * obj0 = 0 ;
11616 char *kwnames[] = {
11617 (char *) "self", NULL
11618 };
11619
11620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11622 if (SWIG_arg_fail(1)) SWIG_fail;
11623 {
11624 PyThreadState* __tstate = wxPyBeginAllowThreads();
11625 result = (int)(arg1)->GetVPosition();
11626
11627 wxPyEndAllowThreads(__tstate);
11628 if (PyErr_Occurred()) SWIG_fail;
11629 }
11630 {
11631 resultobj = SWIG_From_int((int)(result));
11632 }
11633 return resultobj;
11634 fail:
11635 return NULL;
11636 }
11637
11638
11639 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11640 PyObject *resultobj;
11641 wxJoystick *arg1 = (wxJoystick *) 0 ;
11642 int result;
11643 PyObject * obj0 = 0 ;
11644 char *kwnames[] = {
11645 (char *) "self", NULL
11646 };
11647
11648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11650 if (SWIG_arg_fail(1)) SWIG_fail;
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 result = (int)(arg1)->GetMovementThreshold();
11654
11655 wxPyEndAllowThreads(__tstate);
11656 if (PyErr_Occurred()) SWIG_fail;
11657 }
11658 {
11659 resultobj = SWIG_From_int((int)(result));
11660 }
11661 return resultobj;
11662 fail:
11663 return NULL;
11664 }
11665
11666
11667 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11668 PyObject *resultobj;
11669 wxJoystick *arg1 = (wxJoystick *) 0 ;
11670 int arg2 ;
11671 PyObject * obj0 = 0 ;
11672 PyObject * obj1 = 0 ;
11673 char *kwnames[] = {
11674 (char *) "self",(char *) "threshold", NULL
11675 };
11676
11677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11679 if (SWIG_arg_fail(1)) SWIG_fail;
11680 {
11681 arg2 = (int)(SWIG_As_int(obj1));
11682 if (SWIG_arg_fail(2)) SWIG_fail;
11683 }
11684 {
11685 PyThreadState* __tstate = wxPyBeginAllowThreads();
11686 (arg1)->SetMovementThreshold(arg2);
11687
11688 wxPyEndAllowThreads(__tstate);
11689 if (PyErr_Occurred()) SWIG_fail;
11690 }
11691 Py_INCREF(Py_None); resultobj = Py_None;
11692 return resultobj;
11693 fail:
11694 return NULL;
11695 }
11696
11697
11698 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11699 PyObject *resultobj;
11700 wxJoystick *arg1 = (wxJoystick *) 0 ;
11701 bool result;
11702 PyObject * obj0 = 0 ;
11703 char *kwnames[] = {
11704 (char *) "self", NULL
11705 };
11706
11707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11709 if (SWIG_arg_fail(1)) SWIG_fail;
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 result = (bool)(arg1)->IsOk();
11713
11714 wxPyEndAllowThreads(__tstate);
11715 if (PyErr_Occurred()) SWIG_fail;
11716 }
11717 {
11718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11719 }
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11727 PyObject *resultobj;
11728 wxJoystick *arg1 = (wxJoystick *) 0 ;
11729 int result;
11730 PyObject * obj0 = 0 ;
11731 char *kwnames[] = {
11732 (char *) "self", NULL
11733 };
11734
11735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11737 if (SWIG_arg_fail(1)) SWIG_fail;
11738 {
11739 PyThreadState* __tstate = wxPyBeginAllowThreads();
11740 result = (int)(arg1)->GetNumberJoysticks();
11741
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 {
11746 resultobj = SWIG_From_int((int)(result));
11747 }
11748 return resultobj;
11749 fail:
11750 return NULL;
11751 }
11752
11753
11754 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11755 PyObject *resultobj;
11756 wxJoystick *arg1 = (wxJoystick *) 0 ;
11757 int result;
11758 PyObject * obj0 = 0 ;
11759 char *kwnames[] = {
11760 (char *) "self", NULL
11761 };
11762
11763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11765 if (SWIG_arg_fail(1)) SWIG_fail;
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (int)(arg1)->GetManufacturerId();
11769
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 resultobj = SWIG_From_int((int)(result));
11775 }
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11783 PyObject *resultobj;
11784 wxJoystick *arg1 = (wxJoystick *) 0 ;
11785 int result;
11786 PyObject * obj0 = 0 ;
11787 char *kwnames[] = {
11788 (char *) "self", NULL
11789 };
11790
11791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11793 if (SWIG_arg_fail(1)) SWIG_fail;
11794 {
11795 PyThreadState* __tstate = wxPyBeginAllowThreads();
11796 result = (int)(arg1)->GetProductId();
11797
11798 wxPyEndAllowThreads(__tstate);
11799 if (PyErr_Occurred()) SWIG_fail;
11800 }
11801 {
11802 resultobj = SWIG_From_int((int)(result));
11803 }
11804 return resultobj;
11805 fail:
11806 return NULL;
11807 }
11808
11809
11810 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11811 PyObject *resultobj;
11812 wxJoystick *arg1 = (wxJoystick *) 0 ;
11813 wxString result;
11814 PyObject * obj0 = 0 ;
11815 char *kwnames[] = {
11816 (char *) "self", NULL
11817 };
11818
11819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11821 if (SWIG_arg_fail(1)) SWIG_fail;
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (arg1)->GetProductName();
11825
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 {
11830 #if wxUSE_UNICODE
11831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11832 #else
11833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11834 #endif
11835 }
11836 return resultobj;
11837 fail:
11838 return NULL;
11839 }
11840
11841
11842 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11843 PyObject *resultobj;
11844 wxJoystick *arg1 = (wxJoystick *) 0 ;
11845 int result;
11846 PyObject * obj0 = 0 ;
11847 char *kwnames[] = {
11848 (char *) "self", NULL
11849 };
11850
11851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11853 if (SWIG_arg_fail(1)) SWIG_fail;
11854 {
11855 PyThreadState* __tstate = wxPyBeginAllowThreads();
11856 result = (int)(arg1)->GetXMin();
11857
11858 wxPyEndAllowThreads(__tstate);
11859 if (PyErr_Occurred()) SWIG_fail;
11860 }
11861 {
11862 resultobj = SWIG_From_int((int)(result));
11863 }
11864 return resultobj;
11865 fail:
11866 return NULL;
11867 }
11868
11869
11870 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11871 PyObject *resultobj;
11872 wxJoystick *arg1 = (wxJoystick *) 0 ;
11873 int result;
11874 PyObject * obj0 = 0 ;
11875 char *kwnames[] = {
11876 (char *) "self", NULL
11877 };
11878
11879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11881 if (SWIG_arg_fail(1)) SWIG_fail;
11882 {
11883 PyThreadState* __tstate = wxPyBeginAllowThreads();
11884 result = (int)(arg1)->GetYMin();
11885
11886 wxPyEndAllowThreads(__tstate);
11887 if (PyErr_Occurred()) SWIG_fail;
11888 }
11889 {
11890 resultobj = SWIG_From_int((int)(result));
11891 }
11892 return resultobj;
11893 fail:
11894 return NULL;
11895 }
11896
11897
11898 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11899 PyObject *resultobj;
11900 wxJoystick *arg1 = (wxJoystick *) 0 ;
11901 int result;
11902 PyObject * obj0 = 0 ;
11903 char *kwnames[] = {
11904 (char *) "self", NULL
11905 };
11906
11907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11909 if (SWIG_arg_fail(1)) SWIG_fail;
11910 {
11911 PyThreadState* __tstate = wxPyBeginAllowThreads();
11912 result = (int)(arg1)->GetZMin();
11913
11914 wxPyEndAllowThreads(__tstate);
11915 if (PyErr_Occurred()) SWIG_fail;
11916 }
11917 {
11918 resultobj = SWIG_From_int((int)(result));
11919 }
11920 return resultobj;
11921 fail:
11922 return NULL;
11923 }
11924
11925
11926 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11927 PyObject *resultobj;
11928 wxJoystick *arg1 = (wxJoystick *) 0 ;
11929 int result;
11930 PyObject * obj0 = 0 ;
11931 char *kwnames[] = {
11932 (char *) "self", NULL
11933 };
11934
11935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
11936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11937 if (SWIG_arg_fail(1)) SWIG_fail;
11938 {
11939 PyThreadState* __tstate = wxPyBeginAllowThreads();
11940 result = (int)(arg1)->GetXMax();
11941
11942 wxPyEndAllowThreads(__tstate);
11943 if (PyErr_Occurred()) SWIG_fail;
11944 }
11945 {
11946 resultobj = SWIG_From_int((int)(result));
11947 }
11948 return resultobj;
11949 fail:
11950 return NULL;
11951 }
11952
11953
11954 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj;
11956 wxJoystick *arg1 = (wxJoystick *) 0 ;
11957 int result;
11958 PyObject * obj0 = 0 ;
11959 char *kwnames[] = {
11960 (char *) "self", NULL
11961 };
11962
11963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11965 if (SWIG_arg_fail(1)) SWIG_fail;
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 result = (int)(arg1)->GetYMax();
11969
11970 wxPyEndAllowThreads(__tstate);
11971 if (PyErr_Occurred()) SWIG_fail;
11972 }
11973 {
11974 resultobj = SWIG_From_int((int)(result));
11975 }
11976 return resultobj;
11977 fail:
11978 return NULL;
11979 }
11980
11981
11982 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
11983 PyObject *resultobj;
11984 wxJoystick *arg1 = (wxJoystick *) 0 ;
11985 int result;
11986 PyObject * obj0 = 0 ;
11987 char *kwnames[] = {
11988 (char *) "self", NULL
11989 };
11990
11991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
11992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11993 if (SWIG_arg_fail(1)) SWIG_fail;
11994 {
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 result = (int)(arg1)->GetZMax();
11997
11998 wxPyEndAllowThreads(__tstate);
11999 if (PyErr_Occurred()) SWIG_fail;
12000 }
12001 {
12002 resultobj = SWIG_From_int((int)(result));
12003 }
12004 return resultobj;
12005 fail:
12006 return NULL;
12007 }
12008
12009
12010 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12011 PyObject *resultobj;
12012 wxJoystick *arg1 = (wxJoystick *) 0 ;
12013 int result;
12014 PyObject * obj0 = 0 ;
12015 char *kwnames[] = {
12016 (char *) "self", NULL
12017 };
12018
12019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12021 if (SWIG_arg_fail(1)) SWIG_fail;
12022 {
12023 PyThreadState* __tstate = wxPyBeginAllowThreads();
12024 result = (int)(arg1)->GetNumberButtons();
12025
12026 wxPyEndAllowThreads(__tstate);
12027 if (PyErr_Occurred()) SWIG_fail;
12028 }
12029 {
12030 resultobj = SWIG_From_int((int)(result));
12031 }
12032 return resultobj;
12033 fail:
12034 return NULL;
12035 }
12036
12037
12038 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12039 PyObject *resultobj;
12040 wxJoystick *arg1 = (wxJoystick *) 0 ;
12041 int result;
12042 PyObject * obj0 = 0 ;
12043 char *kwnames[] = {
12044 (char *) "self", NULL
12045 };
12046
12047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12049 if (SWIG_arg_fail(1)) SWIG_fail;
12050 {
12051 PyThreadState* __tstate = wxPyBeginAllowThreads();
12052 result = (int)(arg1)->GetNumberAxes();
12053
12054 wxPyEndAllowThreads(__tstate);
12055 if (PyErr_Occurred()) SWIG_fail;
12056 }
12057 {
12058 resultobj = SWIG_From_int((int)(result));
12059 }
12060 return resultobj;
12061 fail:
12062 return NULL;
12063 }
12064
12065
12066 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12067 PyObject *resultobj;
12068 wxJoystick *arg1 = (wxJoystick *) 0 ;
12069 int result;
12070 PyObject * obj0 = 0 ;
12071 char *kwnames[] = {
12072 (char *) "self", NULL
12073 };
12074
12075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12077 if (SWIG_arg_fail(1)) SWIG_fail;
12078 {
12079 PyThreadState* __tstate = wxPyBeginAllowThreads();
12080 result = (int)(arg1)->GetMaxButtons();
12081
12082 wxPyEndAllowThreads(__tstate);
12083 if (PyErr_Occurred()) SWIG_fail;
12084 }
12085 {
12086 resultobj = SWIG_From_int((int)(result));
12087 }
12088 return resultobj;
12089 fail:
12090 return NULL;
12091 }
12092
12093
12094 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12095 PyObject *resultobj;
12096 wxJoystick *arg1 = (wxJoystick *) 0 ;
12097 int result;
12098 PyObject * obj0 = 0 ;
12099 char *kwnames[] = {
12100 (char *) "self", NULL
12101 };
12102
12103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12105 if (SWIG_arg_fail(1)) SWIG_fail;
12106 {
12107 PyThreadState* __tstate = wxPyBeginAllowThreads();
12108 result = (int)(arg1)->GetMaxAxes();
12109
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 {
12114 resultobj = SWIG_From_int((int)(result));
12115 }
12116 return resultobj;
12117 fail:
12118 return NULL;
12119 }
12120
12121
12122 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12123 PyObject *resultobj;
12124 wxJoystick *arg1 = (wxJoystick *) 0 ;
12125 int result;
12126 PyObject * obj0 = 0 ;
12127 char *kwnames[] = {
12128 (char *) "self", NULL
12129 };
12130
12131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12133 if (SWIG_arg_fail(1)) SWIG_fail;
12134 {
12135 PyThreadState* __tstate = wxPyBeginAllowThreads();
12136 result = (int)(arg1)->GetPollingMin();
12137
12138 wxPyEndAllowThreads(__tstate);
12139 if (PyErr_Occurred()) SWIG_fail;
12140 }
12141 {
12142 resultobj = SWIG_From_int((int)(result));
12143 }
12144 return resultobj;
12145 fail:
12146 return NULL;
12147 }
12148
12149
12150 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12151 PyObject *resultobj;
12152 wxJoystick *arg1 = (wxJoystick *) 0 ;
12153 int result;
12154 PyObject * obj0 = 0 ;
12155 char *kwnames[] = {
12156 (char *) "self", NULL
12157 };
12158
12159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12161 if (SWIG_arg_fail(1)) SWIG_fail;
12162 {
12163 PyThreadState* __tstate = wxPyBeginAllowThreads();
12164 result = (int)(arg1)->GetPollingMax();
12165
12166 wxPyEndAllowThreads(__tstate);
12167 if (PyErr_Occurred()) SWIG_fail;
12168 }
12169 {
12170 resultobj = SWIG_From_int((int)(result));
12171 }
12172 return resultobj;
12173 fail:
12174 return NULL;
12175 }
12176
12177
12178 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj;
12180 wxJoystick *arg1 = (wxJoystick *) 0 ;
12181 int result;
12182 PyObject * obj0 = 0 ;
12183 char *kwnames[] = {
12184 (char *) "self", NULL
12185 };
12186
12187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12189 if (SWIG_arg_fail(1)) SWIG_fail;
12190 {
12191 PyThreadState* __tstate = wxPyBeginAllowThreads();
12192 result = (int)(arg1)->GetRudderMin();
12193
12194 wxPyEndAllowThreads(__tstate);
12195 if (PyErr_Occurred()) SWIG_fail;
12196 }
12197 {
12198 resultobj = SWIG_From_int((int)(result));
12199 }
12200 return resultobj;
12201 fail:
12202 return NULL;
12203 }
12204
12205
12206 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12207 PyObject *resultobj;
12208 wxJoystick *arg1 = (wxJoystick *) 0 ;
12209 int result;
12210 PyObject * obj0 = 0 ;
12211 char *kwnames[] = {
12212 (char *) "self", NULL
12213 };
12214
12215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12217 if (SWIG_arg_fail(1)) SWIG_fail;
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 result = (int)(arg1)->GetRudderMax();
12221
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 {
12226 resultobj = SWIG_From_int((int)(result));
12227 }
12228 return resultobj;
12229 fail:
12230 return NULL;
12231 }
12232
12233
12234 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12235 PyObject *resultobj;
12236 wxJoystick *arg1 = (wxJoystick *) 0 ;
12237 int result;
12238 PyObject * obj0 = 0 ;
12239 char *kwnames[] = {
12240 (char *) "self", NULL
12241 };
12242
12243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12245 if (SWIG_arg_fail(1)) SWIG_fail;
12246 {
12247 PyThreadState* __tstate = wxPyBeginAllowThreads();
12248 result = (int)(arg1)->GetUMin();
12249
12250 wxPyEndAllowThreads(__tstate);
12251 if (PyErr_Occurred()) SWIG_fail;
12252 }
12253 {
12254 resultobj = SWIG_From_int((int)(result));
12255 }
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12263 PyObject *resultobj;
12264 wxJoystick *arg1 = (wxJoystick *) 0 ;
12265 int result;
12266 PyObject * obj0 = 0 ;
12267 char *kwnames[] = {
12268 (char *) "self", NULL
12269 };
12270
12271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12273 if (SWIG_arg_fail(1)) SWIG_fail;
12274 {
12275 PyThreadState* __tstate = wxPyBeginAllowThreads();
12276 result = (int)(arg1)->GetUMax();
12277
12278 wxPyEndAllowThreads(__tstate);
12279 if (PyErr_Occurred()) SWIG_fail;
12280 }
12281 {
12282 resultobj = SWIG_From_int((int)(result));
12283 }
12284 return resultobj;
12285 fail:
12286 return NULL;
12287 }
12288
12289
12290 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12291 PyObject *resultobj;
12292 wxJoystick *arg1 = (wxJoystick *) 0 ;
12293 int result;
12294 PyObject * obj0 = 0 ;
12295 char *kwnames[] = {
12296 (char *) "self", NULL
12297 };
12298
12299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12301 if (SWIG_arg_fail(1)) SWIG_fail;
12302 {
12303 PyThreadState* __tstate = wxPyBeginAllowThreads();
12304 result = (int)(arg1)->GetVMin();
12305
12306 wxPyEndAllowThreads(__tstate);
12307 if (PyErr_Occurred()) SWIG_fail;
12308 }
12309 {
12310 resultobj = SWIG_From_int((int)(result));
12311 }
12312 return resultobj;
12313 fail:
12314 return NULL;
12315 }
12316
12317
12318 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12319 PyObject *resultobj;
12320 wxJoystick *arg1 = (wxJoystick *) 0 ;
12321 int result;
12322 PyObject * obj0 = 0 ;
12323 char *kwnames[] = {
12324 (char *) "self", NULL
12325 };
12326
12327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12329 if (SWIG_arg_fail(1)) SWIG_fail;
12330 {
12331 PyThreadState* __tstate = wxPyBeginAllowThreads();
12332 result = (int)(arg1)->GetVMax();
12333
12334 wxPyEndAllowThreads(__tstate);
12335 if (PyErr_Occurred()) SWIG_fail;
12336 }
12337 {
12338 resultobj = SWIG_From_int((int)(result));
12339 }
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12347 PyObject *resultobj;
12348 wxJoystick *arg1 = (wxJoystick *) 0 ;
12349 bool result;
12350 PyObject * obj0 = 0 ;
12351 char *kwnames[] = {
12352 (char *) "self", NULL
12353 };
12354
12355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12357 if (SWIG_arg_fail(1)) SWIG_fail;
12358 {
12359 PyThreadState* __tstate = wxPyBeginAllowThreads();
12360 result = (bool)(arg1)->HasRudder();
12361
12362 wxPyEndAllowThreads(__tstate);
12363 if (PyErr_Occurred()) SWIG_fail;
12364 }
12365 {
12366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12367 }
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12375 PyObject *resultobj;
12376 wxJoystick *arg1 = (wxJoystick *) 0 ;
12377 bool result;
12378 PyObject * obj0 = 0 ;
12379 char *kwnames[] = {
12380 (char *) "self", NULL
12381 };
12382
12383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12385 if (SWIG_arg_fail(1)) SWIG_fail;
12386 {
12387 PyThreadState* __tstate = wxPyBeginAllowThreads();
12388 result = (bool)(arg1)->HasZ();
12389
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 {
12394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12395 }
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12403 PyObject *resultobj;
12404 wxJoystick *arg1 = (wxJoystick *) 0 ;
12405 bool result;
12406 PyObject * obj0 = 0 ;
12407 char *kwnames[] = {
12408 (char *) "self", NULL
12409 };
12410
12411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12413 if (SWIG_arg_fail(1)) SWIG_fail;
12414 {
12415 PyThreadState* __tstate = wxPyBeginAllowThreads();
12416 result = (bool)(arg1)->HasU();
12417
12418 wxPyEndAllowThreads(__tstate);
12419 if (PyErr_Occurred()) SWIG_fail;
12420 }
12421 {
12422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12423 }
12424 return resultobj;
12425 fail:
12426 return NULL;
12427 }
12428
12429
12430 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12431 PyObject *resultobj;
12432 wxJoystick *arg1 = (wxJoystick *) 0 ;
12433 bool result;
12434 PyObject * obj0 = 0 ;
12435 char *kwnames[] = {
12436 (char *) "self", NULL
12437 };
12438
12439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12441 if (SWIG_arg_fail(1)) SWIG_fail;
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 result = (bool)(arg1)->HasV();
12445
12446 wxPyEndAllowThreads(__tstate);
12447 if (PyErr_Occurred()) SWIG_fail;
12448 }
12449 {
12450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12451 }
12452 return resultobj;
12453 fail:
12454 return NULL;
12455 }
12456
12457
12458 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12459 PyObject *resultobj;
12460 wxJoystick *arg1 = (wxJoystick *) 0 ;
12461 bool result;
12462 PyObject * obj0 = 0 ;
12463 char *kwnames[] = {
12464 (char *) "self", NULL
12465 };
12466
12467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12469 if (SWIG_arg_fail(1)) SWIG_fail;
12470 {
12471 PyThreadState* __tstate = wxPyBeginAllowThreads();
12472 result = (bool)(arg1)->HasPOV();
12473
12474 wxPyEndAllowThreads(__tstate);
12475 if (PyErr_Occurred()) SWIG_fail;
12476 }
12477 {
12478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12479 }
12480 return resultobj;
12481 fail:
12482 return NULL;
12483 }
12484
12485
12486 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12487 PyObject *resultobj;
12488 wxJoystick *arg1 = (wxJoystick *) 0 ;
12489 bool result;
12490 PyObject * obj0 = 0 ;
12491 char *kwnames[] = {
12492 (char *) "self", NULL
12493 };
12494
12495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12497 if (SWIG_arg_fail(1)) SWIG_fail;
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 result = (bool)(arg1)->HasPOV4Dir();
12501
12502 wxPyEndAllowThreads(__tstate);
12503 if (PyErr_Occurred()) SWIG_fail;
12504 }
12505 {
12506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12507 }
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12515 PyObject *resultobj;
12516 wxJoystick *arg1 = (wxJoystick *) 0 ;
12517 bool result;
12518 PyObject * obj0 = 0 ;
12519 char *kwnames[] = {
12520 (char *) "self", NULL
12521 };
12522
12523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12525 if (SWIG_arg_fail(1)) SWIG_fail;
12526 {
12527 PyThreadState* __tstate = wxPyBeginAllowThreads();
12528 result = (bool)(arg1)->HasPOVCTS();
12529
12530 wxPyEndAllowThreads(__tstate);
12531 if (PyErr_Occurred()) SWIG_fail;
12532 }
12533 {
12534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12535 }
12536 return resultobj;
12537 fail:
12538 return NULL;
12539 }
12540
12541
12542 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12543 PyObject *resultobj;
12544 wxJoystick *arg1 = (wxJoystick *) 0 ;
12545 wxWindow *arg2 = (wxWindow *) 0 ;
12546 int arg3 = (int) 0 ;
12547 bool result;
12548 PyObject * obj0 = 0 ;
12549 PyObject * obj1 = 0 ;
12550 PyObject * obj2 = 0 ;
12551 char *kwnames[] = {
12552 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12553 };
12554
12555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12557 if (SWIG_arg_fail(1)) SWIG_fail;
12558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12559 if (SWIG_arg_fail(2)) SWIG_fail;
12560 if (obj2) {
12561 {
12562 arg3 = (int)(SWIG_As_int(obj2));
12563 if (SWIG_arg_fail(3)) SWIG_fail;
12564 }
12565 }
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 result = (bool)(arg1)->SetCapture(arg2,arg3);
12569
12570 wxPyEndAllowThreads(__tstate);
12571 if (PyErr_Occurred()) SWIG_fail;
12572 }
12573 {
12574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12575 }
12576 return resultobj;
12577 fail:
12578 return NULL;
12579 }
12580
12581
12582 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12583 PyObject *resultobj;
12584 wxJoystick *arg1 = (wxJoystick *) 0 ;
12585 bool result;
12586 PyObject * obj0 = 0 ;
12587 char *kwnames[] = {
12588 (char *) "self", NULL
12589 };
12590
12591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12593 if (SWIG_arg_fail(1)) SWIG_fail;
12594 {
12595 PyThreadState* __tstate = wxPyBeginAllowThreads();
12596 result = (bool)(arg1)->ReleaseCapture();
12597
12598 wxPyEndAllowThreads(__tstate);
12599 if (PyErr_Occurred()) SWIG_fail;
12600 }
12601 {
12602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12603 }
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12611 PyObject *obj;
12612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12613 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12614 Py_INCREF(obj);
12615 return Py_BuildValue((char *)"");
12616 }
12617 static PyObject *_wrap_JoystickEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
12618 PyObject *resultobj;
12619 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12620 wxPoint *arg2 = (wxPoint *) 0 ;
12621 PyObject * obj0 = 0 ;
12622 PyObject * obj1 = 0 ;
12623 char *kwnames[] = {
12624 (char *) "self",(char *) "m_pos", NULL
12625 };
12626
12627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
12628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12629 if (SWIG_arg_fail(1)) SWIG_fail;
12630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12631 if (SWIG_arg_fail(2)) SWIG_fail;
12632 if (arg1) (arg1)->m_pos = *arg2;
12633
12634 Py_INCREF(Py_None); resultobj = Py_None;
12635 return resultobj;
12636 fail:
12637 return NULL;
12638 }
12639
12640
12641 static PyObject *_wrap_JoystickEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
12642 PyObject *resultobj;
12643 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12644 wxPoint *result;
12645 PyObject * obj0 = 0 ;
12646 char *kwnames[] = {
12647 (char *) "self", NULL
12648 };
12649
12650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_pos_get",kwnames,&obj0)) goto fail;
12651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12652 if (SWIG_arg_fail(1)) SWIG_fail;
12653 result = (wxPoint *)& ((arg1)->m_pos);
12654
12655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 static PyObject *_wrap_JoystickEvent_m_zPosition_set(PyObject *, PyObject *args, PyObject *kwargs) {
12663 PyObject *resultobj;
12664 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12665 int arg2 ;
12666 PyObject * obj0 = 0 ;
12667 PyObject * obj1 = 0 ;
12668 char *kwnames[] = {
12669 (char *) "self",(char *) "m_zPosition", NULL
12670 };
12671
12672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_zPosition_set",kwnames,&obj0,&obj1)) goto fail;
12673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12674 if (SWIG_arg_fail(1)) SWIG_fail;
12675 {
12676 arg2 = (int)(SWIG_As_int(obj1));
12677 if (SWIG_arg_fail(2)) SWIG_fail;
12678 }
12679 if (arg1) (arg1)->m_zPosition = arg2;
12680
12681 Py_INCREF(Py_None); resultobj = Py_None;
12682 return resultobj;
12683 fail:
12684 return NULL;
12685 }
12686
12687
12688 static PyObject *_wrap_JoystickEvent_m_zPosition_get(PyObject *, PyObject *args, PyObject *kwargs) {
12689 PyObject *resultobj;
12690 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12691 int result;
12692 PyObject * obj0 = 0 ;
12693 char *kwnames[] = {
12694 (char *) "self", NULL
12695 };
12696
12697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_zPosition_get",kwnames,&obj0)) goto fail;
12698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12699 if (SWIG_arg_fail(1)) SWIG_fail;
12700 result = (int) ((arg1)->m_zPosition);
12701
12702 {
12703 resultobj = SWIG_From_int((int)(result));
12704 }
12705 return resultobj;
12706 fail:
12707 return NULL;
12708 }
12709
12710
12711 static PyObject *_wrap_JoystickEvent_m_buttonChange_set(PyObject *, PyObject *args, PyObject *kwargs) {
12712 PyObject *resultobj;
12713 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12714 int arg2 ;
12715 PyObject * obj0 = 0 ;
12716 PyObject * obj1 = 0 ;
12717 char *kwnames[] = {
12718 (char *) "self",(char *) "m_buttonChange", NULL
12719 };
12720
12721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonChange_set",kwnames,&obj0,&obj1)) goto fail;
12722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12723 if (SWIG_arg_fail(1)) SWIG_fail;
12724 {
12725 arg2 = (int)(SWIG_As_int(obj1));
12726 if (SWIG_arg_fail(2)) SWIG_fail;
12727 }
12728 if (arg1) (arg1)->m_buttonChange = arg2;
12729
12730 Py_INCREF(Py_None); resultobj = Py_None;
12731 return resultobj;
12732 fail:
12733 return NULL;
12734 }
12735
12736
12737 static PyObject *_wrap_JoystickEvent_m_buttonChange_get(PyObject *, PyObject *args, PyObject *kwargs) {
12738 PyObject *resultobj;
12739 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12740 int result;
12741 PyObject * obj0 = 0 ;
12742 char *kwnames[] = {
12743 (char *) "self", NULL
12744 };
12745
12746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonChange_get",kwnames,&obj0)) goto fail;
12747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12748 if (SWIG_arg_fail(1)) SWIG_fail;
12749 result = (int) ((arg1)->m_buttonChange);
12750
12751 {
12752 resultobj = SWIG_From_int((int)(result));
12753 }
12754 return resultobj;
12755 fail:
12756 return NULL;
12757 }
12758
12759
12760 static PyObject *_wrap_JoystickEvent_m_buttonState_set(PyObject *, PyObject *args, PyObject *kwargs) {
12761 PyObject *resultobj;
12762 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12763 int arg2 ;
12764 PyObject * obj0 = 0 ;
12765 PyObject * obj1 = 0 ;
12766 char *kwnames[] = {
12767 (char *) "self",(char *) "m_buttonState", NULL
12768 };
12769
12770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonState_set",kwnames,&obj0,&obj1)) goto fail;
12771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12772 if (SWIG_arg_fail(1)) SWIG_fail;
12773 {
12774 arg2 = (int)(SWIG_As_int(obj1));
12775 if (SWIG_arg_fail(2)) SWIG_fail;
12776 }
12777 if (arg1) (arg1)->m_buttonState = arg2;
12778
12779 Py_INCREF(Py_None); resultobj = Py_None;
12780 return resultobj;
12781 fail:
12782 return NULL;
12783 }
12784
12785
12786 static PyObject *_wrap_JoystickEvent_m_buttonState_get(PyObject *, PyObject *args, PyObject *kwargs) {
12787 PyObject *resultobj;
12788 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12789 int result;
12790 PyObject * obj0 = 0 ;
12791 char *kwnames[] = {
12792 (char *) "self", NULL
12793 };
12794
12795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonState_get",kwnames,&obj0)) goto fail;
12796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12797 if (SWIG_arg_fail(1)) SWIG_fail;
12798 result = (int) ((arg1)->m_buttonState);
12799
12800 {
12801 resultobj = SWIG_From_int((int)(result));
12802 }
12803 return resultobj;
12804 fail:
12805 return NULL;
12806 }
12807
12808
12809 static PyObject *_wrap_JoystickEvent_m_joyStick_set(PyObject *, PyObject *args, PyObject *kwargs) {
12810 PyObject *resultobj;
12811 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12812 int arg2 ;
12813 PyObject * obj0 = 0 ;
12814 PyObject * obj1 = 0 ;
12815 char *kwnames[] = {
12816 (char *) "self",(char *) "m_joyStick", NULL
12817 };
12818
12819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_joyStick_set",kwnames,&obj0,&obj1)) goto fail;
12820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12821 if (SWIG_arg_fail(1)) SWIG_fail;
12822 {
12823 arg2 = (int)(SWIG_As_int(obj1));
12824 if (SWIG_arg_fail(2)) SWIG_fail;
12825 }
12826 if (arg1) (arg1)->m_joyStick = arg2;
12827
12828 Py_INCREF(Py_None); resultobj = Py_None;
12829 return resultobj;
12830 fail:
12831 return NULL;
12832 }
12833
12834
12835 static PyObject *_wrap_JoystickEvent_m_joyStick_get(PyObject *, PyObject *args, PyObject *kwargs) {
12836 PyObject *resultobj;
12837 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12838 int result;
12839 PyObject * obj0 = 0 ;
12840 char *kwnames[] = {
12841 (char *) "self", NULL
12842 };
12843
12844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_joyStick_get",kwnames,&obj0)) goto fail;
12845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12846 if (SWIG_arg_fail(1)) SWIG_fail;
12847 result = (int) ((arg1)->m_joyStick);
12848
12849 {
12850 resultobj = SWIG_From_int((int)(result));
12851 }
12852 return resultobj;
12853 fail:
12854 return NULL;
12855 }
12856
12857
12858 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12859 PyObject *resultobj;
12860 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12861 int arg2 = (int) 0 ;
12862 int arg3 = (int) wxJOYSTICK1 ;
12863 int arg4 = (int) 0 ;
12864 wxJoystickEvent *result;
12865 PyObject * obj0 = 0 ;
12866 PyObject * obj1 = 0 ;
12867 PyObject * obj2 = 0 ;
12868 PyObject * obj3 = 0 ;
12869 char *kwnames[] = {
12870 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12871 };
12872
12873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12874 if (obj0) {
12875 {
12876 arg1 = (wxEventType)(SWIG_As_int(obj0));
12877 if (SWIG_arg_fail(1)) SWIG_fail;
12878 }
12879 }
12880 if (obj1) {
12881 {
12882 arg2 = (int)(SWIG_As_int(obj1));
12883 if (SWIG_arg_fail(2)) SWIG_fail;
12884 }
12885 }
12886 if (obj2) {
12887 {
12888 arg3 = (int)(SWIG_As_int(obj2));
12889 if (SWIG_arg_fail(3)) SWIG_fail;
12890 }
12891 }
12892 if (obj3) {
12893 {
12894 arg4 = (int)(SWIG_As_int(obj3));
12895 if (SWIG_arg_fail(4)) SWIG_fail;
12896 }
12897 }
12898 {
12899 PyThreadState* __tstate = wxPyBeginAllowThreads();
12900 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12901
12902 wxPyEndAllowThreads(__tstate);
12903 if (PyErr_Occurred()) SWIG_fail;
12904 }
12905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12906 return resultobj;
12907 fail:
12908 return NULL;
12909 }
12910
12911
12912 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12913 PyObject *resultobj;
12914 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12915 wxPoint result;
12916 PyObject * obj0 = 0 ;
12917 char *kwnames[] = {
12918 (char *) "self", NULL
12919 };
12920
12921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12923 if (SWIG_arg_fail(1)) SWIG_fail;
12924 {
12925 PyThreadState* __tstate = wxPyBeginAllowThreads();
12926 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12927
12928 wxPyEndAllowThreads(__tstate);
12929 if (PyErr_Occurred()) SWIG_fail;
12930 }
12931 {
12932 wxPoint * resultptr;
12933 resultptr = new wxPoint((wxPoint &)(result));
12934 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12935 }
12936 return resultobj;
12937 fail:
12938 return NULL;
12939 }
12940
12941
12942 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12943 PyObject *resultobj;
12944 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12945 int result;
12946 PyObject * obj0 = 0 ;
12947 char *kwnames[] = {
12948 (char *) "self", NULL
12949 };
12950
12951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12953 if (SWIG_arg_fail(1)) SWIG_fail;
12954 {
12955 PyThreadState* __tstate = wxPyBeginAllowThreads();
12956 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12957
12958 wxPyEndAllowThreads(__tstate);
12959 if (PyErr_Occurred()) SWIG_fail;
12960 }
12961 {
12962 resultobj = SWIG_From_int((int)(result));
12963 }
12964 return resultobj;
12965 fail:
12966 return NULL;
12967 }
12968
12969
12970 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12971 PyObject *resultobj;
12972 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12973 int result;
12974 PyObject * obj0 = 0 ;
12975 char *kwnames[] = {
12976 (char *) "self", NULL
12977 };
12978
12979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12981 if (SWIG_arg_fail(1)) SWIG_fail;
12982 {
12983 PyThreadState* __tstate = wxPyBeginAllowThreads();
12984 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12985
12986 wxPyEndAllowThreads(__tstate);
12987 if (PyErr_Occurred()) SWIG_fail;
12988 }
12989 {
12990 resultobj = SWIG_From_int((int)(result));
12991 }
12992 return resultobj;
12993 fail:
12994 return NULL;
12995 }
12996
12997
12998 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12999 PyObject *resultobj;
13000 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13001 int result;
13002 PyObject * obj0 = 0 ;
13003 char *kwnames[] = {
13004 (char *) "self", NULL
13005 };
13006
13007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13009 if (SWIG_arg_fail(1)) SWIG_fail;
13010 {
13011 PyThreadState* __tstate = wxPyBeginAllowThreads();
13012 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13013
13014 wxPyEndAllowThreads(__tstate);
13015 if (PyErr_Occurred()) SWIG_fail;
13016 }
13017 {
13018 resultobj = SWIG_From_int((int)(result));
13019 }
13020 return resultobj;
13021 fail:
13022 return NULL;
13023 }
13024
13025
13026 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13027 PyObject *resultobj;
13028 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13029 int result;
13030 PyObject * obj0 = 0 ;
13031 char *kwnames[] = {
13032 (char *) "self", NULL
13033 };
13034
13035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13037 if (SWIG_arg_fail(1)) SWIG_fail;
13038 {
13039 PyThreadState* __tstate = wxPyBeginAllowThreads();
13040 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13041
13042 wxPyEndAllowThreads(__tstate);
13043 if (PyErr_Occurred()) SWIG_fail;
13044 }
13045 {
13046 resultobj = SWIG_From_int((int)(result));
13047 }
13048 return resultobj;
13049 fail:
13050 return NULL;
13051 }
13052
13053
13054 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj;
13056 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13057 int arg2 ;
13058 PyObject * obj0 = 0 ;
13059 PyObject * obj1 = 0 ;
13060 char *kwnames[] = {
13061 (char *) "self",(char *) "stick", NULL
13062 };
13063
13064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13066 if (SWIG_arg_fail(1)) SWIG_fail;
13067 {
13068 arg2 = (int)(SWIG_As_int(obj1));
13069 if (SWIG_arg_fail(2)) SWIG_fail;
13070 }
13071 {
13072 PyThreadState* __tstate = wxPyBeginAllowThreads();
13073 (arg1)->SetJoystick(arg2);
13074
13075 wxPyEndAllowThreads(__tstate);
13076 if (PyErr_Occurred()) SWIG_fail;
13077 }
13078 Py_INCREF(Py_None); resultobj = Py_None;
13079 return resultobj;
13080 fail:
13081 return NULL;
13082 }
13083
13084
13085 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13086 PyObject *resultobj;
13087 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13088 int arg2 ;
13089 PyObject * obj0 = 0 ;
13090 PyObject * obj1 = 0 ;
13091 char *kwnames[] = {
13092 (char *) "self",(char *) "state", NULL
13093 };
13094
13095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13097 if (SWIG_arg_fail(1)) SWIG_fail;
13098 {
13099 arg2 = (int)(SWIG_As_int(obj1));
13100 if (SWIG_arg_fail(2)) SWIG_fail;
13101 }
13102 {
13103 PyThreadState* __tstate = wxPyBeginAllowThreads();
13104 (arg1)->SetButtonState(arg2);
13105
13106 wxPyEndAllowThreads(__tstate);
13107 if (PyErr_Occurred()) SWIG_fail;
13108 }
13109 Py_INCREF(Py_None); resultobj = Py_None;
13110 return resultobj;
13111 fail:
13112 return NULL;
13113 }
13114
13115
13116 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13117 PyObject *resultobj;
13118 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13119 int arg2 ;
13120 PyObject * obj0 = 0 ;
13121 PyObject * obj1 = 0 ;
13122 char *kwnames[] = {
13123 (char *) "self",(char *) "change", NULL
13124 };
13125
13126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13128 if (SWIG_arg_fail(1)) SWIG_fail;
13129 {
13130 arg2 = (int)(SWIG_As_int(obj1));
13131 if (SWIG_arg_fail(2)) SWIG_fail;
13132 }
13133 {
13134 PyThreadState* __tstate = wxPyBeginAllowThreads();
13135 (arg1)->SetButtonChange(arg2);
13136
13137 wxPyEndAllowThreads(__tstate);
13138 if (PyErr_Occurred()) SWIG_fail;
13139 }
13140 Py_INCREF(Py_None); resultobj = Py_None;
13141 return resultobj;
13142 fail:
13143 return NULL;
13144 }
13145
13146
13147 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13148 PyObject *resultobj;
13149 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13150 wxPoint *arg2 = 0 ;
13151 wxPoint temp2 ;
13152 PyObject * obj0 = 0 ;
13153 PyObject * obj1 = 0 ;
13154 char *kwnames[] = {
13155 (char *) "self",(char *) "pos", NULL
13156 };
13157
13158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13160 if (SWIG_arg_fail(1)) SWIG_fail;
13161 {
13162 arg2 = &temp2;
13163 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13164 }
13165 {
13166 PyThreadState* __tstate = wxPyBeginAllowThreads();
13167 (arg1)->SetPosition((wxPoint const &)*arg2);
13168
13169 wxPyEndAllowThreads(__tstate);
13170 if (PyErr_Occurred()) SWIG_fail;
13171 }
13172 Py_INCREF(Py_None); resultobj = Py_None;
13173 return resultobj;
13174 fail:
13175 return NULL;
13176 }
13177
13178
13179 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13180 PyObject *resultobj;
13181 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13182 int arg2 ;
13183 PyObject * obj0 = 0 ;
13184 PyObject * obj1 = 0 ;
13185 char *kwnames[] = {
13186 (char *) "self",(char *) "zPos", NULL
13187 };
13188
13189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13191 if (SWIG_arg_fail(1)) SWIG_fail;
13192 {
13193 arg2 = (int)(SWIG_As_int(obj1));
13194 if (SWIG_arg_fail(2)) SWIG_fail;
13195 }
13196 {
13197 PyThreadState* __tstate = wxPyBeginAllowThreads();
13198 (arg1)->SetZPosition(arg2);
13199
13200 wxPyEndAllowThreads(__tstate);
13201 if (PyErr_Occurred()) SWIG_fail;
13202 }
13203 Py_INCREF(Py_None); resultobj = Py_None;
13204 return resultobj;
13205 fail:
13206 return NULL;
13207 }
13208
13209
13210 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13211 PyObject *resultobj;
13212 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13213 bool result;
13214 PyObject * obj0 = 0 ;
13215 char *kwnames[] = {
13216 (char *) "self", NULL
13217 };
13218
13219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13221 if (SWIG_arg_fail(1)) SWIG_fail;
13222 {
13223 PyThreadState* __tstate = wxPyBeginAllowThreads();
13224 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13225
13226 wxPyEndAllowThreads(__tstate);
13227 if (PyErr_Occurred()) SWIG_fail;
13228 }
13229 {
13230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13231 }
13232 return resultobj;
13233 fail:
13234 return NULL;
13235 }
13236
13237
13238 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13239 PyObject *resultobj;
13240 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13241 bool result;
13242 PyObject * obj0 = 0 ;
13243 char *kwnames[] = {
13244 (char *) "self", NULL
13245 };
13246
13247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13249 if (SWIG_arg_fail(1)) SWIG_fail;
13250 {
13251 PyThreadState* __tstate = wxPyBeginAllowThreads();
13252 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13253
13254 wxPyEndAllowThreads(__tstate);
13255 if (PyErr_Occurred()) SWIG_fail;
13256 }
13257 {
13258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13259 }
13260 return resultobj;
13261 fail:
13262 return NULL;
13263 }
13264
13265
13266 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj;
13268 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13269 bool result;
13270 PyObject * obj0 = 0 ;
13271 char *kwnames[] = {
13272 (char *) "self", NULL
13273 };
13274
13275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13277 if (SWIG_arg_fail(1)) SWIG_fail;
13278 {
13279 PyThreadState* __tstate = wxPyBeginAllowThreads();
13280 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13281
13282 wxPyEndAllowThreads(__tstate);
13283 if (PyErr_Occurred()) SWIG_fail;
13284 }
13285 {
13286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13287 }
13288 return resultobj;
13289 fail:
13290 return NULL;
13291 }
13292
13293
13294 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13295 PyObject *resultobj;
13296 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13297 int arg2 = (int) wxJOY_BUTTON_ANY ;
13298 bool result;
13299 PyObject * obj0 = 0 ;
13300 PyObject * obj1 = 0 ;
13301 char *kwnames[] = {
13302 (char *) "self",(char *) "but", NULL
13303 };
13304
13305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13307 if (SWIG_arg_fail(1)) SWIG_fail;
13308 if (obj1) {
13309 {
13310 arg2 = (int)(SWIG_As_int(obj1));
13311 if (SWIG_arg_fail(2)) SWIG_fail;
13312 }
13313 }
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13317
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 {
13322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13323 }
13324 return resultobj;
13325 fail:
13326 return NULL;
13327 }
13328
13329
13330 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13331 PyObject *resultobj;
13332 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13333 int arg2 = (int) wxJOY_BUTTON_ANY ;
13334 bool result;
13335 PyObject * obj0 = 0 ;
13336 PyObject * obj1 = 0 ;
13337 char *kwnames[] = {
13338 (char *) "self",(char *) "but", NULL
13339 };
13340
13341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13343 if (SWIG_arg_fail(1)) SWIG_fail;
13344 if (obj1) {
13345 {
13346 arg2 = (int)(SWIG_As_int(obj1));
13347 if (SWIG_arg_fail(2)) SWIG_fail;
13348 }
13349 }
13350 {
13351 PyThreadState* __tstate = wxPyBeginAllowThreads();
13352 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13353
13354 wxPyEndAllowThreads(__tstate);
13355 if (PyErr_Occurred()) SWIG_fail;
13356 }
13357 {
13358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13359 }
13360 return resultobj;
13361 fail:
13362 return NULL;
13363 }
13364
13365
13366 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13367 PyObject *resultobj;
13368 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13369 int arg2 = (int) wxJOY_BUTTON_ANY ;
13370 bool result;
13371 PyObject * obj0 = 0 ;
13372 PyObject * obj1 = 0 ;
13373 char *kwnames[] = {
13374 (char *) "self",(char *) "but", NULL
13375 };
13376
13377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13379 if (SWIG_arg_fail(1)) SWIG_fail;
13380 if (obj1) {
13381 {
13382 arg2 = (int)(SWIG_As_int(obj1));
13383 if (SWIG_arg_fail(2)) SWIG_fail;
13384 }
13385 }
13386 {
13387 PyThreadState* __tstate = wxPyBeginAllowThreads();
13388 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13389
13390 wxPyEndAllowThreads(__tstate);
13391 if (PyErr_Occurred()) SWIG_fail;
13392 }
13393 {
13394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13395 }
13396 return resultobj;
13397 fail:
13398 return NULL;
13399 }
13400
13401
13402 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13403 PyObject *obj;
13404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13405 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13406 Py_INCREF(obj);
13407 return Py_BuildValue((char *)"");
13408 }
13409 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13410 PyObject *resultobj;
13411 wxString const &arg1_defvalue = wxPyEmptyString ;
13412 wxString *arg1 = (wxString *) &arg1_defvalue ;
13413 wxSound *result;
13414 bool temp1 = false ;
13415 PyObject * obj0 = 0 ;
13416 char *kwnames[] = {
13417 (char *) "fileName", NULL
13418 };
13419
13420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13421 if (obj0) {
13422 {
13423 arg1 = wxString_in_helper(obj0);
13424 if (arg1 == NULL) SWIG_fail;
13425 temp1 = true;
13426 }
13427 }
13428 {
13429 if (!wxPyCheckForApp()) SWIG_fail;
13430 PyThreadState* __tstate = wxPyBeginAllowThreads();
13431 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13432
13433 wxPyEndAllowThreads(__tstate);
13434 if (PyErr_Occurred()) SWIG_fail;
13435 }
13436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13437 {
13438 if (temp1)
13439 delete arg1;
13440 }
13441 return resultobj;
13442 fail:
13443 {
13444 if (temp1)
13445 delete arg1;
13446 }
13447 return NULL;
13448 }
13449
13450
13451 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13452 PyObject *resultobj;
13453 PyObject *arg1 = (PyObject *) 0 ;
13454 wxSound *result;
13455 PyObject * obj0 = 0 ;
13456 char *kwnames[] = {
13457 (char *) "data", NULL
13458 };
13459
13460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13461 arg1 = obj0;
13462 {
13463 if (!wxPyCheckForApp()) SWIG_fail;
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 result = (wxSound *)new_wxSound(arg1);
13466
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13471 return resultobj;
13472 fail:
13473 return NULL;
13474 }
13475
13476
13477 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13478 PyObject *resultobj;
13479 wxSound *arg1 = (wxSound *) 0 ;
13480 PyObject * obj0 = 0 ;
13481 char *kwnames[] = {
13482 (char *) "self", NULL
13483 };
13484
13485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13487 if (SWIG_arg_fail(1)) SWIG_fail;
13488 {
13489 PyThreadState* __tstate = wxPyBeginAllowThreads();
13490 delete arg1;
13491
13492 wxPyEndAllowThreads(__tstate);
13493 if (PyErr_Occurred()) SWIG_fail;
13494 }
13495 Py_INCREF(Py_None); resultobj = Py_None;
13496 return resultobj;
13497 fail:
13498 return NULL;
13499 }
13500
13501
13502 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13503 PyObject *resultobj;
13504 wxSound *arg1 = (wxSound *) 0 ;
13505 wxString *arg2 = 0 ;
13506 bool result;
13507 bool temp2 = false ;
13508 PyObject * obj0 = 0 ;
13509 PyObject * obj1 = 0 ;
13510 char *kwnames[] = {
13511 (char *) "self",(char *) "fileName", NULL
13512 };
13513
13514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13516 if (SWIG_arg_fail(1)) SWIG_fail;
13517 {
13518 arg2 = wxString_in_helper(obj1);
13519 if (arg2 == NULL) SWIG_fail;
13520 temp2 = true;
13521 }
13522 {
13523 PyThreadState* __tstate = wxPyBeginAllowThreads();
13524 result = (bool)(arg1)->Create((wxString const &)*arg2);
13525
13526 wxPyEndAllowThreads(__tstate);
13527 if (PyErr_Occurred()) SWIG_fail;
13528 }
13529 {
13530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13531 }
13532 {
13533 if (temp2)
13534 delete arg2;
13535 }
13536 return resultobj;
13537 fail:
13538 {
13539 if (temp2)
13540 delete arg2;
13541 }
13542 return NULL;
13543 }
13544
13545
13546 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13547 PyObject *resultobj;
13548 wxSound *arg1 = (wxSound *) 0 ;
13549 PyObject *arg2 = (PyObject *) 0 ;
13550 bool result;
13551 PyObject * obj0 = 0 ;
13552 PyObject * obj1 = 0 ;
13553 char *kwnames[] = {
13554 (char *) "self",(char *) "data", NULL
13555 };
13556
13557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13559 if (SWIG_arg_fail(1)) SWIG_fail;
13560 arg2 = obj1;
13561 {
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 result = (bool)wxSound_CreateFromData(arg1,arg2);
13564
13565 wxPyEndAllowThreads(__tstate);
13566 if (PyErr_Occurred()) SWIG_fail;
13567 }
13568 {
13569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13570 }
13571 return resultobj;
13572 fail:
13573 return NULL;
13574 }
13575
13576
13577 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj;
13579 wxSound *arg1 = (wxSound *) 0 ;
13580 bool result;
13581 PyObject * obj0 = 0 ;
13582 char *kwnames[] = {
13583 (char *) "self", NULL
13584 };
13585
13586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13588 if (SWIG_arg_fail(1)) SWIG_fail;
13589 {
13590 PyThreadState* __tstate = wxPyBeginAllowThreads();
13591 result = (bool)(arg1)->IsOk();
13592
13593 wxPyEndAllowThreads(__tstate);
13594 if (PyErr_Occurred()) SWIG_fail;
13595 }
13596 {
13597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13598 }
13599 return resultobj;
13600 fail:
13601 return NULL;
13602 }
13603
13604
13605 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13606 PyObject *resultobj;
13607 wxSound *arg1 = (wxSound *) 0 ;
13608 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13609 bool result;
13610 PyObject * obj0 = 0 ;
13611 PyObject * obj1 = 0 ;
13612 char *kwnames[] = {
13613 (char *) "self",(char *) "flags", NULL
13614 };
13615
13616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13618 if (SWIG_arg_fail(1)) SWIG_fail;
13619 if (obj1) {
13620 {
13621 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13622 if (SWIG_arg_fail(2)) SWIG_fail;
13623 }
13624 }
13625 {
13626 if (!wxPyCheckForApp()) SWIG_fail;
13627 PyThreadState* __tstate = wxPyBeginAllowThreads();
13628 result = (bool)((wxSound const *)arg1)->Play(arg2);
13629
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 {
13634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13635 }
13636 return resultobj;
13637 fail:
13638 return NULL;
13639 }
13640
13641
13642 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13643 PyObject *resultobj;
13644 wxString *arg1 = 0 ;
13645 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13646 bool result;
13647 bool temp1 = false ;
13648 PyObject * obj0 = 0 ;
13649 PyObject * obj1 = 0 ;
13650 char *kwnames[] = {
13651 (char *) "filename",(char *) "flags", NULL
13652 };
13653
13654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13655 {
13656 arg1 = wxString_in_helper(obj0);
13657 if (arg1 == NULL) SWIG_fail;
13658 temp1 = true;
13659 }
13660 if (obj1) {
13661 {
13662 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13663 if (SWIG_arg_fail(2)) SWIG_fail;
13664 }
13665 }
13666 {
13667 if (!wxPyCheckForApp()) SWIG_fail;
13668 PyThreadState* __tstate = wxPyBeginAllowThreads();
13669 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13670
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 {
13675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13676 }
13677 {
13678 if (temp1)
13679 delete arg1;
13680 }
13681 return resultobj;
13682 fail:
13683 {
13684 if (temp1)
13685 delete arg1;
13686 }
13687 return NULL;
13688 }
13689
13690
13691 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13692 PyObject *resultobj;
13693 char *kwnames[] = {
13694 NULL
13695 };
13696
13697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13698 {
13699 if (!wxPyCheckForApp()) SWIG_fail;
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 wxSound::Stop();
13702
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 Py_INCREF(Py_None); resultobj = Py_None;
13707 return resultobj;
13708 fail:
13709 return NULL;
13710 }
13711
13712
13713 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13714 PyObject *obj;
13715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13716 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13717 Py_INCREF(obj);
13718 return Py_BuildValue((char *)"");
13719 }
13720 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13721 PyObject *resultobj;
13722 wxString *arg1 = 0 ;
13723 wxString *arg2 = 0 ;
13724 wxString *arg3 = 0 ;
13725 wxString *arg4 = 0 ;
13726 wxFileTypeInfo *result;
13727 bool temp1 = false ;
13728 bool temp2 = false ;
13729 bool temp3 = false ;
13730 bool temp4 = false ;
13731 PyObject * obj0 = 0 ;
13732 PyObject * obj1 = 0 ;
13733 PyObject * obj2 = 0 ;
13734 PyObject * obj3 = 0 ;
13735 char *kwnames[] = {
13736 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13737 };
13738
13739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13740 {
13741 arg1 = wxString_in_helper(obj0);
13742 if (arg1 == NULL) SWIG_fail;
13743 temp1 = true;
13744 }
13745 {
13746 arg2 = wxString_in_helper(obj1);
13747 if (arg2 == NULL) SWIG_fail;
13748 temp2 = true;
13749 }
13750 {
13751 arg3 = wxString_in_helper(obj2);
13752 if (arg3 == NULL) SWIG_fail;
13753 temp3 = true;
13754 }
13755 {
13756 arg4 = wxString_in_helper(obj3);
13757 if (arg4 == NULL) SWIG_fail;
13758 temp4 = true;
13759 }
13760 {
13761 PyThreadState* __tstate = wxPyBeginAllowThreads();
13762 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13763
13764 wxPyEndAllowThreads(__tstate);
13765 if (PyErr_Occurred()) SWIG_fail;
13766 }
13767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13768 {
13769 if (temp1)
13770 delete arg1;
13771 }
13772 {
13773 if (temp2)
13774 delete arg2;
13775 }
13776 {
13777 if (temp3)
13778 delete arg3;
13779 }
13780 {
13781 if (temp4)
13782 delete arg4;
13783 }
13784 return resultobj;
13785 fail:
13786 {
13787 if (temp1)
13788 delete arg1;
13789 }
13790 {
13791 if (temp2)
13792 delete arg2;
13793 }
13794 {
13795 if (temp3)
13796 delete arg3;
13797 }
13798 {
13799 if (temp4)
13800 delete arg4;
13801 }
13802 return NULL;
13803 }
13804
13805
13806 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13807 PyObject *resultobj;
13808 wxArrayString *arg1 = 0 ;
13809 wxFileTypeInfo *result;
13810 bool temp1 = false ;
13811 PyObject * obj0 = 0 ;
13812 char *kwnames[] = {
13813 (char *) "sArray", NULL
13814 };
13815
13816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13817 {
13818 if (! PySequence_Check(obj0)) {
13819 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13820 SWIG_fail;
13821 }
13822 arg1 = new wxArrayString;
13823 temp1 = true;
13824 int i, len=PySequence_Length(obj0);
13825 for (i=0; i<len; i++) {
13826 PyObject* item = PySequence_GetItem(obj0, i);
13827 #if wxUSE_UNICODE
13828 PyObject* str = PyObject_Unicode(item);
13829 #else
13830 PyObject* str = PyObject_Str(item);
13831 #endif
13832 if (PyErr_Occurred()) SWIG_fail;
13833 arg1->Add(Py2wxString(str));
13834 Py_DECREF(item);
13835 Py_DECREF(str);
13836 }
13837 }
13838 {
13839 PyThreadState* __tstate = wxPyBeginAllowThreads();
13840 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13841
13842 wxPyEndAllowThreads(__tstate);
13843 if (PyErr_Occurred()) SWIG_fail;
13844 }
13845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13846 {
13847 if (temp1) delete arg1;
13848 }
13849 return resultobj;
13850 fail:
13851 {
13852 if (temp1) delete arg1;
13853 }
13854 return NULL;
13855 }
13856
13857
13858 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj;
13860 wxFileTypeInfo *result;
13861 char *kwnames[] = {
13862 NULL
13863 };
13864
13865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13866 {
13867 PyThreadState* __tstate = wxPyBeginAllowThreads();
13868 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13869
13870 wxPyEndAllowThreads(__tstate);
13871 if (PyErr_Occurred()) SWIG_fail;
13872 }
13873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13874 return resultobj;
13875 fail:
13876 return NULL;
13877 }
13878
13879
13880 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13881 PyObject *resultobj;
13882 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13883 bool result;
13884 PyObject * obj0 = 0 ;
13885 char *kwnames[] = {
13886 (char *) "self", NULL
13887 };
13888
13889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13891 if (SWIG_arg_fail(1)) SWIG_fail;
13892 {
13893 PyThreadState* __tstate = wxPyBeginAllowThreads();
13894 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13895
13896 wxPyEndAllowThreads(__tstate);
13897 if (PyErr_Occurred()) SWIG_fail;
13898 }
13899 {
13900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13901 }
13902 return resultobj;
13903 fail:
13904 return NULL;
13905 }
13906
13907
13908 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13909 PyObject *resultobj;
13910 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13911 wxString *arg2 = 0 ;
13912 int arg3 = (int) 0 ;
13913 bool temp2 = false ;
13914 PyObject * obj0 = 0 ;
13915 PyObject * obj1 = 0 ;
13916 PyObject * obj2 = 0 ;
13917 char *kwnames[] = {
13918 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13919 };
13920
13921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13923 if (SWIG_arg_fail(1)) SWIG_fail;
13924 {
13925 arg2 = wxString_in_helper(obj1);
13926 if (arg2 == NULL) SWIG_fail;
13927 temp2 = true;
13928 }
13929 if (obj2) {
13930 {
13931 arg3 = (int)(SWIG_As_int(obj2));
13932 if (SWIG_arg_fail(3)) SWIG_fail;
13933 }
13934 }
13935 {
13936 PyThreadState* __tstate = wxPyBeginAllowThreads();
13937 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13938
13939 wxPyEndAllowThreads(__tstate);
13940 if (PyErr_Occurred()) SWIG_fail;
13941 }
13942 Py_INCREF(Py_None); resultobj = Py_None;
13943 {
13944 if (temp2)
13945 delete arg2;
13946 }
13947 return resultobj;
13948 fail:
13949 {
13950 if (temp2)
13951 delete arg2;
13952 }
13953 return NULL;
13954 }
13955
13956
13957 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13958 PyObject *resultobj;
13959 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13960 wxString *arg2 = 0 ;
13961 bool temp2 = false ;
13962 PyObject * obj0 = 0 ;
13963 PyObject * obj1 = 0 ;
13964 char *kwnames[] = {
13965 (char *) "self",(char *) "shortDesc", NULL
13966 };
13967
13968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13970 if (SWIG_arg_fail(1)) SWIG_fail;
13971 {
13972 arg2 = wxString_in_helper(obj1);
13973 if (arg2 == NULL) SWIG_fail;
13974 temp2 = true;
13975 }
13976 {
13977 PyThreadState* __tstate = wxPyBeginAllowThreads();
13978 (arg1)->SetShortDesc((wxString const &)*arg2);
13979
13980 wxPyEndAllowThreads(__tstate);
13981 if (PyErr_Occurred()) SWIG_fail;
13982 }
13983 Py_INCREF(Py_None); resultobj = Py_None;
13984 {
13985 if (temp2)
13986 delete arg2;
13987 }
13988 return resultobj;
13989 fail:
13990 {
13991 if (temp2)
13992 delete arg2;
13993 }
13994 return NULL;
13995 }
13996
13997
13998 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13999 PyObject *resultobj;
14000 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14001 wxString *result;
14002 PyObject * obj0 = 0 ;
14003 char *kwnames[] = {
14004 (char *) "self", NULL
14005 };
14006
14007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14009 if (SWIG_arg_fail(1)) SWIG_fail;
14010 {
14011 PyThreadState* __tstate = wxPyBeginAllowThreads();
14012 {
14013 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14014 result = (wxString *) &_result_ref;
14015 }
14016
14017 wxPyEndAllowThreads(__tstate);
14018 if (PyErr_Occurred()) SWIG_fail;
14019 }
14020 {
14021 #if wxUSE_UNICODE
14022 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14023 #else
14024 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14025 #endif
14026 }
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14034 PyObject *resultobj;
14035 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14036 wxString *result;
14037 PyObject * obj0 = 0 ;
14038 char *kwnames[] = {
14039 (char *) "self", NULL
14040 };
14041
14042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14044 if (SWIG_arg_fail(1)) SWIG_fail;
14045 {
14046 PyThreadState* __tstate = wxPyBeginAllowThreads();
14047 {
14048 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14049 result = (wxString *) &_result_ref;
14050 }
14051
14052 wxPyEndAllowThreads(__tstate);
14053 if (PyErr_Occurred()) SWIG_fail;
14054 }
14055 {
14056 #if wxUSE_UNICODE
14057 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14058 #else
14059 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14060 #endif
14061 }
14062 return resultobj;
14063 fail:
14064 return NULL;
14065 }
14066
14067
14068 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14069 PyObject *resultobj;
14070 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14071 wxString *result;
14072 PyObject * obj0 = 0 ;
14073 char *kwnames[] = {
14074 (char *) "self", NULL
14075 };
14076
14077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14079 if (SWIG_arg_fail(1)) SWIG_fail;
14080 {
14081 PyThreadState* __tstate = wxPyBeginAllowThreads();
14082 {
14083 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14084 result = (wxString *) &_result_ref;
14085 }
14086
14087 wxPyEndAllowThreads(__tstate);
14088 if (PyErr_Occurred()) SWIG_fail;
14089 }
14090 {
14091 #if wxUSE_UNICODE
14092 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14093 #else
14094 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14095 #endif
14096 }
14097 return resultobj;
14098 fail:
14099 return NULL;
14100 }
14101
14102
14103 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14104 PyObject *resultobj;
14105 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14106 wxString *result;
14107 PyObject * obj0 = 0 ;
14108 char *kwnames[] = {
14109 (char *) "self", NULL
14110 };
14111
14112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14114 if (SWIG_arg_fail(1)) SWIG_fail;
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 {
14118 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14119 result = (wxString *) &_result_ref;
14120 }
14121
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 {
14126 #if wxUSE_UNICODE
14127 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14128 #else
14129 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14130 #endif
14131 }
14132 return resultobj;
14133 fail:
14134 return NULL;
14135 }
14136
14137
14138 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14139 PyObject *resultobj;
14140 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14141 wxString *result;
14142 PyObject * obj0 = 0 ;
14143 char *kwnames[] = {
14144 (char *) "self", NULL
14145 };
14146
14147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14149 if (SWIG_arg_fail(1)) SWIG_fail;
14150 {
14151 PyThreadState* __tstate = wxPyBeginAllowThreads();
14152 {
14153 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14154 result = (wxString *) &_result_ref;
14155 }
14156
14157 wxPyEndAllowThreads(__tstate);
14158 if (PyErr_Occurred()) SWIG_fail;
14159 }
14160 {
14161 #if wxUSE_UNICODE
14162 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14163 #else
14164 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14165 #endif
14166 }
14167 return resultobj;
14168 fail:
14169 return NULL;
14170 }
14171
14172
14173 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14174 PyObject *resultobj;
14175 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14176 wxArrayString *result;
14177 PyObject * obj0 = 0 ;
14178 char *kwnames[] = {
14179 (char *) "self", NULL
14180 };
14181
14182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14184 if (SWIG_arg_fail(1)) SWIG_fail;
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 {
14188 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14189 result = (wxArrayString *) &_result_ref;
14190 }
14191
14192 wxPyEndAllowThreads(__tstate);
14193 if (PyErr_Occurred()) SWIG_fail;
14194 }
14195 {
14196 resultobj = wxArrayString2PyList_helper(*result);
14197 }
14198 return resultobj;
14199 fail:
14200 return NULL;
14201 }
14202
14203
14204 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14205 PyObject *resultobj;
14206 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14207 int result;
14208 PyObject * obj0 = 0 ;
14209 char *kwnames[] = {
14210 (char *) "self", NULL
14211 };
14212
14213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14215 if (SWIG_arg_fail(1)) SWIG_fail;
14216 {
14217 PyThreadState* __tstate = wxPyBeginAllowThreads();
14218 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14219
14220 wxPyEndAllowThreads(__tstate);
14221 if (PyErr_Occurred()) SWIG_fail;
14222 }
14223 {
14224 resultobj = SWIG_From_int((int)(result));
14225 }
14226 return resultobj;
14227 fail:
14228 return NULL;
14229 }
14230
14231
14232 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14233 PyObject *resultobj;
14234 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14235 wxString *result;
14236 PyObject * obj0 = 0 ;
14237 char *kwnames[] = {
14238 (char *) "self", NULL
14239 };
14240
14241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14243 if (SWIG_arg_fail(1)) SWIG_fail;
14244 {
14245 PyThreadState* __tstate = wxPyBeginAllowThreads();
14246 {
14247 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14248 result = (wxString *) &_result_ref;
14249 }
14250
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 {
14255 #if wxUSE_UNICODE
14256 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14257 #else
14258 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14259 #endif
14260 }
14261 return resultobj;
14262 fail:
14263 return NULL;
14264 }
14265
14266
14267 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14268 PyObject *resultobj;
14269 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14270 int result;
14271 PyObject * obj0 = 0 ;
14272 char *kwnames[] = {
14273 (char *) "self", NULL
14274 };
14275
14276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14278 if (SWIG_arg_fail(1)) SWIG_fail;
14279 {
14280 PyThreadState* __tstate = wxPyBeginAllowThreads();
14281 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14282
14283 wxPyEndAllowThreads(__tstate);
14284 if (PyErr_Occurred()) SWIG_fail;
14285 }
14286 {
14287 resultobj = SWIG_From_int((int)(result));
14288 }
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14296 PyObject *obj;
14297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14298 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14299 Py_INCREF(obj);
14300 return Py_BuildValue((char *)"");
14301 }
14302 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14303 PyObject *resultobj;
14304 wxFileTypeInfo *arg1 = 0 ;
14305 wxFileType *result;
14306 PyObject * obj0 = 0 ;
14307 char *kwnames[] = {
14308 (char *) "ftInfo", NULL
14309 };
14310
14311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14312 {
14313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14314 if (SWIG_arg_fail(1)) SWIG_fail;
14315 if (arg1 == NULL) {
14316 SWIG_null_ref("wxFileTypeInfo");
14317 }
14318 if (SWIG_arg_fail(1)) SWIG_fail;
14319 }
14320 {
14321 PyThreadState* __tstate = wxPyBeginAllowThreads();
14322 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14323
14324 wxPyEndAllowThreads(__tstate);
14325 if (PyErr_Occurred()) SWIG_fail;
14326 }
14327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14328 return resultobj;
14329 fail:
14330 return NULL;
14331 }
14332
14333
14334 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14335 PyObject *resultobj;
14336 wxFileType *arg1 = (wxFileType *) 0 ;
14337 PyObject * obj0 = 0 ;
14338 char *kwnames[] = {
14339 (char *) "self", NULL
14340 };
14341
14342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14344 if (SWIG_arg_fail(1)) SWIG_fail;
14345 {
14346 PyThreadState* __tstate = wxPyBeginAllowThreads();
14347 delete arg1;
14348
14349 wxPyEndAllowThreads(__tstate);
14350 if (PyErr_Occurred()) SWIG_fail;
14351 }
14352 Py_INCREF(Py_None); resultobj = Py_None;
14353 return resultobj;
14354 fail:
14355 return NULL;
14356 }
14357
14358
14359 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14360 PyObject *resultobj;
14361 wxFileType *arg1 = (wxFileType *) 0 ;
14362 PyObject *result;
14363 PyObject * obj0 = 0 ;
14364 char *kwnames[] = {
14365 (char *) "self", NULL
14366 };
14367
14368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14370 if (SWIG_arg_fail(1)) SWIG_fail;
14371 {
14372 PyThreadState* __tstate = wxPyBeginAllowThreads();
14373 result = (PyObject *)wxFileType_GetMimeType(arg1);
14374
14375 wxPyEndAllowThreads(__tstate);
14376 if (PyErr_Occurred()) SWIG_fail;
14377 }
14378 resultobj = result;
14379 return resultobj;
14380 fail:
14381 return NULL;
14382 }
14383
14384
14385 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14386 PyObject *resultobj;
14387 wxFileType *arg1 = (wxFileType *) 0 ;
14388 PyObject *result;
14389 PyObject * obj0 = 0 ;
14390 char *kwnames[] = {
14391 (char *) "self", NULL
14392 };
14393
14394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14396 if (SWIG_arg_fail(1)) SWIG_fail;
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14400
14401 wxPyEndAllowThreads(__tstate);
14402 if (PyErr_Occurred()) SWIG_fail;
14403 }
14404 resultobj = result;
14405 return resultobj;
14406 fail:
14407 return NULL;
14408 }
14409
14410
14411 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14412 PyObject *resultobj;
14413 wxFileType *arg1 = (wxFileType *) 0 ;
14414 PyObject *result;
14415 PyObject * obj0 = 0 ;
14416 char *kwnames[] = {
14417 (char *) "self", NULL
14418 };
14419
14420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14422 if (SWIG_arg_fail(1)) SWIG_fail;
14423 {
14424 PyThreadState* __tstate = wxPyBeginAllowThreads();
14425 result = (PyObject *)wxFileType_GetExtensions(arg1);
14426
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 resultobj = result;
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14438 PyObject *resultobj;
14439 wxFileType *arg1 = (wxFileType *) 0 ;
14440 wxIcon *result;
14441 PyObject * obj0 = 0 ;
14442 char *kwnames[] = {
14443 (char *) "self", NULL
14444 };
14445
14446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14448 if (SWIG_arg_fail(1)) SWIG_fail;
14449 {
14450 PyThreadState* __tstate = wxPyBeginAllowThreads();
14451 result = (wxIcon *)wxFileType_GetIcon(arg1);
14452
14453 wxPyEndAllowThreads(__tstate);
14454 if (PyErr_Occurred()) SWIG_fail;
14455 }
14456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14457 return resultobj;
14458 fail:
14459 return NULL;
14460 }
14461
14462
14463 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14464 PyObject *resultobj;
14465 wxFileType *arg1 = (wxFileType *) 0 ;
14466 PyObject *result;
14467 PyObject * obj0 = 0 ;
14468 char *kwnames[] = {
14469 (char *) "self", NULL
14470 };
14471
14472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14474 if (SWIG_arg_fail(1)) SWIG_fail;
14475 {
14476 PyThreadState* __tstate = wxPyBeginAllowThreads();
14477 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14478
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 resultobj = result;
14483 return resultobj;
14484 fail:
14485 return NULL;
14486 }
14487
14488
14489 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14490 PyObject *resultobj;
14491 wxFileType *arg1 = (wxFileType *) 0 ;
14492 PyObject *result;
14493 PyObject * obj0 = 0 ;
14494 char *kwnames[] = {
14495 (char *) "self", NULL
14496 };
14497
14498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14500 if (SWIG_arg_fail(1)) SWIG_fail;
14501 {
14502 PyThreadState* __tstate = wxPyBeginAllowThreads();
14503 result = (PyObject *)wxFileType_GetDescription(arg1);
14504
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 resultobj = result;
14509 return resultobj;
14510 fail:
14511 return NULL;
14512 }
14513
14514
14515 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14516 PyObject *resultobj;
14517 wxFileType *arg1 = (wxFileType *) 0 ;
14518 wxString *arg2 = 0 ;
14519 wxString const &arg3_defvalue = wxPyEmptyString ;
14520 wxString *arg3 = (wxString *) &arg3_defvalue ;
14521 PyObject *result;
14522 bool temp2 = false ;
14523 bool temp3 = false ;
14524 PyObject * obj0 = 0 ;
14525 PyObject * obj1 = 0 ;
14526 PyObject * obj2 = 0 ;
14527 char *kwnames[] = {
14528 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14529 };
14530
14531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14533 if (SWIG_arg_fail(1)) SWIG_fail;
14534 {
14535 arg2 = wxString_in_helper(obj1);
14536 if (arg2 == NULL) SWIG_fail;
14537 temp2 = true;
14538 }
14539 if (obj2) {
14540 {
14541 arg3 = wxString_in_helper(obj2);
14542 if (arg3 == NULL) SWIG_fail;
14543 temp3 = true;
14544 }
14545 }
14546 {
14547 PyThreadState* __tstate = wxPyBeginAllowThreads();
14548 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14549
14550 wxPyEndAllowThreads(__tstate);
14551 if (PyErr_Occurred()) SWIG_fail;
14552 }
14553 resultobj = result;
14554 {
14555 if (temp2)
14556 delete arg2;
14557 }
14558 {
14559 if (temp3)
14560 delete arg3;
14561 }
14562 return resultobj;
14563 fail:
14564 {
14565 if (temp2)
14566 delete arg2;
14567 }
14568 {
14569 if (temp3)
14570 delete arg3;
14571 }
14572 return NULL;
14573 }
14574
14575
14576 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14577 PyObject *resultobj;
14578 wxFileType *arg1 = (wxFileType *) 0 ;
14579 wxString *arg2 = 0 ;
14580 wxString const &arg3_defvalue = wxPyEmptyString ;
14581 wxString *arg3 = (wxString *) &arg3_defvalue ;
14582 PyObject *result;
14583 bool temp2 = false ;
14584 bool temp3 = false ;
14585 PyObject * obj0 = 0 ;
14586 PyObject * obj1 = 0 ;
14587 PyObject * obj2 = 0 ;
14588 char *kwnames[] = {
14589 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14590 };
14591
14592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14594 if (SWIG_arg_fail(1)) SWIG_fail;
14595 {
14596 arg2 = wxString_in_helper(obj1);
14597 if (arg2 == NULL) SWIG_fail;
14598 temp2 = true;
14599 }
14600 if (obj2) {
14601 {
14602 arg3 = wxString_in_helper(obj2);
14603 if (arg3 == NULL) SWIG_fail;
14604 temp3 = true;
14605 }
14606 }
14607 {
14608 PyThreadState* __tstate = wxPyBeginAllowThreads();
14609 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14610
14611 wxPyEndAllowThreads(__tstate);
14612 if (PyErr_Occurred()) SWIG_fail;
14613 }
14614 resultobj = result;
14615 {
14616 if (temp2)
14617 delete arg2;
14618 }
14619 {
14620 if (temp3)
14621 delete arg3;
14622 }
14623 return resultobj;
14624 fail:
14625 {
14626 if (temp2)
14627 delete arg2;
14628 }
14629 {
14630 if (temp3)
14631 delete arg3;
14632 }
14633 return NULL;
14634 }
14635
14636
14637 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14638 PyObject *resultobj;
14639 wxFileType *arg1 = (wxFileType *) 0 ;
14640 wxString *arg2 = 0 ;
14641 wxString const &arg3_defvalue = wxPyEmptyString ;
14642 wxString *arg3 = (wxString *) &arg3_defvalue ;
14643 PyObject *result;
14644 bool temp2 = false ;
14645 bool temp3 = false ;
14646 PyObject * obj0 = 0 ;
14647 PyObject * obj1 = 0 ;
14648 PyObject * obj2 = 0 ;
14649 char *kwnames[] = {
14650 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14651 };
14652
14653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14655 if (SWIG_arg_fail(1)) SWIG_fail;
14656 {
14657 arg2 = wxString_in_helper(obj1);
14658 if (arg2 == NULL) SWIG_fail;
14659 temp2 = true;
14660 }
14661 if (obj2) {
14662 {
14663 arg3 = wxString_in_helper(obj2);
14664 if (arg3 == NULL) SWIG_fail;
14665 temp3 = true;
14666 }
14667 }
14668 {
14669 PyThreadState* __tstate = wxPyBeginAllowThreads();
14670 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14671
14672 wxPyEndAllowThreads(__tstate);
14673 if (PyErr_Occurred()) SWIG_fail;
14674 }
14675 resultobj = result;
14676 {
14677 if (temp2)
14678 delete arg2;
14679 }
14680 {
14681 if (temp3)
14682 delete arg3;
14683 }
14684 return resultobj;
14685 fail:
14686 {
14687 if (temp2)
14688 delete arg2;
14689 }
14690 {
14691 if (temp3)
14692 delete arg3;
14693 }
14694 return NULL;
14695 }
14696
14697
14698 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14699 PyObject *resultobj;
14700 wxFileType *arg1 = (wxFileType *) 0 ;
14701 wxString *arg2 = 0 ;
14702 wxString *arg3 = 0 ;
14703 bool arg4 = (bool) true ;
14704 bool result;
14705 bool temp2 = false ;
14706 bool temp3 = false ;
14707 PyObject * obj0 = 0 ;
14708 PyObject * obj1 = 0 ;
14709 PyObject * obj2 = 0 ;
14710 PyObject * obj3 = 0 ;
14711 char *kwnames[] = {
14712 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14713 };
14714
14715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14717 if (SWIG_arg_fail(1)) SWIG_fail;
14718 {
14719 arg2 = wxString_in_helper(obj1);
14720 if (arg2 == NULL) SWIG_fail;
14721 temp2 = true;
14722 }
14723 {
14724 arg3 = wxString_in_helper(obj2);
14725 if (arg3 == NULL) SWIG_fail;
14726 temp3 = true;
14727 }
14728 if (obj3) {
14729 {
14730 arg4 = (bool)(SWIG_As_bool(obj3));
14731 if (SWIG_arg_fail(4)) SWIG_fail;
14732 }
14733 }
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14737
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 {
14742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14743 }
14744 {
14745 if (temp2)
14746 delete arg2;
14747 }
14748 {
14749 if (temp3)
14750 delete arg3;
14751 }
14752 return resultobj;
14753 fail:
14754 {
14755 if (temp2)
14756 delete arg2;
14757 }
14758 {
14759 if (temp3)
14760 delete arg3;
14761 }
14762 return NULL;
14763 }
14764
14765
14766 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14767 PyObject *resultobj;
14768 wxFileType *arg1 = (wxFileType *) 0 ;
14769 wxString const &arg2_defvalue = wxPyEmptyString ;
14770 wxString *arg2 = (wxString *) &arg2_defvalue ;
14771 int arg3 = (int) 0 ;
14772 bool result;
14773 bool temp2 = false ;
14774 PyObject * obj0 = 0 ;
14775 PyObject * obj1 = 0 ;
14776 PyObject * obj2 = 0 ;
14777 char *kwnames[] = {
14778 (char *) "self",(char *) "cmd",(char *) "index", NULL
14779 };
14780
14781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",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 if (obj1) {
14785 {
14786 arg2 = wxString_in_helper(obj1);
14787 if (arg2 == NULL) SWIG_fail;
14788 temp2 = true;
14789 }
14790 }
14791 if (obj2) {
14792 {
14793 arg3 = (int)(SWIG_As_int(obj2));
14794 if (SWIG_arg_fail(3)) SWIG_fail;
14795 }
14796 }
14797 {
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14800
14801 wxPyEndAllowThreads(__tstate);
14802 if (PyErr_Occurred()) SWIG_fail;
14803 }
14804 {
14805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14806 }
14807 {
14808 if (temp2)
14809 delete arg2;
14810 }
14811 return resultobj;
14812 fail:
14813 {
14814 if (temp2)
14815 delete arg2;
14816 }
14817 return NULL;
14818 }
14819
14820
14821 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14822 PyObject *resultobj;
14823 wxFileType *arg1 = (wxFileType *) 0 ;
14824 bool result;
14825 PyObject * obj0 = 0 ;
14826 char *kwnames[] = {
14827 (char *) "self", NULL
14828 };
14829
14830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14832 if (SWIG_arg_fail(1)) SWIG_fail;
14833 {
14834 PyThreadState* __tstate = wxPyBeginAllowThreads();
14835 result = (bool)(arg1)->Unassociate();
14836
14837 wxPyEndAllowThreads(__tstate);
14838 if (PyErr_Occurred()) SWIG_fail;
14839 }
14840 {
14841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14842 }
14843 return resultobj;
14844 fail:
14845 return NULL;
14846 }
14847
14848
14849 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14850 PyObject *resultobj;
14851 wxString *arg1 = 0 ;
14852 wxString *arg2 = 0 ;
14853 wxString const &arg3_defvalue = wxPyEmptyString ;
14854 wxString *arg3 = (wxString *) &arg3_defvalue ;
14855 wxString result;
14856 bool temp1 = false ;
14857 bool temp2 = false ;
14858 bool temp3 = false ;
14859 PyObject * obj0 = 0 ;
14860 PyObject * obj1 = 0 ;
14861 PyObject * obj2 = 0 ;
14862 char *kwnames[] = {
14863 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14864 };
14865
14866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14867 {
14868 arg1 = wxString_in_helper(obj0);
14869 if (arg1 == NULL) SWIG_fail;
14870 temp1 = true;
14871 }
14872 {
14873 arg2 = wxString_in_helper(obj1);
14874 if (arg2 == NULL) SWIG_fail;
14875 temp2 = true;
14876 }
14877 if (obj2) {
14878 {
14879 arg3 = wxString_in_helper(obj2);
14880 if (arg3 == NULL) SWIG_fail;
14881 temp3 = true;
14882 }
14883 }
14884 {
14885 PyThreadState* __tstate = wxPyBeginAllowThreads();
14886 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14887
14888 wxPyEndAllowThreads(__tstate);
14889 if (PyErr_Occurred()) SWIG_fail;
14890 }
14891 {
14892 #if wxUSE_UNICODE
14893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14894 #else
14895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14896 #endif
14897 }
14898 {
14899 if (temp1)
14900 delete arg1;
14901 }
14902 {
14903 if (temp2)
14904 delete arg2;
14905 }
14906 {
14907 if (temp3)
14908 delete arg3;
14909 }
14910 return resultobj;
14911 fail:
14912 {
14913 if (temp1)
14914 delete arg1;
14915 }
14916 {
14917 if (temp2)
14918 delete arg2;
14919 }
14920 {
14921 if (temp3)
14922 delete arg3;
14923 }
14924 return NULL;
14925 }
14926
14927
14928 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14929 PyObject *obj;
14930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14931 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14932 Py_INCREF(obj);
14933 return Py_BuildValue((char *)"");
14934 }
14935 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14936 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14937 return 1;
14938 }
14939
14940
14941 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14942 PyObject *pyobj;
14943
14944 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14945 return pyobj;
14946 }
14947
14948
14949 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14950 PyObject *resultobj;
14951 wxString *arg1 = 0 ;
14952 wxString *arg2 = 0 ;
14953 bool result;
14954 bool temp1 = false ;
14955 bool temp2 = false ;
14956 PyObject * obj0 = 0 ;
14957 PyObject * obj1 = 0 ;
14958 char *kwnames[] = {
14959 (char *) "mimeType",(char *) "wildcard", NULL
14960 };
14961
14962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14963 {
14964 arg1 = wxString_in_helper(obj0);
14965 if (arg1 == NULL) SWIG_fail;
14966 temp1 = true;
14967 }
14968 {
14969 arg2 = wxString_in_helper(obj1);
14970 if (arg2 == NULL) SWIG_fail;
14971 temp2 = true;
14972 }
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14976
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 {
14981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14982 }
14983 {
14984 if (temp1)
14985 delete arg1;
14986 }
14987 {
14988 if (temp2)
14989 delete arg2;
14990 }
14991 return resultobj;
14992 fail:
14993 {
14994 if (temp1)
14995 delete arg1;
14996 }
14997 {
14998 if (temp2)
14999 delete arg2;
15000 }
15001 return NULL;
15002 }
15003
15004
15005 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15006 PyObject *resultobj;
15007 wxMimeTypesManager *result;
15008 char *kwnames[] = {
15009 NULL
15010 };
15011
15012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15013 {
15014 PyThreadState* __tstate = wxPyBeginAllowThreads();
15015 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15016
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15021 return resultobj;
15022 fail:
15023 return NULL;
15024 }
15025
15026
15027 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15028 PyObject *resultobj;
15029 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15030 int arg2 = (int) wxMAILCAP_ALL ;
15031 wxString const &arg3_defvalue = wxPyEmptyString ;
15032 wxString *arg3 = (wxString *) &arg3_defvalue ;
15033 bool temp3 = false ;
15034 PyObject * obj0 = 0 ;
15035 PyObject * obj1 = 0 ;
15036 PyObject * obj2 = 0 ;
15037 char *kwnames[] = {
15038 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15039 };
15040
15041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15043 if (SWIG_arg_fail(1)) SWIG_fail;
15044 if (obj1) {
15045 {
15046 arg2 = (int)(SWIG_As_int(obj1));
15047 if (SWIG_arg_fail(2)) SWIG_fail;
15048 }
15049 }
15050 if (obj2) {
15051 {
15052 arg3 = wxString_in_helper(obj2);
15053 if (arg3 == NULL) SWIG_fail;
15054 temp3 = true;
15055 }
15056 }
15057 {
15058 PyThreadState* __tstate = wxPyBeginAllowThreads();
15059 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15060
15061 wxPyEndAllowThreads(__tstate);
15062 if (PyErr_Occurred()) SWIG_fail;
15063 }
15064 Py_INCREF(Py_None); resultobj = Py_None;
15065 {
15066 if (temp3)
15067 delete arg3;
15068 }
15069 return resultobj;
15070 fail:
15071 {
15072 if (temp3)
15073 delete arg3;
15074 }
15075 return NULL;
15076 }
15077
15078
15079 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15080 PyObject *resultobj;
15081 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15082 PyObject * obj0 = 0 ;
15083 char *kwnames[] = {
15084 (char *) "self", NULL
15085 };
15086
15087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15089 if (SWIG_arg_fail(1)) SWIG_fail;
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 (arg1)->ClearData();
15093
15094 wxPyEndAllowThreads(__tstate);
15095 if (PyErr_Occurred()) SWIG_fail;
15096 }
15097 Py_INCREF(Py_None); resultobj = Py_None;
15098 return resultobj;
15099 fail:
15100 return NULL;
15101 }
15102
15103
15104 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15105 PyObject *resultobj;
15106 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15107 wxString *arg2 = 0 ;
15108 wxFileType *result;
15109 bool temp2 = false ;
15110 PyObject * obj0 = 0 ;
15111 PyObject * obj1 = 0 ;
15112 char *kwnames[] = {
15113 (char *) "self",(char *) "ext", NULL
15114 };
15115
15116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15118 if (SWIG_arg_fail(1)) SWIG_fail;
15119 {
15120 arg2 = wxString_in_helper(obj1);
15121 if (arg2 == NULL) SWIG_fail;
15122 temp2 = true;
15123 }
15124 {
15125 PyThreadState* __tstate = wxPyBeginAllowThreads();
15126 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15127
15128 wxPyEndAllowThreads(__tstate);
15129 if (PyErr_Occurred()) SWIG_fail;
15130 }
15131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15132 {
15133 if (temp2)
15134 delete arg2;
15135 }
15136 return resultobj;
15137 fail:
15138 {
15139 if (temp2)
15140 delete arg2;
15141 }
15142 return NULL;
15143 }
15144
15145
15146 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15147 PyObject *resultobj;
15148 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15149 wxString *arg2 = 0 ;
15150 wxFileType *result;
15151 bool temp2 = false ;
15152 PyObject * obj0 = 0 ;
15153 PyObject * obj1 = 0 ;
15154 char *kwnames[] = {
15155 (char *) "self",(char *) "mimeType", NULL
15156 };
15157
15158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15160 if (SWIG_arg_fail(1)) SWIG_fail;
15161 {
15162 arg2 = wxString_in_helper(obj1);
15163 if (arg2 == NULL) SWIG_fail;
15164 temp2 = true;
15165 }
15166 {
15167 PyThreadState* __tstate = wxPyBeginAllowThreads();
15168 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15169
15170 wxPyEndAllowThreads(__tstate);
15171 if (PyErr_Occurred()) SWIG_fail;
15172 }
15173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15174 {
15175 if (temp2)
15176 delete arg2;
15177 }
15178 return resultobj;
15179 fail:
15180 {
15181 if (temp2)
15182 delete arg2;
15183 }
15184 return NULL;
15185 }
15186
15187
15188 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15189 PyObject *resultobj;
15190 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15191 wxString *arg2 = 0 ;
15192 bool arg3 = (bool) false ;
15193 bool result;
15194 bool temp2 = false ;
15195 PyObject * obj0 = 0 ;
15196 PyObject * obj1 = 0 ;
15197 PyObject * obj2 = 0 ;
15198 char *kwnames[] = {
15199 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15200 };
15201
15202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15204 if (SWIG_arg_fail(1)) SWIG_fail;
15205 {
15206 arg2 = wxString_in_helper(obj1);
15207 if (arg2 == NULL) SWIG_fail;
15208 temp2 = true;
15209 }
15210 if (obj2) {
15211 {
15212 arg3 = (bool)(SWIG_As_bool(obj2));
15213 if (SWIG_arg_fail(3)) SWIG_fail;
15214 }
15215 }
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15219
15220 wxPyEndAllowThreads(__tstate);
15221 if (PyErr_Occurred()) SWIG_fail;
15222 }
15223 {
15224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15225 }
15226 {
15227 if (temp2)
15228 delete arg2;
15229 }
15230 return resultobj;
15231 fail:
15232 {
15233 if (temp2)
15234 delete arg2;
15235 }
15236 return NULL;
15237 }
15238
15239
15240 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15241 PyObject *resultobj;
15242 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15243 wxString *arg2 = 0 ;
15244 bool result;
15245 bool temp2 = false ;
15246 PyObject * obj0 = 0 ;
15247 PyObject * obj1 = 0 ;
15248 char *kwnames[] = {
15249 (char *) "self",(char *) "filename", NULL
15250 };
15251
15252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15254 if (SWIG_arg_fail(1)) SWIG_fail;
15255 {
15256 arg2 = wxString_in_helper(obj1);
15257 if (arg2 == NULL) SWIG_fail;
15258 temp2 = true;
15259 }
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15263
15264 wxPyEndAllowThreads(__tstate);
15265 if (PyErr_Occurred()) SWIG_fail;
15266 }
15267 {
15268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15269 }
15270 {
15271 if (temp2)
15272 delete arg2;
15273 }
15274 return resultobj;
15275 fail:
15276 {
15277 if (temp2)
15278 delete arg2;
15279 }
15280 return NULL;
15281 }
15282
15283
15284 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15285 PyObject *resultobj;
15286 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15287 PyObject *result;
15288 PyObject * obj0 = 0 ;
15289 char *kwnames[] = {
15290 (char *) "self", NULL
15291 };
15292
15293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15295 if (SWIG_arg_fail(1)) SWIG_fail;
15296 {
15297 PyThreadState* __tstate = wxPyBeginAllowThreads();
15298 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15299
15300 wxPyEndAllowThreads(__tstate);
15301 if (PyErr_Occurred()) SWIG_fail;
15302 }
15303 resultobj = result;
15304 return resultobj;
15305 fail:
15306 return NULL;
15307 }
15308
15309
15310 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15311 PyObject *resultobj;
15312 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15313 wxFileTypeInfo *arg2 = 0 ;
15314 PyObject * obj0 = 0 ;
15315 PyObject * obj1 = 0 ;
15316 char *kwnames[] = {
15317 (char *) "self",(char *) "ft", NULL
15318 };
15319
15320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15322 if (SWIG_arg_fail(1)) SWIG_fail;
15323 {
15324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15325 if (SWIG_arg_fail(2)) SWIG_fail;
15326 if (arg2 == NULL) {
15327 SWIG_null_ref("wxFileTypeInfo");
15328 }
15329 if (SWIG_arg_fail(2)) SWIG_fail;
15330 }
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15334
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 Py_INCREF(Py_None); resultobj = Py_None;
15339 return resultobj;
15340 fail:
15341 return NULL;
15342 }
15343
15344
15345 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15346 PyObject *resultobj;
15347 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15348 wxFileTypeInfo *arg2 = 0 ;
15349 wxFileType *result;
15350 PyObject * obj0 = 0 ;
15351 PyObject * obj1 = 0 ;
15352 char *kwnames[] = {
15353 (char *) "self",(char *) "ftInfo", NULL
15354 };
15355
15356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15358 if (SWIG_arg_fail(1)) SWIG_fail;
15359 {
15360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15361 if (SWIG_arg_fail(2)) SWIG_fail;
15362 if (arg2 == NULL) {
15363 SWIG_null_ref("wxFileTypeInfo");
15364 }
15365 if (SWIG_arg_fail(2)) SWIG_fail;
15366 }
15367 {
15368 PyThreadState* __tstate = wxPyBeginAllowThreads();
15369 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15370
15371 wxPyEndAllowThreads(__tstate);
15372 if (PyErr_Occurred()) SWIG_fail;
15373 }
15374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15382 PyObject *resultobj;
15383 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15384 wxFileType *arg2 = (wxFileType *) 0 ;
15385 bool result;
15386 PyObject * obj0 = 0 ;
15387 PyObject * obj1 = 0 ;
15388 char *kwnames[] = {
15389 (char *) "self",(char *) "ft", NULL
15390 };
15391
15392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15394 if (SWIG_arg_fail(1)) SWIG_fail;
15395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15396 if (SWIG_arg_fail(2)) SWIG_fail;
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 result = (bool)(arg1)->Unassociate(arg2);
15400
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 {
15405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15406 }
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15416 PyObject * obj0 = 0 ;
15417 char *kwnames[] = {
15418 (char *) "self", NULL
15419 };
15420
15421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",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 delete arg1;
15427
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 Py_INCREF(Py_None); resultobj = Py_None;
15432 return resultobj;
15433 fail:
15434 return NULL;
15435 }
15436
15437
15438 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15439 PyObject *obj;
15440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15441 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15442 Py_INCREF(obj);
15443 return Py_BuildValue((char *)"");
15444 }
15445 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15446 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15447 return 1;
15448 }
15449
15450
15451 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15452 PyObject *pyobj;
15453
15454 {
15455 #if wxUSE_UNICODE
15456 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15457 #else
15458 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15459 #endif
15460 }
15461 return pyobj;
15462 }
15463
15464
15465 static int _wrap_ART_MENU_set(PyObject *) {
15466 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15467 return 1;
15468 }
15469
15470
15471 static PyObject *_wrap_ART_MENU_get(void) {
15472 PyObject *pyobj;
15473
15474 {
15475 #if wxUSE_UNICODE
15476 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15477 #else
15478 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15479 #endif
15480 }
15481 return pyobj;
15482 }
15483
15484
15485 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15486 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15487 return 1;
15488 }
15489
15490
15491 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15492 PyObject *pyobj;
15493
15494 {
15495 #if wxUSE_UNICODE
15496 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15497 #else
15498 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15499 #endif
15500 }
15501 return pyobj;
15502 }
15503
15504
15505 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15506 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15507 return 1;
15508 }
15509
15510
15511 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15512 PyObject *pyobj;
15513
15514 {
15515 #if wxUSE_UNICODE
15516 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15517 #else
15518 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15519 #endif
15520 }
15521 return pyobj;
15522 }
15523
15524
15525 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15526 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15527 return 1;
15528 }
15529
15530
15531 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15532 PyObject *pyobj;
15533
15534 {
15535 #if wxUSE_UNICODE
15536 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15537 #else
15538 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15539 #endif
15540 }
15541 return pyobj;
15542 }
15543
15544
15545 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15546 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15547 return 1;
15548 }
15549
15550
15551 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15552 PyObject *pyobj;
15553
15554 {
15555 #if wxUSE_UNICODE
15556 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15557 #else
15558 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15559 #endif
15560 }
15561 return pyobj;
15562 }
15563
15564
15565 static int _wrap_ART_BUTTON_set(PyObject *) {
15566 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15567 return 1;
15568 }
15569
15570
15571 static PyObject *_wrap_ART_BUTTON_get(void) {
15572 PyObject *pyobj;
15573
15574 {
15575 #if wxUSE_UNICODE
15576 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15577 #else
15578 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15579 #endif
15580 }
15581 return pyobj;
15582 }
15583
15584
15585 static int _wrap_ART_OTHER_set(PyObject *) {
15586 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15587 return 1;
15588 }
15589
15590
15591 static PyObject *_wrap_ART_OTHER_get(void) {
15592 PyObject *pyobj;
15593
15594 {
15595 #if wxUSE_UNICODE
15596 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15597 #else
15598 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15599 #endif
15600 }
15601 return pyobj;
15602 }
15603
15604
15605 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15606 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15607 return 1;
15608 }
15609
15610
15611 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15612 PyObject *pyobj;
15613
15614 {
15615 #if wxUSE_UNICODE
15616 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15617 #else
15618 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15619 #endif
15620 }
15621 return pyobj;
15622 }
15623
15624
15625 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15626 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15627 return 1;
15628 }
15629
15630
15631 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15632 PyObject *pyobj;
15633
15634 {
15635 #if wxUSE_UNICODE
15636 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15637 #else
15638 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15639 #endif
15640 }
15641 return pyobj;
15642 }
15643
15644
15645 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15646 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15647 return 1;
15648 }
15649
15650
15651 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15652 PyObject *pyobj;
15653
15654 {
15655 #if wxUSE_UNICODE
15656 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15657 #else
15658 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15659 #endif
15660 }
15661 return pyobj;
15662 }
15663
15664
15665 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15666 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15667 return 1;
15668 }
15669
15670
15671 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15672 PyObject *pyobj;
15673
15674 {
15675 #if wxUSE_UNICODE
15676 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15677 #else
15678 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15679 #endif
15680 }
15681 return pyobj;
15682 }
15683
15684
15685 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15686 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15687 return 1;
15688 }
15689
15690
15691 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15692 PyObject *pyobj;
15693
15694 {
15695 #if wxUSE_UNICODE
15696 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15697 #else
15698 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15699 #endif
15700 }
15701 return pyobj;
15702 }
15703
15704
15705 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15706 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15707 return 1;
15708 }
15709
15710
15711 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15712 PyObject *pyobj;
15713
15714 {
15715 #if wxUSE_UNICODE
15716 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15717 #else
15718 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15719 #endif
15720 }
15721 return pyobj;
15722 }
15723
15724
15725 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15726 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15727 return 1;
15728 }
15729
15730
15731 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15732 PyObject *pyobj;
15733
15734 {
15735 #if wxUSE_UNICODE
15736 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15737 #else
15738 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15739 #endif
15740 }
15741 return pyobj;
15742 }
15743
15744
15745 static int _wrap_ART_GO_BACK_set(PyObject *) {
15746 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15747 return 1;
15748 }
15749
15750
15751 static PyObject *_wrap_ART_GO_BACK_get(void) {
15752 PyObject *pyobj;
15753
15754 {
15755 #if wxUSE_UNICODE
15756 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15757 #else
15758 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15759 #endif
15760 }
15761 return pyobj;
15762 }
15763
15764
15765 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15766 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15767 return 1;
15768 }
15769
15770
15771 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15772 PyObject *pyobj;
15773
15774 {
15775 #if wxUSE_UNICODE
15776 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15777 #else
15778 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15779 #endif
15780 }
15781 return pyobj;
15782 }
15783
15784
15785 static int _wrap_ART_GO_UP_set(PyObject *) {
15786 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15787 return 1;
15788 }
15789
15790
15791 static PyObject *_wrap_ART_GO_UP_get(void) {
15792 PyObject *pyobj;
15793
15794 {
15795 #if wxUSE_UNICODE
15796 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15797 #else
15798 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15799 #endif
15800 }
15801 return pyobj;
15802 }
15803
15804
15805 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15806 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15807 return 1;
15808 }
15809
15810
15811 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15812 PyObject *pyobj;
15813
15814 {
15815 #if wxUSE_UNICODE
15816 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15817 #else
15818 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15819 #endif
15820 }
15821 return pyobj;
15822 }
15823
15824
15825 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15826 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15827 return 1;
15828 }
15829
15830
15831 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15832 PyObject *pyobj;
15833
15834 {
15835 #if wxUSE_UNICODE
15836 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15837 #else
15838 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15839 #endif
15840 }
15841 return pyobj;
15842 }
15843
15844
15845 static int _wrap_ART_GO_HOME_set(PyObject *) {
15846 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15847 return 1;
15848 }
15849
15850
15851 static PyObject *_wrap_ART_GO_HOME_get(void) {
15852 PyObject *pyobj;
15853
15854 {
15855 #if wxUSE_UNICODE
15856 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15857 #else
15858 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15859 #endif
15860 }
15861 return pyobj;
15862 }
15863
15864
15865 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15866 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15867 return 1;
15868 }
15869
15870
15871 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15872 PyObject *pyobj;
15873
15874 {
15875 #if wxUSE_UNICODE
15876 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15877 #else
15878 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15879 #endif
15880 }
15881 return pyobj;
15882 }
15883
15884
15885 static int _wrap_ART_PRINT_set(PyObject *) {
15886 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15887 return 1;
15888 }
15889
15890
15891 static PyObject *_wrap_ART_PRINT_get(void) {
15892 PyObject *pyobj;
15893
15894 {
15895 #if wxUSE_UNICODE
15896 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15897 #else
15898 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15899 #endif
15900 }
15901 return pyobj;
15902 }
15903
15904
15905 static int _wrap_ART_HELP_set(PyObject *) {
15906 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15907 return 1;
15908 }
15909
15910
15911 static PyObject *_wrap_ART_HELP_get(void) {
15912 PyObject *pyobj;
15913
15914 {
15915 #if wxUSE_UNICODE
15916 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15917 #else
15918 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15919 #endif
15920 }
15921 return pyobj;
15922 }
15923
15924
15925 static int _wrap_ART_TIP_set(PyObject *) {
15926 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15927 return 1;
15928 }
15929
15930
15931 static PyObject *_wrap_ART_TIP_get(void) {
15932 PyObject *pyobj;
15933
15934 {
15935 #if wxUSE_UNICODE
15936 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15937 #else
15938 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15939 #endif
15940 }
15941 return pyobj;
15942 }
15943
15944
15945 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15946 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15947 return 1;
15948 }
15949
15950
15951 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15952 PyObject *pyobj;
15953
15954 {
15955 #if wxUSE_UNICODE
15956 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15957 #else
15958 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15959 #endif
15960 }
15961 return pyobj;
15962 }
15963
15964
15965 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15966 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15967 return 1;
15968 }
15969
15970
15971 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15972 PyObject *pyobj;
15973
15974 {
15975 #if wxUSE_UNICODE
15976 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15977 #else
15978 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15979 #endif
15980 }
15981 return pyobj;
15982 }
15983
15984
15985 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15986 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15987 return 1;
15988 }
15989
15990
15991 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15992 PyObject *pyobj;
15993
15994 {
15995 #if wxUSE_UNICODE
15996 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15997 #else
15998 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15999 #endif
16000 }
16001 return pyobj;
16002 }
16003
16004
16005 static int _wrap_ART_HARDDISK_set(PyObject *) {
16006 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16007 return 1;
16008 }
16009
16010
16011 static PyObject *_wrap_ART_HARDDISK_get(void) {
16012 PyObject *pyobj;
16013
16014 {
16015 #if wxUSE_UNICODE
16016 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16017 #else
16018 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16019 #endif
16020 }
16021 return pyobj;
16022 }
16023
16024
16025 static int _wrap_ART_FLOPPY_set(PyObject *) {
16026 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16027 return 1;
16028 }
16029
16030
16031 static PyObject *_wrap_ART_FLOPPY_get(void) {
16032 PyObject *pyobj;
16033
16034 {
16035 #if wxUSE_UNICODE
16036 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16037 #else
16038 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16039 #endif
16040 }
16041 return pyobj;
16042 }
16043
16044
16045 static int _wrap_ART_CDROM_set(PyObject *) {
16046 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16047 return 1;
16048 }
16049
16050
16051 static PyObject *_wrap_ART_CDROM_get(void) {
16052 PyObject *pyobj;
16053
16054 {
16055 #if wxUSE_UNICODE
16056 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16057 #else
16058 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16059 #endif
16060 }
16061 return pyobj;
16062 }
16063
16064
16065 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16066 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16067 return 1;
16068 }
16069
16070
16071 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16072 PyObject *pyobj;
16073
16074 {
16075 #if wxUSE_UNICODE
16076 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16077 #else
16078 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16079 #endif
16080 }
16081 return pyobj;
16082 }
16083
16084
16085 static int _wrap_ART_FOLDER_set(PyObject *) {
16086 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16087 return 1;
16088 }
16089
16090
16091 static PyObject *_wrap_ART_FOLDER_get(void) {
16092 PyObject *pyobj;
16093
16094 {
16095 #if wxUSE_UNICODE
16096 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16097 #else
16098 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16099 #endif
16100 }
16101 return pyobj;
16102 }
16103
16104
16105 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16106 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16107 return 1;
16108 }
16109
16110
16111 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16112 PyObject *pyobj;
16113
16114 {
16115 #if wxUSE_UNICODE
16116 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16117 #else
16118 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16119 #endif
16120 }
16121 return pyobj;
16122 }
16123
16124
16125 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16126 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16127 return 1;
16128 }
16129
16130
16131 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16132 PyObject *pyobj;
16133
16134 {
16135 #if wxUSE_UNICODE
16136 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16137 #else
16138 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16139 #endif
16140 }
16141 return pyobj;
16142 }
16143
16144
16145 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16146 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16147 return 1;
16148 }
16149
16150
16151 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16152 PyObject *pyobj;
16153
16154 {
16155 #if wxUSE_UNICODE
16156 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16157 #else
16158 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16159 #endif
16160 }
16161 return pyobj;
16162 }
16163
16164
16165 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16166 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16167 return 1;
16168 }
16169
16170
16171 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16172 PyObject *pyobj;
16173
16174 {
16175 #if wxUSE_UNICODE
16176 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16177 #else
16178 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16179 #endif
16180 }
16181 return pyobj;
16182 }
16183
16184
16185 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16186 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16187 return 1;
16188 }
16189
16190
16191 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16192 PyObject *pyobj;
16193
16194 {
16195 #if wxUSE_UNICODE
16196 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16197 #else
16198 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16199 #endif
16200 }
16201 return pyobj;
16202 }
16203
16204
16205 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16206 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16207 return 1;
16208 }
16209
16210
16211 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16212 PyObject *pyobj;
16213
16214 {
16215 #if wxUSE_UNICODE
16216 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16217 #else
16218 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16219 #endif
16220 }
16221 return pyobj;
16222 }
16223
16224
16225 static int _wrap_ART_ERROR_set(PyObject *) {
16226 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16227 return 1;
16228 }
16229
16230
16231 static PyObject *_wrap_ART_ERROR_get(void) {
16232 PyObject *pyobj;
16233
16234 {
16235 #if wxUSE_UNICODE
16236 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16237 #else
16238 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16239 #endif
16240 }
16241 return pyobj;
16242 }
16243
16244
16245 static int _wrap_ART_QUESTION_set(PyObject *) {
16246 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16247 return 1;
16248 }
16249
16250
16251 static PyObject *_wrap_ART_QUESTION_get(void) {
16252 PyObject *pyobj;
16253
16254 {
16255 #if wxUSE_UNICODE
16256 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16257 #else
16258 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16259 #endif
16260 }
16261 return pyobj;
16262 }
16263
16264
16265 static int _wrap_ART_WARNING_set(PyObject *) {
16266 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16267 return 1;
16268 }
16269
16270
16271 static PyObject *_wrap_ART_WARNING_get(void) {
16272 PyObject *pyobj;
16273
16274 {
16275 #if wxUSE_UNICODE
16276 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16277 #else
16278 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16279 #endif
16280 }
16281 return pyobj;
16282 }
16283
16284
16285 static int _wrap_ART_INFORMATION_set(PyObject *) {
16286 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16287 return 1;
16288 }
16289
16290
16291 static PyObject *_wrap_ART_INFORMATION_get(void) {
16292 PyObject *pyobj;
16293
16294 {
16295 #if wxUSE_UNICODE
16296 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16297 #else
16298 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16299 #endif
16300 }
16301 return pyobj;
16302 }
16303
16304
16305 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16306 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16307 return 1;
16308 }
16309
16310
16311 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16312 PyObject *pyobj;
16313
16314 {
16315 #if wxUSE_UNICODE
16316 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16317 #else
16318 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16319 #endif
16320 }
16321 return pyobj;
16322 }
16323
16324
16325 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj;
16327 wxPyArtProvider *result;
16328 char *kwnames[] = {
16329 NULL
16330 };
16331
16332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16333 {
16334 if (!wxPyCheckForApp()) SWIG_fail;
16335 PyThreadState* __tstate = wxPyBeginAllowThreads();
16336 result = (wxPyArtProvider *)new wxPyArtProvider();
16337
16338 wxPyEndAllowThreads(__tstate);
16339 if (PyErr_Occurred()) SWIG_fail;
16340 }
16341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16342 return resultobj;
16343 fail:
16344 return NULL;
16345 }
16346
16347
16348 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16349 PyObject *resultobj;
16350 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16351 PyObject *arg2 = (PyObject *) 0 ;
16352 PyObject *arg3 = (PyObject *) 0 ;
16353 PyObject * obj0 = 0 ;
16354 PyObject * obj1 = 0 ;
16355 PyObject * obj2 = 0 ;
16356 char *kwnames[] = {
16357 (char *) "self",(char *) "self",(char *) "_class", NULL
16358 };
16359
16360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16362 if (SWIG_arg_fail(1)) SWIG_fail;
16363 arg2 = obj1;
16364 arg3 = obj2;
16365 {
16366 PyThreadState* __tstate = wxPyBeginAllowThreads();
16367 (arg1)->_setCallbackInfo(arg2,arg3);
16368
16369 wxPyEndAllowThreads(__tstate);
16370 if (PyErr_Occurred()) SWIG_fail;
16371 }
16372 Py_INCREF(Py_None); resultobj = Py_None;
16373 return resultobj;
16374 fail:
16375 return NULL;
16376 }
16377
16378
16379 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16380 PyObject *resultobj;
16381 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16382 PyObject * obj0 = 0 ;
16383 char *kwnames[] = {
16384 (char *) "provider", NULL
16385 };
16386
16387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16389 if (SWIG_arg_fail(1)) SWIG_fail;
16390 {
16391 PyThreadState* __tstate = wxPyBeginAllowThreads();
16392 wxPyArtProvider::PushProvider(arg1);
16393
16394 wxPyEndAllowThreads(__tstate);
16395 if (PyErr_Occurred()) SWIG_fail;
16396 }
16397 Py_INCREF(Py_None); resultobj = Py_None;
16398 return resultobj;
16399 fail:
16400 return NULL;
16401 }
16402
16403
16404 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16405 PyObject *resultobj;
16406 bool result;
16407 char *kwnames[] = {
16408 NULL
16409 };
16410
16411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16412 {
16413 PyThreadState* __tstate = wxPyBeginAllowThreads();
16414 result = (bool)wxPyArtProvider::PopProvider();
16415
16416 wxPyEndAllowThreads(__tstate);
16417 if (PyErr_Occurred()) SWIG_fail;
16418 }
16419 {
16420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16421 }
16422 return resultobj;
16423 fail:
16424 return NULL;
16425 }
16426
16427
16428 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16429 PyObject *resultobj;
16430 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16431 bool result;
16432 PyObject * obj0 = 0 ;
16433 char *kwnames[] = {
16434 (char *) "provider", NULL
16435 };
16436
16437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16439 if (SWIG_arg_fail(1)) SWIG_fail;
16440 {
16441 PyThreadState* __tstate = wxPyBeginAllowThreads();
16442 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16443
16444 wxPyEndAllowThreads(__tstate);
16445 if (PyErr_Occurred()) SWIG_fail;
16446 }
16447 {
16448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16449 }
16450 return resultobj;
16451 fail:
16452 return NULL;
16453 }
16454
16455
16456 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16457 PyObject *resultobj;
16458 wxString *arg1 = 0 ;
16459 wxString const &arg2_defvalue = wxPyART_OTHER ;
16460 wxString *arg2 = (wxString *) &arg2_defvalue ;
16461 wxSize const &arg3_defvalue = wxDefaultSize ;
16462 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16463 wxBitmap result;
16464 bool temp1 = false ;
16465 bool temp2 = false ;
16466 wxSize temp3 ;
16467 PyObject * obj0 = 0 ;
16468 PyObject * obj1 = 0 ;
16469 PyObject * obj2 = 0 ;
16470 char *kwnames[] = {
16471 (char *) "id",(char *) "client",(char *) "size", NULL
16472 };
16473
16474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16475 {
16476 arg1 = wxString_in_helper(obj0);
16477 if (arg1 == NULL) SWIG_fail;
16478 temp1 = true;
16479 }
16480 if (obj1) {
16481 {
16482 arg2 = wxString_in_helper(obj1);
16483 if (arg2 == NULL) SWIG_fail;
16484 temp2 = true;
16485 }
16486 }
16487 if (obj2) {
16488 {
16489 arg3 = &temp3;
16490 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16491 }
16492 }
16493 {
16494 if (!wxPyCheckForApp()) SWIG_fail;
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16497
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 {
16502 wxBitmap * resultptr;
16503 resultptr = new wxBitmap((wxBitmap &)(result));
16504 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16505 }
16506 {
16507 if (temp1)
16508 delete arg1;
16509 }
16510 {
16511 if (temp2)
16512 delete arg2;
16513 }
16514 return resultobj;
16515 fail:
16516 {
16517 if (temp1)
16518 delete arg1;
16519 }
16520 {
16521 if (temp2)
16522 delete arg2;
16523 }
16524 return NULL;
16525 }
16526
16527
16528 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16529 PyObject *resultobj;
16530 wxString *arg1 = 0 ;
16531 wxString const &arg2_defvalue = wxPyART_OTHER ;
16532 wxString *arg2 = (wxString *) &arg2_defvalue ;
16533 wxSize const &arg3_defvalue = wxDefaultSize ;
16534 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16535 wxIcon result;
16536 bool temp1 = false ;
16537 bool temp2 = false ;
16538 wxSize temp3 ;
16539 PyObject * obj0 = 0 ;
16540 PyObject * obj1 = 0 ;
16541 PyObject * obj2 = 0 ;
16542 char *kwnames[] = {
16543 (char *) "id",(char *) "client",(char *) "size", NULL
16544 };
16545
16546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16547 {
16548 arg1 = wxString_in_helper(obj0);
16549 if (arg1 == NULL) SWIG_fail;
16550 temp1 = true;
16551 }
16552 if (obj1) {
16553 {
16554 arg2 = wxString_in_helper(obj1);
16555 if (arg2 == NULL) SWIG_fail;
16556 temp2 = true;
16557 }
16558 }
16559 if (obj2) {
16560 {
16561 arg3 = &temp3;
16562 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16563 }
16564 }
16565 {
16566 if (!wxPyCheckForApp()) SWIG_fail;
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16569
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 {
16574 wxIcon * resultptr;
16575 resultptr = new wxIcon((wxIcon &)(result));
16576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16577 }
16578 {
16579 if (temp1)
16580 delete arg1;
16581 }
16582 {
16583 if (temp2)
16584 delete arg2;
16585 }
16586 return resultobj;
16587 fail:
16588 {
16589 if (temp1)
16590 delete arg1;
16591 }
16592 {
16593 if (temp2)
16594 delete arg2;
16595 }
16596 return NULL;
16597 }
16598
16599
16600 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16601 PyObject *resultobj;
16602 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16603 PyObject * obj0 = 0 ;
16604 char *kwnames[] = {
16605 (char *) "self", NULL
16606 };
16607
16608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16610 if (SWIG_arg_fail(1)) SWIG_fail;
16611 {
16612 PyThreadState* __tstate = wxPyBeginAllowThreads();
16613 wxPyArtProvider_Destroy(arg1);
16614
16615 wxPyEndAllowThreads(__tstate);
16616 if (PyErr_Occurred()) SWIG_fail;
16617 }
16618 Py_INCREF(Py_None); resultobj = Py_None;
16619 return resultobj;
16620 fail:
16621 return NULL;
16622 }
16623
16624
16625 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16626 PyObject *obj;
16627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16628 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16629 Py_INCREF(obj);
16630 return Py_BuildValue((char *)"");
16631 }
16632 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj;
16634 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16635 PyObject * obj0 = 0 ;
16636 char *kwnames[] = {
16637 (char *) "self", NULL
16638 };
16639
16640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16642 if (SWIG_arg_fail(1)) SWIG_fail;
16643 {
16644 PyThreadState* __tstate = wxPyBeginAllowThreads();
16645 delete arg1;
16646
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 Py_INCREF(Py_None); resultobj = Py_None;
16651 return resultobj;
16652 fail:
16653 return NULL;
16654 }
16655
16656
16657 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16658 PyObject *resultobj;
16659 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16660 wxConfigBase *result;
16661 PyObject * obj0 = 0 ;
16662 char *kwnames[] = {
16663 (char *) "config", NULL
16664 };
16665
16666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16668 if (SWIG_arg_fail(1)) SWIG_fail;
16669 {
16670 PyThreadState* __tstate = wxPyBeginAllowThreads();
16671 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16672
16673 wxPyEndAllowThreads(__tstate);
16674 if (PyErr_Occurred()) SWIG_fail;
16675 }
16676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16677 return resultobj;
16678 fail:
16679 return NULL;
16680 }
16681
16682
16683 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16684 PyObject *resultobj;
16685 bool arg1 = (bool) true ;
16686 wxConfigBase *result;
16687 PyObject * obj0 = 0 ;
16688 char *kwnames[] = {
16689 (char *) "createOnDemand", NULL
16690 };
16691
16692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16693 if (obj0) {
16694 {
16695 arg1 = (bool)(SWIG_As_bool(obj0));
16696 if (SWIG_arg_fail(1)) SWIG_fail;
16697 }
16698 }
16699 {
16700 PyThreadState* __tstate = wxPyBeginAllowThreads();
16701 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16702
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16707 return resultobj;
16708 fail:
16709 return NULL;
16710 }
16711
16712
16713 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16714 PyObject *resultobj;
16715 wxConfigBase *result;
16716 char *kwnames[] = {
16717 NULL
16718 };
16719
16720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16721 {
16722 PyThreadState* __tstate = wxPyBeginAllowThreads();
16723 result = (wxConfigBase *)wxConfigBase::Create();
16724
16725 wxPyEndAllowThreads(__tstate);
16726 if (PyErr_Occurred()) SWIG_fail;
16727 }
16728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16729 return resultobj;
16730 fail:
16731 return NULL;
16732 }
16733
16734
16735 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16736 PyObject *resultobj;
16737 char *kwnames[] = {
16738 NULL
16739 };
16740
16741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16742 {
16743 PyThreadState* __tstate = wxPyBeginAllowThreads();
16744 wxConfigBase::DontCreateOnDemand();
16745
16746 wxPyEndAllowThreads(__tstate);
16747 if (PyErr_Occurred()) SWIG_fail;
16748 }
16749 Py_INCREF(Py_None); resultobj = Py_None;
16750 return resultobj;
16751 fail:
16752 return NULL;
16753 }
16754
16755
16756 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj;
16758 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16759 wxString *arg2 = 0 ;
16760 bool temp2 = false ;
16761 PyObject * obj0 = 0 ;
16762 PyObject * obj1 = 0 ;
16763 char *kwnames[] = {
16764 (char *) "self",(char *) "path", NULL
16765 };
16766
16767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16769 if (SWIG_arg_fail(1)) SWIG_fail;
16770 {
16771 arg2 = wxString_in_helper(obj1);
16772 if (arg2 == NULL) SWIG_fail;
16773 temp2 = true;
16774 }
16775 {
16776 PyThreadState* __tstate = wxPyBeginAllowThreads();
16777 (arg1)->SetPath((wxString const &)*arg2);
16778
16779 wxPyEndAllowThreads(__tstate);
16780 if (PyErr_Occurred()) SWIG_fail;
16781 }
16782 Py_INCREF(Py_None); resultobj = Py_None;
16783 {
16784 if (temp2)
16785 delete arg2;
16786 }
16787 return resultobj;
16788 fail:
16789 {
16790 if (temp2)
16791 delete arg2;
16792 }
16793 return NULL;
16794 }
16795
16796
16797 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16798 PyObject *resultobj;
16799 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16800 wxString *result;
16801 PyObject * obj0 = 0 ;
16802 char *kwnames[] = {
16803 (char *) "self", NULL
16804 };
16805
16806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16808 if (SWIG_arg_fail(1)) SWIG_fail;
16809 {
16810 PyThreadState* __tstate = wxPyBeginAllowThreads();
16811 {
16812 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16813 result = (wxString *) &_result_ref;
16814 }
16815
16816 wxPyEndAllowThreads(__tstate);
16817 if (PyErr_Occurred()) SWIG_fail;
16818 }
16819 {
16820 #if wxUSE_UNICODE
16821 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16822 #else
16823 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16824 #endif
16825 }
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16833 PyObject *resultobj;
16834 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16835 PyObject *result;
16836 PyObject * obj0 = 0 ;
16837 char *kwnames[] = {
16838 (char *) "self", NULL
16839 };
16840
16841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16843 if (SWIG_arg_fail(1)) SWIG_fail;
16844 {
16845 PyThreadState* __tstate = wxPyBeginAllowThreads();
16846 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16847
16848 wxPyEndAllowThreads(__tstate);
16849 if (PyErr_Occurred()) SWIG_fail;
16850 }
16851 resultobj = result;
16852 return resultobj;
16853 fail:
16854 return NULL;
16855 }
16856
16857
16858 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16859 PyObject *resultobj;
16860 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16861 long arg2 ;
16862 PyObject *result;
16863 PyObject * obj0 = 0 ;
16864 PyObject * obj1 = 0 ;
16865 char *kwnames[] = {
16866 (char *) "self",(char *) "index", NULL
16867 };
16868
16869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16871 if (SWIG_arg_fail(1)) SWIG_fail;
16872 {
16873 arg2 = (long)(SWIG_As_long(obj1));
16874 if (SWIG_arg_fail(2)) SWIG_fail;
16875 }
16876 {
16877 PyThreadState* __tstate = wxPyBeginAllowThreads();
16878 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16879
16880 wxPyEndAllowThreads(__tstate);
16881 if (PyErr_Occurred()) SWIG_fail;
16882 }
16883 resultobj = result;
16884 return resultobj;
16885 fail:
16886 return NULL;
16887 }
16888
16889
16890 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16891 PyObject *resultobj;
16892 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16893 PyObject *result;
16894 PyObject * obj0 = 0 ;
16895 char *kwnames[] = {
16896 (char *) "self", NULL
16897 };
16898
16899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16901 if (SWIG_arg_fail(1)) SWIG_fail;
16902 {
16903 PyThreadState* __tstate = wxPyBeginAllowThreads();
16904 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16905
16906 wxPyEndAllowThreads(__tstate);
16907 if (PyErr_Occurred()) SWIG_fail;
16908 }
16909 resultobj = result;
16910 return resultobj;
16911 fail:
16912 return NULL;
16913 }
16914
16915
16916 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16917 PyObject *resultobj;
16918 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16919 long arg2 ;
16920 PyObject *result;
16921 PyObject * obj0 = 0 ;
16922 PyObject * obj1 = 0 ;
16923 char *kwnames[] = {
16924 (char *) "self",(char *) "index", NULL
16925 };
16926
16927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16929 if (SWIG_arg_fail(1)) SWIG_fail;
16930 {
16931 arg2 = (long)(SWIG_As_long(obj1));
16932 if (SWIG_arg_fail(2)) SWIG_fail;
16933 }
16934 {
16935 PyThreadState* __tstate = wxPyBeginAllowThreads();
16936 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16937
16938 wxPyEndAllowThreads(__tstate);
16939 if (PyErr_Occurred()) SWIG_fail;
16940 }
16941 resultobj = result;
16942 return resultobj;
16943 fail:
16944 return NULL;
16945 }
16946
16947
16948 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16949 PyObject *resultobj;
16950 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16951 bool arg2 = (bool) false ;
16952 size_t result;
16953 PyObject * obj0 = 0 ;
16954 PyObject * obj1 = 0 ;
16955 char *kwnames[] = {
16956 (char *) "self",(char *) "recursive", NULL
16957 };
16958
16959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16961 if (SWIG_arg_fail(1)) SWIG_fail;
16962 if (obj1) {
16963 {
16964 arg2 = (bool)(SWIG_As_bool(obj1));
16965 if (SWIG_arg_fail(2)) SWIG_fail;
16966 }
16967 }
16968 {
16969 PyThreadState* __tstate = wxPyBeginAllowThreads();
16970 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16971
16972 wxPyEndAllowThreads(__tstate);
16973 if (PyErr_Occurred()) SWIG_fail;
16974 }
16975 {
16976 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16977 }
16978 return resultobj;
16979 fail:
16980 return NULL;
16981 }
16982
16983
16984 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16985 PyObject *resultobj;
16986 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16987 bool arg2 = (bool) false ;
16988 size_t result;
16989 PyObject * obj0 = 0 ;
16990 PyObject * obj1 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "self",(char *) "recursive", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 if (obj1) {
16999 {
17000 arg2 = (bool)(SWIG_As_bool(obj1));
17001 if (SWIG_arg_fail(2)) SWIG_fail;
17002 }
17003 }
17004 {
17005 PyThreadState* __tstate = wxPyBeginAllowThreads();
17006 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17007
17008 wxPyEndAllowThreads(__tstate);
17009 if (PyErr_Occurred()) SWIG_fail;
17010 }
17011 {
17012 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17013 }
17014 return resultobj;
17015 fail:
17016 return NULL;
17017 }
17018
17019
17020 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17021 PyObject *resultobj;
17022 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17023 wxString *arg2 = 0 ;
17024 bool result;
17025 bool temp2 = false ;
17026 PyObject * obj0 = 0 ;
17027 PyObject * obj1 = 0 ;
17028 char *kwnames[] = {
17029 (char *) "self",(char *) "name", NULL
17030 };
17031
17032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17034 if (SWIG_arg_fail(1)) SWIG_fail;
17035 {
17036 arg2 = wxString_in_helper(obj1);
17037 if (arg2 == NULL) SWIG_fail;
17038 temp2 = true;
17039 }
17040 {
17041 PyThreadState* __tstate = wxPyBeginAllowThreads();
17042 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17043
17044 wxPyEndAllowThreads(__tstate);
17045 if (PyErr_Occurred()) SWIG_fail;
17046 }
17047 {
17048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17049 }
17050 {
17051 if (temp2)
17052 delete arg2;
17053 }
17054 return resultobj;
17055 fail:
17056 {
17057 if (temp2)
17058 delete arg2;
17059 }
17060 return NULL;
17061 }
17062
17063
17064 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17065 PyObject *resultobj;
17066 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17067 wxString *arg2 = 0 ;
17068 bool result;
17069 bool temp2 = false ;
17070 PyObject * obj0 = 0 ;
17071 PyObject * obj1 = 0 ;
17072 char *kwnames[] = {
17073 (char *) "self",(char *) "name", NULL
17074 };
17075
17076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17078 if (SWIG_arg_fail(1)) SWIG_fail;
17079 {
17080 arg2 = wxString_in_helper(obj1);
17081 if (arg2 == NULL) SWIG_fail;
17082 temp2 = true;
17083 }
17084 {
17085 PyThreadState* __tstate = wxPyBeginAllowThreads();
17086 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17087
17088 wxPyEndAllowThreads(__tstate);
17089 if (PyErr_Occurred()) SWIG_fail;
17090 }
17091 {
17092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17093 }
17094 {
17095 if (temp2)
17096 delete arg2;
17097 }
17098 return resultobj;
17099 fail:
17100 {
17101 if (temp2)
17102 delete arg2;
17103 }
17104 return NULL;
17105 }
17106
17107
17108 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17109 PyObject *resultobj;
17110 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17111 wxString *arg2 = 0 ;
17112 bool result;
17113 bool temp2 = false ;
17114 PyObject * obj0 = 0 ;
17115 PyObject * obj1 = 0 ;
17116 char *kwnames[] = {
17117 (char *) "self",(char *) "name", NULL
17118 };
17119
17120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17122 if (SWIG_arg_fail(1)) SWIG_fail;
17123 {
17124 arg2 = wxString_in_helper(obj1);
17125 if (arg2 == NULL) SWIG_fail;
17126 temp2 = true;
17127 }
17128 {
17129 PyThreadState* __tstate = wxPyBeginAllowThreads();
17130 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17131
17132 wxPyEndAllowThreads(__tstate);
17133 if (PyErr_Occurred()) SWIG_fail;
17134 }
17135 {
17136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17137 }
17138 {
17139 if (temp2)
17140 delete arg2;
17141 }
17142 return resultobj;
17143 fail:
17144 {
17145 if (temp2)
17146 delete arg2;
17147 }
17148 return NULL;
17149 }
17150
17151
17152 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj;
17154 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17155 wxString *arg2 = 0 ;
17156 wxConfigBase::EntryType result;
17157 bool temp2 = false ;
17158 PyObject * obj0 = 0 ;
17159 PyObject * obj1 = 0 ;
17160 char *kwnames[] = {
17161 (char *) "self",(char *) "name", NULL
17162 };
17163
17164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17166 if (SWIG_arg_fail(1)) SWIG_fail;
17167 {
17168 arg2 = wxString_in_helper(obj1);
17169 if (arg2 == NULL) SWIG_fail;
17170 temp2 = true;
17171 }
17172 {
17173 PyThreadState* __tstate = wxPyBeginAllowThreads();
17174 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17175
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 resultobj = SWIG_From_int((result));
17180 {
17181 if (temp2)
17182 delete arg2;
17183 }
17184 return resultobj;
17185 fail:
17186 {
17187 if (temp2)
17188 delete arg2;
17189 }
17190 return NULL;
17191 }
17192
17193
17194 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj;
17196 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17197 wxString *arg2 = 0 ;
17198 wxString const &arg3_defvalue = wxPyEmptyString ;
17199 wxString *arg3 = (wxString *) &arg3_defvalue ;
17200 wxString result;
17201 bool temp2 = false ;
17202 bool temp3 = false ;
17203 PyObject * obj0 = 0 ;
17204 PyObject * obj1 = 0 ;
17205 PyObject * obj2 = 0 ;
17206 char *kwnames[] = {
17207 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17208 };
17209
17210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17212 if (SWIG_arg_fail(1)) SWIG_fail;
17213 {
17214 arg2 = wxString_in_helper(obj1);
17215 if (arg2 == NULL) SWIG_fail;
17216 temp2 = true;
17217 }
17218 if (obj2) {
17219 {
17220 arg3 = wxString_in_helper(obj2);
17221 if (arg3 == NULL) SWIG_fail;
17222 temp3 = true;
17223 }
17224 }
17225 {
17226 PyThreadState* __tstate = wxPyBeginAllowThreads();
17227 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17228
17229 wxPyEndAllowThreads(__tstate);
17230 if (PyErr_Occurred()) SWIG_fail;
17231 }
17232 {
17233 #if wxUSE_UNICODE
17234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17235 #else
17236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17237 #endif
17238 }
17239 {
17240 if (temp2)
17241 delete arg2;
17242 }
17243 {
17244 if (temp3)
17245 delete arg3;
17246 }
17247 return resultobj;
17248 fail:
17249 {
17250 if (temp2)
17251 delete arg2;
17252 }
17253 {
17254 if (temp3)
17255 delete arg3;
17256 }
17257 return NULL;
17258 }
17259
17260
17261 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17262 PyObject *resultobj;
17263 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17264 wxString *arg2 = 0 ;
17265 long arg3 = (long) 0 ;
17266 long result;
17267 bool temp2 = false ;
17268 PyObject * obj0 = 0 ;
17269 PyObject * obj1 = 0 ;
17270 PyObject * obj2 = 0 ;
17271 char *kwnames[] = {
17272 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17273 };
17274
17275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17277 if (SWIG_arg_fail(1)) SWIG_fail;
17278 {
17279 arg2 = wxString_in_helper(obj1);
17280 if (arg2 == NULL) SWIG_fail;
17281 temp2 = true;
17282 }
17283 if (obj2) {
17284 {
17285 arg3 = (long)(SWIG_As_long(obj2));
17286 if (SWIG_arg_fail(3)) SWIG_fail;
17287 }
17288 }
17289 {
17290 PyThreadState* __tstate = wxPyBeginAllowThreads();
17291 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17292
17293 wxPyEndAllowThreads(__tstate);
17294 if (PyErr_Occurred()) SWIG_fail;
17295 }
17296 {
17297 resultobj = SWIG_From_long((long)(result));
17298 }
17299 {
17300 if (temp2)
17301 delete arg2;
17302 }
17303 return resultobj;
17304 fail:
17305 {
17306 if (temp2)
17307 delete arg2;
17308 }
17309 return NULL;
17310 }
17311
17312
17313 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17314 PyObject *resultobj;
17315 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17316 wxString *arg2 = 0 ;
17317 double arg3 = (double) 0.0 ;
17318 double result;
17319 bool temp2 = false ;
17320 PyObject * obj0 = 0 ;
17321 PyObject * obj1 = 0 ;
17322 PyObject * obj2 = 0 ;
17323 char *kwnames[] = {
17324 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17325 };
17326
17327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17329 if (SWIG_arg_fail(1)) SWIG_fail;
17330 {
17331 arg2 = wxString_in_helper(obj1);
17332 if (arg2 == NULL) SWIG_fail;
17333 temp2 = true;
17334 }
17335 if (obj2) {
17336 {
17337 arg3 = (double)(SWIG_As_double(obj2));
17338 if (SWIG_arg_fail(3)) SWIG_fail;
17339 }
17340 }
17341 {
17342 PyThreadState* __tstate = wxPyBeginAllowThreads();
17343 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17344
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 {
17349 resultobj = SWIG_From_double((double)(result));
17350 }
17351 {
17352 if (temp2)
17353 delete arg2;
17354 }
17355 return resultobj;
17356 fail:
17357 {
17358 if (temp2)
17359 delete arg2;
17360 }
17361 return NULL;
17362 }
17363
17364
17365 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17366 PyObject *resultobj;
17367 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17368 wxString *arg2 = 0 ;
17369 bool arg3 = (bool) false ;
17370 bool result;
17371 bool temp2 = false ;
17372 PyObject * obj0 = 0 ;
17373 PyObject * obj1 = 0 ;
17374 PyObject * obj2 = 0 ;
17375 char *kwnames[] = {
17376 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17377 };
17378
17379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17381 if (SWIG_arg_fail(1)) SWIG_fail;
17382 {
17383 arg2 = wxString_in_helper(obj1);
17384 if (arg2 == NULL) SWIG_fail;
17385 temp2 = true;
17386 }
17387 if (obj2) {
17388 {
17389 arg3 = (bool)(SWIG_As_bool(obj2));
17390 if (SWIG_arg_fail(3)) SWIG_fail;
17391 }
17392 }
17393 {
17394 PyThreadState* __tstate = wxPyBeginAllowThreads();
17395 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17396
17397 wxPyEndAllowThreads(__tstate);
17398 if (PyErr_Occurred()) SWIG_fail;
17399 }
17400 {
17401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17402 }
17403 {
17404 if (temp2)
17405 delete arg2;
17406 }
17407 return resultobj;
17408 fail:
17409 {
17410 if (temp2)
17411 delete arg2;
17412 }
17413 return NULL;
17414 }
17415
17416
17417 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17418 PyObject *resultobj;
17419 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17420 wxString *arg2 = 0 ;
17421 wxString *arg3 = 0 ;
17422 bool result;
17423 bool temp2 = false ;
17424 bool temp3 = false ;
17425 PyObject * obj0 = 0 ;
17426 PyObject * obj1 = 0 ;
17427 PyObject * obj2 = 0 ;
17428 char *kwnames[] = {
17429 (char *) "self",(char *) "key",(char *) "value", NULL
17430 };
17431
17432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17434 if (SWIG_arg_fail(1)) SWIG_fail;
17435 {
17436 arg2 = wxString_in_helper(obj1);
17437 if (arg2 == NULL) SWIG_fail;
17438 temp2 = true;
17439 }
17440 {
17441 arg3 = wxString_in_helper(obj2);
17442 if (arg3 == NULL) SWIG_fail;
17443 temp3 = true;
17444 }
17445 {
17446 PyThreadState* __tstate = wxPyBeginAllowThreads();
17447 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17448
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 {
17453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17454 }
17455 {
17456 if (temp2)
17457 delete arg2;
17458 }
17459 {
17460 if (temp3)
17461 delete arg3;
17462 }
17463 return resultobj;
17464 fail:
17465 {
17466 if (temp2)
17467 delete arg2;
17468 }
17469 {
17470 if (temp3)
17471 delete arg3;
17472 }
17473 return NULL;
17474 }
17475
17476
17477 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17478 PyObject *resultobj;
17479 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17480 wxString *arg2 = 0 ;
17481 long arg3 ;
17482 bool result;
17483 bool temp2 = false ;
17484 PyObject * obj0 = 0 ;
17485 PyObject * obj1 = 0 ;
17486 PyObject * obj2 = 0 ;
17487 char *kwnames[] = {
17488 (char *) "self",(char *) "key",(char *) "value", NULL
17489 };
17490
17491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17493 if (SWIG_arg_fail(1)) SWIG_fail;
17494 {
17495 arg2 = wxString_in_helper(obj1);
17496 if (arg2 == NULL) SWIG_fail;
17497 temp2 = true;
17498 }
17499 {
17500 arg3 = (long)(SWIG_As_long(obj2));
17501 if (SWIG_arg_fail(3)) SWIG_fail;
17502 }
17503 {
17504 PyThreadState* __tstate = wxPyBeginAllowThreads();
17505 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17506
17507 wxPyEndAllowThreads(__tstate);
17508 if (PyErr_Occurred()) SWIG_fail;
17509 }
17510 {
17511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17512 }
17513 {
17514 if (temp2)
17515 delete arg2;
17516 }
17517 return resultobj;
17518 fail:
17519 {
17520 if (temp2)
17521 delete arg2;
17522 }
17523 return NULL;
17524 }
17525
17526
17527 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj;
17529 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17530 wxString *arg2 = 0 ;
17531 double arg3 ;
17532 bool result;
17533 bool temp2 = false ;
17534 PyObject * obj0 = 0 ;
17535 PyObject * obj1 = 0 ;
17536 PyObject * obj2 = 0 ;
17537 char *kwnames[] = {
17538 (char *) "self",(char *) "key",(char *) "value", NULL
17539 };
17540
17541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17543 if (SWIG_arg_fail(1)) SWIG_fail;
17544 {
17545 arg2 = wxString_in_helper(obj1);
17546 if (arg2 == NULL) SWIG_fail;
17547 temp2 = true;
17548 }
17549 {
17550 arg3 = (double)(SWIG_As_double(obj2));
17551 if (SWIG_arg_fail(3)) SWIG_fail;
17552 }
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17556
17557 wxPyEndAllowThreads(__tstate);
17558 if (PyErr_Occurred()) SWIG_fail;
17559 }
17560 {
17561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17562 }
17563 {
17564 if (temp2)
17565 delete arg2;
17566 }
17567 return resultobj;
17568 fail:
17569 {
17570 if (temp2)
17571 delete arg2;
17572 }
17573 return NULL;
17574 }
17575
17576
17577 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17578 PyObject *resultobj;
17579 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17580 wxString *arg2 = 0 ;
17581 bool arg3 ;
17582 bool result;
17583 bool temp2 = false ;
17584 PyObject * obj0 = 0 ;
17585 PyObject * obj1 = 0 ;
17586 PyObject * obj2 = 0 ;
17587 char *kwnames[] = {
17588 (char *) "self",(char *) "key",(char *) "value", NULL
17589 };
17590
17591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17593 if (SWIG_arg_fail(1)) SWIG_fail;
17594 {
17595 arg2 = wxString_in_helper(obj1);
17596 if (arg2 == NULL) SWIG_fail;
17597 temp2 = true;
17598 }
17599 {
17600 arg3 = (bool)(SWIG_As_bool(obj2));
17601 if (SWIG_arg_fail(3)) SWIG_fail;
17602 }
17603 {
17604 PyThreadState* __tstate = wxPyBeginAllowThreads();
17605 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17606
17607 wxPyEndAllowThreads(__tstate);
17608 if (PyErr_Occurred()) SWIG_fail;
17609 }
17610 {
17611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17612 }
17613 {
17614 if (temp2)
17615 delete arg2;
17616 }
17617 return resultobj;
17618 fail:
17619 {
17620 if (temp2)
17621 delete arg2;
17622 }
17623 return NULL;
17624 }
17625
17626
17627 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17628 PyObject *resultobj;
17629 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17630 bool arg2 = (bool) false ;
17631 bool result;
17632 PyObject * obj0 = 0 ;
17633 PyObject * obj1 = 0 ;
17634 char *kwnames[] = {
17635 (char *) "self",(char *) "currentOnly", NULL
17636 };
17637
17638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17640 if (SWIG_arg_fail(1)) SWIG_fail;
17641 if (obj1) {
17642 {
17643 arg2 = (bool)(SWIG_As_bool(obj1));
17644 if (SWIG_arg_fail(2)) SWIG_fail;
17645 }
17646 }
17647 {
17648 PyThreadState* __tstate = wxPyBeginAllowThreads();
17649 result = (bool)(arg1)->Flush(arg2);
17650
17651 wxPyEndAllowThreads(__tstate);
17652 if (PyErr_Occurred()) SWIG_fail;
17653 }
17654 {
17655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17656 }
17657 return resultobj;
17658 fail:
17659 return NULL;
17660 }
17661
17662
17663 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17664 PyObject *resultobj;
17665 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17666 wxString *arg2 = 0 ;
17667 wxString *arg3 = 0 ;
17668 bool result;
17669 bool temp2 = false ;
17670 bool temp3 = false ;
17671 PyObject * obj0 = 0 ;
17672 PyObject * obj1 = 0 ;
17673 PyObject * obj2 = 0 ;
17674 char *kwnames[] = {
17675 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17676 };
17677
17678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17680 if (SWIG_arg_fail(1)) SWIG_fail;
17681 {
17682 arg2 = wxString_in_helper(obj1);
17683 if (arg2 == NULL) SWIG_fail;
17684 temp2 = true;
17685 }
17686 {
17687 arg3 = wxString_in_helper(obj2);
17688 if (arg3 == NULL) SWIG_fail;
17689 temp3 = true;
17690 }
17691 {
17692 PyThreadState* __tstate = wxPyBeginAllowThreads();
17693 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17694
17695 wxPyEndAllowThreads(__tstate);
17696 if (PyErr_Occurred()) SWIG_fail;
17697 }
17698 {
17699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17700 }
17701 {
17702 if (temp2)
17703 delete arg2;
17704 }
17705 {
17706 if (temp3)
17707 delete arg3;
17708 }
17709 return resultobj;
17710 fail:
17711 {
17712 if (temp2)
17713 delete arg2;
17714 }
17715 {
17716 if (temp3)
17717 delete arg3;
17718 }
17719 return NULL;
17720 }
17721
17722
17723 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj;
17725 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17726 wxString *arg2 = 0 ;
17727 wxString *arg3 = 0 ;
17728 bool result;
17729 bool temp2 = false ;
17730 bool temp3 = false ;
17731 PyObject * obj0 = 0 ;
17732 PyObject * obj1 = 0 ;
17733 PyObject * obj2 = 0 ;
17734 char *kwnames[] = {
17735 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17736 };
17737
17738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17740 if (SWIG_arg_fail(1)) SWIG_fail;
17741 {
17742 arg2 = wxString_in_helper(obj1);
17743 if (arg2 == NULL) SWIG_fail;
17744 temp2 = true;
17745 }
17746 {
17747 arg3 = wxString_in_helper(obj2);
17748 if (arg3 == NULL) SWIG_fail;
17749 temp3 = true;
17750 }
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17754
17755 wxPyEndAllowThreads(__tstate);
17756 if (PyErr_Occurred()) SWIG_fail;
17757 }
17758 {
17759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17760 }
17761 {
17762 if (temp2)
17763 delete arg2;
17764 }
17765 {
17766 if (temp3)
17767 delete arg3;
17768 }
17769 return resultobj;
17770 fail:
17771 {
17772 if (temp2)
17773 delete arg2;
17774 }
17775 {
17776 if (temp3)
17777 delete arg3;
17778 }
17779 return NULL;
17780 }
17781
17782
17783 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17784 PyObject *resultobj;
17785 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17786 wxString *arg2 = 0 ;
17787 bool arg3 = (bool) true ;
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 *) "deleteGroupIfEmpty", NULL
17795 };
17796
17797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",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)(arg1)->DeleteEntry((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_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj;
17837 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17838 wxString *arg2 = 0 ;
17839 bool result;
17840 bool temp2 = false ;
17841 PyObject * obj0 = 0 ;
17842 PyObject * obj1 = 0 ;
17843 char *kwnames[] = {
17844 (char *) "self",(char *) "key", NULL
17845 };
17846
17847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17849 if (SWIG_arg_fail(1)) SWIG_fail;
17850 {
17851 arg2 = wxString_in_helper(obj1);
17852 if (arg2 == NULL) SWIG_fail;
17853 temp2 = true;
17854 }
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17858
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 {
17863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17864 }
17865 {
17866 if (temp2)
17867 delete arg2;
17868 }
17869 return resultobj;
17870 fail:
17871 {
17872 if (temp2)
17873 delete arg2;
17874 }
17875 return NULL;
17876 }
17877
17878
17879 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17880 PyObject *resultobj;
17881 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17882 bool result;
17883 PyObject * obj0 = 0 ;
17884 char *kwnames[] = {
17885 (char *) "self", NULL
17886 };
17887
17888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17890 if (SWIG_arg_fail(1)) SWIG_fail;
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (bool)(arg1)->DeleteAll();
17894
17895 wxPyEndAllowThreads(__tstate);
17896 if (PyErr_Occurred()) SWIG_fail;
17897 }
17898 {
17899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17900 }
17901 return resultobj;
17902 fail:
17903 return NULL;
17904 }
17905
17906
17907 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17908 PyObject *resultobj;
17909 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17910 bool arg2 = (bool) true ;
17911 PyObject * obj0 = 0 ;
17912 PyObject * obj1 = 0 ;
17913 char *kwnames[] = {
17914 (char *) "self",(char *) "doIt", NULL
17915 };
17916
17917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17919 if (SWIG_arg_fail(1)) SWIG_fail;
17920 if (obj1) {
17921 {
17922 arg2 = (bool)(SWIG_As_bool(obj1));
17923 if (SWIG_arg_fail(2)) SWIG_fail;
17924 }
17925 }
17926 {
17927 PyThreadState* __tstate = wxPyBeginAllowThreads();
17928 (arg1)->SetExpandEnvVars(arg2);
17929
17930 wxPyEndAllowThreads(__tstate);
17931 if (PyErr_Occurred()) SWIG_fail;
17932 }
17933 Py_INCREF(Py_None); resultobj = Py_None;
17934 return resultobj;
17935 fail:
17936 return NULL;
17937 }
17938
17939
17940 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17941 PyObject *resultobj;
17942 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17943 bool result;
17944 PyObject * obj0 = 0 ;
17945 char *kwnames[] = {
17946 (char *) "self", NULL
17947 };
17948
17949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17951 if (SWIG_arg_fail(1)) SWIG_fail;
17952 {
17953 PyThreadState* __tstate = wxPyBeginAllowThreads();
17954 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17955
17956 wxPyEndAllowThreads(__tstate);
17957 if (PyErr_Occurred()) SWIG_fail;
17958 }
17959 {
17960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17961 }
17962 return resultobj;
17963 fail:
17964 return NULL;
17965 }
17966
17967
17968 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17969 PyObject *resultobj;
17970 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17971 bool arg2 = (bool) true ;
17972 PyObject * obj0 = 0 ;
17973 PyObject * obj1 = 0 ;
17974 char *kwnames[] = {
17975 (char *) "self",(char *) "doIt", NULL
17976 };
17977
17978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17980 if (SWIG_arg_fail(1)) SWIG_fail;
17981 if (obj1) {
17982 {
17983 arg2 = (bool)(SWIG_As_bool(obj1));
17984 if (SWIG_arg_fail(2)) SWIG_fail;
17985 }
17986 }
17987 {
17988 PyThreadState* __tstate = wxPyBeginAllowThreads();
17989 (arg1)->SetRecordDefaults(arg2);
17990
17991 wxPyEndAllowThreads(__tstate);
17992 if (PyErr_Occurred()) SWIG_fail;
17993 }
17994 Py_INCREF(Py_None); resultobj = Py_None;
17995 return resultobj;
17996 fail:
17997 return NULL;
17998 }
17999
18000
18001 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18002 PyObject *resultobj;
18003 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18004 bool result;
18005 PyObject * obj0 = 0 ;
18006 char *kwnames[] = {
18007 (char *) "self", NULL
18008 };
18009
18010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18012 if (SWIG_arg_fail(1)) SWIG_fail;
18013 {
18014 PyThreadState* __tstate = wxPyBeginAllowThreads();
18015 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18016
18017 wxPyEndAllowThreads(__tstate);
18018 if (PyErr_Occurred()) SWIG_fail;
18019 }
18020 {
18021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18022 }
18023 return resultobj;
18024 fail:
18025 return NULL;
18026 }
18027
18028
18029 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18030 PyObject *resultobj;
18031 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18032 wxString *arg2 = 0 ;
18033 wxString result;
18034 bool temp2 = false ;
18035 PyObject * obj0 = 0 ;
18036 PyObject * obj1 = 0 ;
18037 char *kwnames[] = {
18038 (char *) "self",(char *) "str", NULL
18039 };
18040
18041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18043 if (SWIG_arg_fail(1)) SWIG_fail;
18044 {
18045 arg2 = wxString_in_helper(obj1);
18046 if (arg2 == NULL) SWIG_fail;
18047 temp2 = true;
18048 }
18049 {
18050 PyThreadState* __tstate = wxPyBeginAllowThreads();
18051 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18052
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 {
18057 #if wxUSE_UNICODE
18058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18059 #else
18060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18061 #endif
18062 }
18063 {
18064 if (temp2)
18065 delete arg2;
18066 }
18067 return resultobj;
18068 fail:
18069 {
18070 if (temp2)
18071 delete arg2;
18072 }
18073 return NULL;
18074 }
18075
18076
18077 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18078 PyObject *resultobj;
18079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18080 wxString result;
18081 PyObject * obj0 = 0 ;
18082 char *kwnames[] = {
18083 (char *) "self", NULL
18084 };
18085
18086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18088 if (SWIG_arg_fail(1)) SWIG_fail;
18089 {
18090 PyThreadState* __tstate = wxPyBeginAllowThreads();
18091 result = ((wxConfigBase const *)arg1)->GetAppName();
18092
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 {
18097 #if wxUSE_UNICODE
18098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18099 #else
18100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18101 #endif
18102 }
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18110 PyObject *resultobj;
18111 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18112 wxString result;
18113 PyObject * obj0 = 0 ;
18114 char *kwnames[] = {
18115 (char *) "self", NULL
18116 };
18117
18118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18120 if (SWIG_arg_fail(1)) SWIG_fail;
18121 {
18122 PyThreadState* __tstate = wxPyBeginAllowThreads();
18123 result = ((wxConfigBase const *)arg1)->GetVendorName();
18124
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 {
18129 #if wxUSE_UNICODE
18130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18131 #else
18132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18133 #endif
18134 }
18135 return resultobj;
18136 fail:
18137 return NULL;
18138 }
18139
18140
18141 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18142 PyObject *resultobj;
18143 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18144 wxString *arg2 = 0 ;
18145 bool temp2 = false ;
18146 PyObject * obj0 = 0 ;
18147 PyObject * obj1 = 0 ;
18148 char *kwnames[] = {
18149 (char *) "self",(char *) "appName", NULL
18150 };
18151
18152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18154 if (SWIG_arg_fail(1)) SWIG_fail;
18155 {
18156 arg2 = wxString_in_helper(obj1);
18157 if (arg2 == NULL) SWIG_fail;
18158 temp2 = true;
18159 }
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 (arg1)->SetAppName((wxString const &)*arg2);
18163
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 Py_INCREF(Py_None); resultobj = Py_None;
18168 {
18169 if (temp2)
18170 delete arg2;
18171 }
18172 return resultobj;
18173 fail:
18174 {
18175 if (temp2)
18176 delete arg2;
18177 }
18178 return NULL;
18179 }
18180
18181
18182 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18183 PyObject *resultobj;
18184 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18185 wxString *arg2 = 0 ;
18186 bool temp2 = false ;
18187 PyObject * obj0 = 0 ;
18188 PyObject * obj1 = 0 ;
18189 char *kwnames[] = {
18190 (char *) "self",(char *) "vendorName", NULL
18191 };
18192
18193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18195 if (SWIG_arg_fail(1)) SWIG_fail;
18196 {
18197 arg2 = wxString_in_helper(obj1);
18198 if (arg2 == NULL) SWIG_fail;
18199 temp2 = true;
18200 }
18201 {
18202 PyThreadState* __tstate = wxPyBeginAllowThreads();
18203 (arg1)->SetVendorName((wxString const &)*arg2);
18204
18205 wxPyEndAllowThreads(__tstate);
18206 if (PyErr_Occurred()) SWIG_fail;
18207 }
18208 Py_INCREF(Py_None); resultobj = Py_None;
18209 {
18210 if (temp2)
18211 delete arg2;
18212 }
18213 return resultobj;
18214 fail:
18215 {
18216 if (temp2)
18217 delete arg2;
18218 }
18219 return NULL;
18220 }
18221
18222
18223 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18224 PyObject *resultobj;
18225 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18226 long arg2 ;
18227 PyObject * obj0 = 0 ;
18228 PyObject * obj1 = 0 ;
18229 char *kwnames[] = {
18230 (char *) "self",(char *) "style", NULL
18231 };
18232
18233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18235 if (SWIG_arg_fail(1)) SWIG_fail;
18236 {
18237 arg2 = (long)(SWIG_As_long(obj1));
18238 if (SWIG_arg_fail(2)) SWIG_fail;
18239 }
18240 {
18241 PyThreadState* __tstate = wxPyBeginAllowThreads();
18242 (arg1)->SetStyle(arg2);
18243
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 Py_INCREF(Py_None); resultobj = Py_None;
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18255 PyObject *resultobj;
18256 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18257 long result;
18258 PyObject * obj0 = 0 ;
18259 char *kwnames[] = {
18260 (char *) "self", NULL
18261 };
18262
18263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18265 if (SWIG_arg_fail(1)) SWIG_fail;
18266 {
18267 PyThreadState* __tstate = wxPyBeginAllowThreads();
18268 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18269
18270 wxPyEndAllowThreads(__tstate);
18271 if (PyErr_Occurred()) SWIG_fail;
18272 }
18273 {
18274 resultobj = SWIG_From_long((long)(result));
18275 }
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18283 PyObject *obj;
18284 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18285 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18286 Py_INCREF(obj);
18287 return Py_BuildValue((char *)"");
18288 }
18289 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18290 PyObject *resultobj;
18291 wxString const &arg1_defvalue = wxPyEmptyString ;
18292 wxString *arg1 = (wxString *) &arg1_defvalue ;
18293 wxString const &arg2_defvalue = wxPyEmptyString ;
18294 wxString *arg2 = (wxString *) &arg2_defvalue ;
18295 wxString const &arg3_defvalue = wxPyEmptyString ;
18296 wxString *arg3 = (wxString *) &arg3_defvalue ;
18297 wxString const &arg4_defvalue = wxPyEmptyString ;
18298 wxString *arg4 = (wxString *) &arg4_defvalue ;
18299 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18300 wxConfig *result;
18301 bool temp1 = false ;
18302 bool temp2 = false ;
18303 bool temp3 = false ;
18304 bool temp4 = false ;
18305 PyObject * obj0 = 0 ;
18306 PyObject * obj1 = 0 ;
18307 PyObject * obj2 = 0 ;
18308 PyObject * obj3 = 0 ;
18309 PyObject * obj4 = 0 ;
18310 char *kwnames[] = {
18311 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18312 };
18313
18314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18315 if (obj0) {
18316 {
18317 arg1 = wxString_in_helper(obj0);
18318 if (arg1 == NULL) SWIG_fail;
18319 temp1 = true;
18320 }
18321 }
18322 if (obj1) {
18323 {
18324 arg2 = wxString_in_helper(obj1);
18325 if (arg2 == NULL) SWIG_fail;
18326 temp2 = true;
18327 }
18328 }
18329 if (obj2) {
18330 {
18331 arg3 = wxString_in_helper(obj2);
18332 if (arg3 == NULL) SWIG_fail;
18333 temp3 = true;
18334 }
18335 }
18336 if (obj3) {
18337 {
18338 arg4 = wxString_in_helper(obj3);
18339 if (arg4 == NULL) SWIG_fail;
18340 temp4 = true;
18341 }
18342 }
18343 if (obj4) {
18344 {
18345 arg5 = (long)(SWIG_As_long(obj4));
18346 if (SWIG_arg_fail(5)) SWIG_fail;
18347 }
18348 }
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18352
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18357 {
18358 if (temp1)
18359 delete arg1;
18360 }
18361 {
18362 if (temp2)
18363 delete arg2;
18364 }
18365 {
18366 if (temp3)
18367 delete arg3;
18368 }
18369 {
18370 if (temp4)
18371 delete arg4;
18372 }
18373 return resultobj;
18374 fail:
18375 {
18376 if (temp1)
18377 delete arg1;
18378 }
18379 {
18380 if (temp2)
18381 delete arg2;
18382 }
18383 {
18384 if (temp3)
18385 delete arg3;
18386 }
18387 {
18388 if (temp4)
18389 delete arg4;
18390 }
18391 return NULL;
18392 }
18393
18394
18395 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18396 PyObject *resultobj;
18397 wxConfig *arg1 = (wxConfig *) 0 ;
18398 PyObject * obj0 = 0 ;
18399 char *kwnames[] = {
18400 (char *) "self", NULL
18401 };
18402
18403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18405 if (SWIG_arg_fail(1)) SWIG_fail;
18406 {
18407 PyThreadState* __tstate = wxPyBeginAllowThreads();
18408 delete arg1;
18409
18410 wxPyEndAllowThreads(__tstate);
18411 if (PyErr_Occurred()) SWIG_fail;
18412 }
18413 Py_INCREF(Py_None); resultobj = Py_None;
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18421 PyObject *obj;
18422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18423 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18424 Py_INCREF(obj);
18425 return Py_BuildValue((char *)"");
18426 }
18427 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj;
18429 wxString const &arg1_defvalue = wxPyEmptyString ;
18430 wxString *arg1 = (wxString *) &arg1_defvalue ;
18431 wxString const &arg2_defvalue = wxPyEmptyString ;
18432 wxString *arg2 = (wxString *) &arg2_defvalue ;
18433 wxString const &arg3_defvalue = wxPyEmptyString ;
18434 wxString *arg3 = (wxString *) &arg3_defvalue ;
18435 wxString const &arg4_defvalue = wxPyEmptyString ;
18436 wxString *arg4 = (wxString *) &arg4_defvalue ;
18437 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18438 wxFileConfig *result;
18439 bool temp1 = false ;
18440 bool temp2 = false ;
18441 bool temp3 = false ;
18442 bool temp4 = false ;
18443 PyObject * obj0 = 0 ;
18444 PyObject * obj1 = 0 ;
18445 PyObject * obj2 = 0 ;
18446 PyObject * obj3 = 0 ;
18447 PyObject * obj4 = 0 ;
18448 char *kwnames[] = {
18449 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18450 };
18451
18452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18453 if (obj0) {
18454 {
18455 arg1 = wxString_in_helper(obj0);
18456 if (arg1 == NULL) SWIG_fail;
18457 temp1 = true;
18458 }
18459 }
18460 if (obj1) {
18461 {
18462 arg2 = wxString_in_helper(obj1);
18463 if (arg2 == NULL) SWIG_fail;
18464 temp2 = true;
18465 }
18466 }
18467 if (obj2) {
18468 {
18469 arg3 = wxString_in_helper(obj2);
18470 if (arg3 == NULL) SWIG_fail;
18471 temp3 = true;
18472 }
18473 }
18474 if (obj3) {
18475 {
18476 arg4 = wxString_in_helper(obj3);
18477 if (arg4 == NULL) SWIG_fail;
18478 temp4 = true;
18479 }
18480 }
18481 if (obj4) {
18482 {
18483 arg5 = (long)(SWIG_As_long(obj4));
18484 if (SWIG_arg_fail(5)) SWIG_fail;
18485 }
18486 }
18487 {
18488 PyThreadState* __tstate = wxPyBeginAllowThreads();
18489 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18490
18491 wxPyEndAllowThreads(__tstate);
18492 if (PyErr_Occurred()) SWIG_fail;
18493 }
18494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18495 {
18496 if (temp1)
18497 delete arg1;
18498 }
18499 {
18500 if (temp2)
18501 delete arg2;
18502 }
18503 {
18504 if (temp3)
18505 delete arg3;
18506 }
18507 {
18508 if (temp4)
18509 delete arg4;
18510 }
18511 return resultobj;
18512 fail:
18513 {
18514 if (temp1)
18515 delete arg1;
18516 }
18517 {
18518 if (temp2)
18519 delete arg2;
18520 }
18521 {
18522 if (temp3)
18523 delete arg3;
18524 }
18525 {
18526 if (temp4)
18527 delete arg4;
18528 }
18529 return NULL;
18530 }
18531
18532
18533 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18534 PyObject *resultobj;
18535 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18536 PyObject * obj0 = 0 ;
18537 char *kwnames[] = {
18538 (char *) "self", NULL
18539 };
18540
18541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18543 if (SWIG_arg_fail(1)) SWIG_fail;
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 delete arg1;
18547
18548 wxPyEndAllowThreads(__tstate);
18549 if (PyErr_Occurred()) SWIG_fail;
18550 }
18551 Py_INCREF(Py_None); resultobj = Py_None;
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18559 PyObject *obj;
18560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18561 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18562 Py_INCREF(obj);
18563 return Py_BuildValue((char *)"");
18564 }
18565 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18566 PyObject *resultobj;
18567 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18568 wxString *arg2 = 0 ;
18569 wxConfigPathChanger *result;
18570 bool temp2 = false ;
18571 PyObject * obj0 = 0 ;
18572 PyObject * obj1 = 0 ;
18573 char *kwnames[] = {
18574 (char *) "config",(char *) "entry", NULL
18575 };
18576
18577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18579 if (SWIG_arg_fail(1)) SWIG_fail;
18580 {
18581 arg2 = wxString_in_helper(obj1);
18582 if (arg2 == NULL) SWIG_fail;
18583 temp2 = true;
18584 }
18585 {
18586 PyThreadState* __tstate = wxPyBeginAllowThreads();
18587 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18588
18589 wxPyEndAllowThreads(__tstate);
18590 if (PyErr_Occurred()) SWIG_fail;
18591 }
18592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18593 {
18594 if (temp2)
18595 delete arg2;
18596 }
18597 return resultobj;
18598 fail:
18599 {
18600 if (temp2)
18601 delete arg2;
18602 }
18603 return NULL;
18604 }
18605
18606
18607 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18608 PyObject *resultobj;
18609 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18610 PyObject * obj0 = 0 ;
18611 char *kwnames[] = {
18612 (char *) "self", NULL
18613 };
18614
18615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18617 if (SWIG_arg_fail(1)) SWIG_fail;
18618 {
18619 PyThreadState* __tstate = wxPyBeginAllowThreads();
18620 delete arg1;
18621
18622 wxPyEndAllowThreads(__tstate);
18623 if (PyErr_Occurred()) SWIG_fail;
18624 }
18625 Py_INCREF(Py_None); resultobj = Py_None;
18626 return resultobj;
18627 fail:
18628 return NULL;
18629 }
18630
18631
18632 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18633 PyObject *resultobj;
18634 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18635 wxString *result;
18636 PyObject * obj0 = 0 ;
18637 char *kwnames[] = {
18638 (char *) "self", NULL
18639 };
18640
18641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18643 if (SWIG_arg_fail(1)) SWIG_fail;
18644 {
18645 PyThreadState* __tstate = wxPyBeginAllowThreads();
18646 {
18647 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18648 result = (wxString *) &_result_ref;
18649 }
18650
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 {
18655 #if wxUSE_UNICODE
18656 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18657 #else
18658 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18659 #endif
18660 }
18661 return resultobj;
18662 fail:
18663 return NULL;
18664 }
18665
18666
18667 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18668 PyObject *obj;
18669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18670 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18671 Py_INCREF(obj);
18672 return Py_BuildValue((char *)"");
18673 }
18674 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj;
18676 wxString *arg1 = 0 ;
18677 wxString result;
18678 bool temp1 = false ;
18679 PyObject * obj0 = 0 ;
18680 char *kwnames[] = {
18681 (char *) "sz", NULL
18682 };
18683
18684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18685 {
18686 arg1 = wxString_in_helper(obj0);
18687 if (arg1 == NULL) SWIG_fail;
18688 temp1 = true;
18689 }
18690 {
18691 PyThreadState* __tstate = wxPyBeginAllowThreads();
18692 result = wxExpandEnvVars((wxString const &)*arg1);
18693
18694 wxPyEndAllowThreads(__tstate);
18695 if (PyErr_Occurred()) SWIG_fail;
18696 }
18697 {
18698 #if wxUSE_UNICODE
18699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18700 #else
18701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18702 #endif
18703 }
18704 {
18705 if (temp1)
18706 delete arg1;
18707 }
18708 return resultobj;
18709 fail:
18710 {
18711 if (temp1)
18712 delete arg1;
18713 }
18714 return NULL;
18715 }
18716
18717
18718 static int _wrap_DateFormatStr_set(PyObject *) {
18719 PyErr_SetString(PyExc_TypeError,"Variable DateFormatStr is read-only.");
18720 return 1;
18721 }
18722
18723
18724 static PyObject *_wrap_DateFormatStr_get(void) {
18725 PyObject *pyobj;
18726
18727 {
18728 #if wxUSE_UNICODE
18729 pyobj = PyUnicode_FromWideChar((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18730 #else
18731 pyobj = PyString_FromStringAndSize((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18732 #endif
18733 }
18734 return pyobj;
18735 }
18736
18737
18738 static int _wrap_TimeSpanFormatStr_set(PyObject *) {
18739 PyErr_SetString(PyExc_TypeError,"Variable TimeSpanFormatStr is read-only.");
18740 return 1;
18741 }
18742
18743
18744 static PyObject *_wrap_TimeSpanFormatStr_get(void) {
18745 PyObject *pyobj;
18746
18747 {
18748 #if wxUSE_UNICODE
18749 pyobj = PyUnicode_FromWideChar((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18750 #else
18751 pyobj = PyString_FromStringAndSize((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18752 #endif
18753 }
18754 return pyobj;
18755 }
18756
18757
18758 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18759 PyObject *resultobj;
18760 wxDateTime::Country arg1 ;
18761 PyObject * obj0 = 0 ;
18762 char *kwnames[] = {
18763 (char *) "country", NULL
18764 };
18765
18766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18767 {
18768 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18769 if (SWIG_arg_fail(1)) SWIG_fail;
18770 }
18771 {
18772 PyThreadState* __tstate = wxPyBeginAllowThreads();
18773 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18774
18775 wxPyEndAllowThreads(__tstate);
18776 if (PyErr_Occurred()) SWIG_fail;
18777 }
18778 Py_INCREF(Py_None); resultobj = Py_None;
18779 return resultobj;
18780 fail:
18781 return NULL;
18782 }
18783
18784
18785 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18786 PyObject *resultobj;
18787 wxDateTime::Country result;
18788 char *kwnames[] = {
18789 NULL
18790 };
18791
18792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18793 {
18794 PyThreadState* __tstate = wxPyBeginAllowThreads();
18795 result = (wxDateTime::Country)wxDateTime::GetCountry();
18796
18797 wxPyEndAllowThreads(__tstate);
18798 if (PyErr_Occurred()) SWIG_fail;
18799 }
18800 resultobj = SWIG_From_int((result));
18801 return resultobj;
18802 fail:
18803 return NULL;
18804 }
18805
18806
18807 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18808 PyObject *resultobj;
18809 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18810 bool result;
18811 PyObject * obj0 = 0 ;
18812 char *kwnames[] = {
18813 (char *) "country", NULL
18814 };
18815
18816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18817 if (obj0) {
18818 {
18819 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18820 if (SWIG_arg_fail(1)) SWIG_fail;
18821 }
18822 }
18823 {
18824 PyThreadState* __tstate = wxPyBeginAllowThreads();
18825 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18826
18827 wxPyEndAllowThreads(__tstate);
18828 if (PyErr_Occurred()) SWIG_fail;
18829 }
18830 {
18831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18832 }
18833 return resultobj;
18834 fail:
18835 return NULL;
18836 }
18837
18838
18839 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18840 PyObject *resultobj;
18841 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18842 int result;
18843 PyObject * obj0 = 0 ;
18844 char *kwnames[] = {
18845 (char *) "cal", NULL
18846 };
18847
18848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18849 if (obj0) {
18850 {
18851 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18852 if (SWIG_arg_fail(1)) SWIG_fail;
18853 }
18854 }
18855 {
18856 PyThreadState* __tstate = wxPyBeginAllowThreads();
18857 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18858
18859 wxPyEndAllowThreads(__tstate);
18860 if (PyErr_Occurred()) SWIG_fail;
18861 }
18862 {
18863 resultobj = SWIG_From_int((int)(result));
18864 }
18865 return resultobj;
18866 fail:
18867 return NULL;
18868 }
18869
18870
18871 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18872 PyObject *resultobj;
18873 int arg1 ;
18874 int result;
18875 PyObject * obj0 = 0 ;
18876 char *kwnames[] = {
18877 (char *) "year", NULL
18878 };
18879
18880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18881 {
18882 arg1 = (int)(SWIG_As_int(obj0));
18883 if (SWIG_arg_fail(1)) SWIG_fail;
18884 }
18885 {
18886 PyThreadState* __tstate = wxPyBeginAllowThreads();
18887 result = (int)wxDateTime::ConvertYearToBC(arg1);
18888
18889 wxPyEndAllowThreads(__tstate);
18890 if (PyErr_Occurred()) SWIG_fail;
18891 }
18892 {
18893 resultobj = SWIG_From_int((int)(result));
18894 }
18895 return resultobj;
18896 fail:
18897 return NULL;
18898 }
18899
18900
18901 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18902 PyObject *resultobj;
18903 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18904 wxDateTime::Month result;
18905 PyObject * obj0 = 0 ;
18906 char *kwnames[] = {
18907 (char *) "cal", NULL
18908 };
18909
18910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18911 if (obj0) {
18912 {
18913 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18914 if (SWIG_arg_fail(1)) SWIG_fail;
18915 }
18916 }
18917 {
18918 PyThreadState* __tstate = wxPyBeginAllowThreads();
18919 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18920
18921 wxPyEndAllowThreads(__tstate);
18922 if (PyErr_Occurred()) SWIG_fail;
18923 }
18924 resultobj = SWIG_From_int((result));
18925 return resultobj;
18926 fail:
18927 return NULL;
18928 }
18929
18930
18931 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18932 PyObject *resultobj;
18933 int arg1 = (int) wxDateTime::Inv_Year ;
18934 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18935 bool result;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 char *kwnames[] = {
18939 (char *) "year",(char *) "cal", NULL
18940 };
18941
18942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18943 if (obj0) {
18944 {
18945 arg1 = (int)(SWIG_As_int(obj0));
18946 if (SWIG_arg_fail(1)) SWIG_fail;
18947 }
18948 }
18949 if (obj1) {
18950 {
18951 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18952 if (SWIG_arg_fail(2)) SWIG_fail;
18953 }
18954 }
18955 {
18956 PyThreadState* __tstate = wxPyBeginAllowThreads();
18957 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18958
18959 wxPyEndAllowThreads(__tstate);
18960 if (PyErr_Occurred()) SWIG_fail;
18961 }
18962 {
18963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18964 }
18965 return resultobj;
18966 fail:
18967 return NULL;
18968 }
18969
18970
18971 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18972 PyObject *resultobj;
18973 int arg1 = (int) wxDateTime::Inv_Year ;
18974 int result;
18975 PyObject * obj0 = 0 ;
18976 char *kwnames[] = {
18977 (char *) "year", NULL
18978 };
18979
18980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18981 if (obj0) {
18982 {
18983 arg1 = (int)(SWIG_As_int(obj0));
18984 if (SWIG_arg_fail(1)) SWIG_fail;
18985 }
18986 }
18987 {
18988 PyThreadState* __tstate = wxPyBeginAllowThreads();
18989 result = (int)wxDateTime::GetCentury(arg1);
18990
18991 wxPyEndAllowThreads(__tstate);
18992 if (PyErr_Occurred()) SWIG_fail;
18993 }
18994 {
18995 resultobj = SWIG_From_int((int)(result));
18996 }
18997 return resultobj;
18998 fail:
18999 return NULL;
19000 }
19001
19002
19003 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19004 PyObject *resultobj;
19005 int arg1 ;
19006 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19007 int result;
19008 PyObject * obj0 = 0 ;
19009 PyObject * obj1 = 0 ;
19010 char *kwnames[] = {
19011 (char *) "year",(char *) "cal", NULL
19012 };
19013
19014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19015 {
19016 arg1 = (int)(SWIG_As_int(obj0));
19017 if (SWIG_arg_fail(1)) SWIG_fail;
19018 }
19019 if (obj1) {
19020 {
19021 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19022 if (SWIG_arg_fail(2)) SWIG_fail;
19023 }
19024 }
19025 {
19026 PyThreadState* __tstate = wxPyBeginAllowThreads();
19027 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19028
19029 wxPyEndAllowThreads(__tstate);
19030 if (PyErr_Occurred()) SWIG_fail;
19031 }
19032 {
19033 resultobj = SWIG_From_int((int)(result));
19034 }
19035 return resultobj;
19036 fail:
19037 return NULL;
19038 }
19039
19040
19041 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19042 PyObject *resultobj;
19043 wxDateTime::Month arg1 ;
19044 int arg2 = (int) wxDateTime::Inv_Year ;
19045 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19046 int result;
19047 PyObject * obj0 = 0 ;
19048 PyObject * obj1 = 0 ;
19049 PyObject * obj2 = 0 ;
19050 char *kwnames[] = {
19051 (char *) "month",(char *) "year",(char *) "cal", NULL
19052 };
19053
19054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19055 {
19056 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19057 if (SWIG_arg_fail(1)) SWIG_fail;
19058 }
19059 if (obj1) {
19060 {
19061 arg2 = (int)(SWIG_As_int(obj1));
19062 if (SWIG_arg_fail(2)) SWIG_fail;
19063 }
19064 }
19065 if (obj2) {
19066 {
19067 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19068 if (SWIG_arg_fail(3)) SWIG_fail;
19069 }
19070 }
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19074
19075 wxPyEndAllowThreads(__tstate);
19076 if (PyErr_Occurred()) SWIG_fail;
19077 }
19078 {
19079 resultobj = SWIG_From_int((int)(result));
19080 }
19081 return resultobj;
19082 fail:
19083 return NULL;
19084 }
19085
19086
19087 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19088 PyObject *resultobj;
19089 wxDateTime::Month arg1 ;
19090 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19091 wxString result;
19092 PyObject * obj0 = 0 ;
19093 PyObject * obj1 = 0 ;
19094 char *kwnames[] = {
19095 (char *) "month",(char *) "flags", NULL
19096 };
19097
19098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19099 {
19100 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19101 if (SWIG_arg_fail(1)) SWIG_fail;
19102 }
19103 if (obj1) {
19104 {
19105 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19106 if (SWIG_arg_fail(2)) SWIG_fail;
19107 }
19108 }
19109 {
19110 PyThreadState* __tstate = wxPyBeginAllowThreads();
19111 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19112
19113 wxPyEndAllowThreads(__tstate);
19114 if (PyErr_Occurred()) SWIG_fail;
19115 }
19116 {
19117 #if wxUSE_UNICODE
19118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19119 #else
19120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19121 #endif
19122 }
19123 return resultobj;
19124 fail:
19125 return NULL;
19126 }
19127
19128
19129 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19130 PyObject *resultobj;
19131 wxDateTime::WeekDay arg1 ;
19132 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19133 wxString result;
19134 PyObject * obj0 = 0 ;
19135 PyObject * obj1 = 0 ;
19136 char *kwnames[] = {
19137 (char *) "weekday",(char *) "flags", NULL
19138 };
19139
19140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19141 {
19142 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19143 if (SWIG_arg_fail(1)) SWIG_fail;
19144 }
19145 if (obj1) {
19146 {
19147 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19148 if (SWIG_arg_fail(2)) SWIG_fail;
19149 }
19150 }
19151 {
19152 PyThreadState* __tstate = wxPyBeginAllowThreads();
19153 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19154
19155 wxPyEndAllowThreads(__tstate);
19156 if (PyErr_Occurred()) SWIG_fail;
19157 }
19158 {
19159 #if wxUSE_UNICODE
19160 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19161 #else
19162 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19163 #endif
19164 }
19165 return resultobj;
19166 fail:
19167 return NULL;
19168 }
19169
19170
19171 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19172 PyObject *resultobj;
19173 wxString *arg1 = (wxString *) 0 ;
19174 wxString *arg2 = (wxString *) 0 ;
19175 bool temp1 = false ;
19176 bool temp2 = false ;
19177 PyObject * obj0 = 0 ;
19178 PyObject * obj1 = 0 ;
19179 char *kwnames[] = {
19180 (char *) "OUTPUT",(char *) "OUTPUT", NULL
19181 };
19182
19183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
19184 {
19185 arg1 = wxString_in_helper(obj0);
19186 if (arg1 == NULL) SWIG_fail;
19187 temp1 = true;
19188 }
19189 {
19190 arg2 = wxString_in_helper(obj1);
19191 if (arg2 == NULL) SWIG_fail;
19192 temp2 = true;
19193 }
19194 {
19195 PyThreadState* __tstate = wxPyBeginAllowThreads();
19196 wxDateTime::GetAmPmStrings(arg1,arg2);
19197
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 Py_INCREF(Py_None); resultobj = Py_None;
19202 {
19203 if (temp1)
19204 delete arg1;
19205 }
19206 {
19207 if (temp2)
19208 delete arg2;
19209 }
19210 return resultobj;
19211 fail:
19212 {
19213 if (temp1)
19214 delete arg1;
19215 }
19216 {
19217 if (temp2)
19218 delete arg2;
19219 }
19220 return NULL;
19221 }
19222
19223
19224 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19225 PyObject *resultobj;
19226 int arg1 = (int) wxDateTime::Inv_Year ;
19227 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19228 bool result;
19229 PyObject * obj0 = 0 ;
19230 PyObject * obj1 = 0 ;
19231 char *kwnames[] = {
19232 (char *) "year",(char *) "country", NULL
19233 };
19234
19235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19236 if (obj0) {
19237 {
19238 arg1 = (int)(SWIG_As_int(obj0));
19239 if (SWIG_arg_fail(1)) SWIG_fail;
19240 }
19241 }
19242 if (obj1) {
19243 {
19244 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19245 if (SWIG_arg_fail(2)) SWIG_fail;
19246 }
19247 }
19248 {
19249 PyThreadState* __tstate = wxPyBeginAllowThreads();
19250 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19251
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 {
19256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19257 }
19258 return resultobj;
19259 fail:
19260 return NULL;
19261 }
19262
19263
19264 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19265 PyObject *resultobj;
19266 int arg1 = (int) wxDateTime::Inv_Year ;
19267 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19268 wxDateTime result;
19269 PyObject * obj0 = 0 ;
19270 PyObject * obj1 = 0 ;
19271 char *kwnames[] = {
19272 (char *) "year",(char *) "country", NULL
19273 };
19274
19275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19276 if (obj0) {
19277 {
19278 arg1 = (int)(SWIG_As_int(obj0));
19279 if (SWIG_arg_fail(1)) SWIG_fail;
19280 }
19281 }
19282 if (obj1) {
19283 {
19284 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19285 if (SWIG_arg_fail(2)) SWIG_fail;
19286 }
19287 }
19288 {
19289 PyThreadState* __tstate = wxPyBeginAllowThreads();
19290 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19291
19292 wxPyEndAllowThreads(__tstate);
19293 if (PyErr_Occurred()) SWIG_fail;
19294 }
19295 {
19296 wxDateTime * resultptr;
19297 resultptr = new wxDateTime((wxDateTime &)(result));
19298 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19299 }
19300 return resultobj;
19301 fail:
19302 return NULL;
19303 }
19304
19305
19306 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19307 PyObject *resultobj;
19308 int arg1 = (int) wxDateTime::Inv_Year ;
19309 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19310 wxDateTime result;
19311 PyObject * obj0 = 0 ;
19312 PyObject * obj1 = 0 ;
19313 char *kwnames[] = {
19314 (char *) "year",(char *) "country", NULL
19315 };
19316
19317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19318 if (obj0) {
19319 {
19320 arg1 = (int)(SWIG_As_int(obj0));
19321 if (SWIG_arg_fail(1)) SWIG_fail;
19322 }
19323 }
19324 if (obj1) {
19325 {
19326 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19327 if (SWIG_arg_fail(2)) SWIG_fail;
19328 }
19329 }
19330 {
19331 PyThreadState* __tstate = wxPyBeginAllowThreads();
19332 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19333
19334 wxPyEndAllowThreads(__tstate);
19335 if (PyErr_Occurred()) SWIG_fail;
19336 }
19337 {
19338 wxDateTime * resultptr;
19339 resultptr = new wxDateTime((wxDateTime &)(result));
19340 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19341 }
19342 return resultobj;
19343 fail:
19344 return NULL;
19345 }
19346
19347
19348 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19349 PyObject *resultobj;
19350 wxDateTime result;
19351 char *kwnames[] = {
19352 NULL
19353 };
19354
19355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19356 {
19357 PyThreadState* __tstate = wxPyBeginAllowThreads();
19358 result = wxDateTime::Now();
19359
19360 wxPyEndAllowThreads(__tstate);
19361 if (PyErr_Occurred()) SWIG_fail;
19362 }
19363 {
19364 wxDateTime * resultptr;
19365 resultptr = new wxDateTime((wxDateTime &)(result));
19366 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19367 }
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19375 PyObject *resultobj;
19376 wxDateTime result;
19377 char *kwnames[] = {
19378 NULL
19379 };
19380
19381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19382 {
19383 PyThreadState* __tstate = wxPyBeginAllowThreads();
19384 result = wxDateTime::UNow();
19385
19386 wxPyEndAllowThreads(__tstate);
19387 if (PyErr_Occurred()) SWIG_fail;
19388 }
19389 {
19390 wxDateTime * resultptr;
19391 resultptr = new wxDateTime((wxDateTime &)(result));
19392 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19393 }
19394 return resultobj;
19395 fail:
19396 return NULL;
19397 }
19398
19399
19400 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19401 PyObject *resultobj;
19402 wxDateTime result;
19403 char *kwnames[] = {
19404 NULL
19405 };
19406
19407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19408 {
19409 PyThreadState* __tstate = wxPyBeginAllowThreads();
19410 result = wxDateTime::Today();
19411
19412 wxPyEndAllowThreads(__tstate);
19413 if (PyErr_Occurred()) SWIG_fail;
19414 }
19415 {
19416 wxDateTime * resultptr;
19417 resultptr = new wxDateTime((wxDateTime &)(result));
19418 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19419 }
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19427 PyObject *resultobj;
19428 wxDateTime *result;
19429 char *kwnames[] = {
19430 NULL
19431 };
19432
19433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 result = (wxDateTime *)new wxDateTime();
19437
19438 wxPyEndAllowThreads(__tstate);
19439 if (PyErr_Occurred()) SWIG_fail;
19440 }
19441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19449 PyObject *resultobj;
19450 time_t arg1 ;
19451 wxDateTime *result;
19452 PyObject * obj0 = 0 ;
19453 char *kwnames[] = {
19454 (char *) "timet", NULL
19455 };
19456
19457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19458 {
19459 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19460 if (SWIG_arg_fail(1)) SWIG_fail;
19461 }
19462 {
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 result = (wxDateTime *)new wxDateTime(arg1);
19465
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19470 return resultobj;
19471 fail:
19472 return NULL;
19473 }
19474
19475
19476 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19477 PyObject *resultobj;
19478 double arg1 ;
19479 wxDateTime *result;
19480 PyObject * obj0 = 0 ;
19481 char *kwnames[] = {
19482 (char *) "jdn", NULL
19483 };
19484
19485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19486 {
19487 arg1 = (double)(SWIG_As_double(obj0));
19488 if (SWIG_arg_fail(1)) SWIG_fail;
19489 }
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 result = (wxDateTime *)new wxDateTime(arg1);
19493
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19498 return resultobj;
19499 fail:
19500 return NULL;
19501 }
19502
19503
19504 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19505 PyObject *resultobj;
19506 int arg1 ;
19507 int arg2 = (int) 0 ;
19508 int arg3 = (int) 0 ;
19509 int arg4 = (int) 0 ;
19510 wxDateTime *result;
19511 PyObject * obj0 = 0 ;
19512 PyObject * obj1 = 0 ;
19513 PyObject * obj2 = 0 ;
19514 PyObject * obj3 = 0 ;
19515 char *kwnames[] = {
19516 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19517 };
19518
19519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19520 {
19521 arg1 = (int)(SWIG_As_int(obj0));
19522 if (SWIG_arg_fail(1)) SWIG_fail;
19523 }
19524 if (obj1) {
19525 {
19526 arg2 = (int)(SWIG_As_int(obj1));
19527 if (SWIG_arg_fail(2)) SWIG_fail;
19528 }
19529 }
19530 if (obj2) {
19531 {
19532 arg3 = (int)(SWIG_As_int(obj2));
19533 if (SWIG_arg_fail(3)) SWIG_fail;
19534 }
19535 }
19536 if (obj3) {
19537 {
19538 arg4 = (int)(SWIG_As_int(obj3));
19539 if (SWIG_arg_fail(4)) SWIG_fail;
19540 }
19541 }
19542 {
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19545
19546 wxPyEndAllowThreads(__tstate);
19547 if (PyErr_Occurred()) SWIG_fail;
19548 }
19549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19557 PyObject *resultobj;
19558 int arg1 ;
19559 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19560 int arg3 = (int) wxDateTime::Inv_Year ;
19561 int arg4 = (int) 0 ;
19562 int arg5 = (int) 0 ;
19563 int arg6 = (int) 0 ;
19564 int arg7 = (int) 0 ;
19565 wxDateTime *result;
19566 PyObject * obj0 = 0 ;
19567 PyObject * obj1 = 0 ;
19568 PyObject * obj2 = 0 ;
19569 PyObject * obj3 = 0 ;
19570 PyObject * obj4 = 0 ;
19571 PyObject * obj5 = 0 ;
19572 PyObject * obj6 = 0 ;
19573 char *kwnames[] = {
19574 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19575 };
19576
19577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19578 {
19579 arg1 = (int)(SWIG_As_int(obj0));
19580 if (SWIG_arg_fail(1)) SWIG_fail;
19581 }
19582 if (obj1) {
19583 {
19584 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19585 if (SWIG_arg_fail(2)) SWIG_fail;
19586 }
19587 }
19588 if (obj2) {
19589 {
19590 arg3 = (int)(SWIG_As_int(obj2));
19591 if (SWIG_arg_fail(3)) SWIG_fail;
19592 }
19593 }
19594 if (obj3) {
19595 {
19596 arg4 = (int)(SWIG_As_int(obj3));
19597 if (SWIG_arg_fail(4)) SWIG_fail;
19598 }
19599 }
19600 if (obj4) {
19601 {
19602 arg5 = (int)(SWIG_As_int(obj4));
19603 if (SWIG_arg_fail(5)) SWIG_fail;
19604 }
19605 }
19606 if (obj5) {
19607 {
19608 arg6 = (int)(SWIG_As_int(obj5));
19609 if (SWIG_arg_fail(6)) SWIG_fail;
19610 }
19611 }
19612 if (obj6) {
19613 {
19614 arg7 = (int)(SWIG_As_int(obj6));
19615 if (SWIG_arg_fail(7)) SWIG_fail;
19616 }
19617 }
19618 {
19619 PyThreadState* __tstate = wxPyBeginAllowThreads();
19620 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19621
19622 wxPyEndAllowThreads(__tstate);
19623 if (PyErr_Occurred()) SWIG_fail;
19624 }
19625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19626 return resultobj;
19627 fail:
19628 return NULL;
19629 }
19630
19631
19632 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19633 PyObject *resultobj;
19634 wxDateTime *arg1 = (wxDateTime *) 0 ;
19635 PyObject * obj0 = 0 ;
19636 char *kwnames[] = {
19637 (char *) "self", NULL
19638 };
19639
19640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19642 if (SWIG_arg_fail(1)) SWIG_fail;
19643 {
19644 PyThreadState* __tstate = wxPyBeginAllowThreads();
19645 delete arg1;
19646
19647 wxPyEndAllowThreads(__tstate);
19648 if (PyErr_Occurred()) SWIG_fail;
19649 }
19650 Py_INCREF(Py_None); resultobj = Py_None;
19651 return resultobj;
19652 fail:
19653 return NULL;
19654 }
19655
19656
19657 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19658 PyObject *resultobj;
19659 wxDateTime *arg1 = (wxDateTime *) 0 ;
19660 wxDateTime *result;
19661 PyObject * obj0 = 0 ;
19662 char *kwnames[] = {
19663 (char *) "self", NULL
19664 };
19665
19666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19668 if (SWIG_arg_fail(1)) SWIG_fail;
19669 {
19670 PyThreadState* __tstate = wxPyBeginAllowThreads();
19671 {
19672 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19673 result = (wxDateTime *) &_result_ref;
19674 }
19675
19676 wxPyEndAllowThreads(__tstate);
19677 if (PyErr_Occurred()) SWIG_fail;
19678 }
19679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19680 return resultobj;
19681 fail:
19682 return NULL;
19683 }
19684
19685
19686 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19687 PyObject *resultobj;
19688 wxDateTime *arg1 = (wxDateTime *) 0 ;
19689 time_t arg2 ;
19690 wxDateTime *result;
19691 PyObject * obj0 = 0 ;
19692 PyObject * obj1 = 0 ;
19693 char *kwnames[] = {
19694 (char *) "self",(char *) "timet", NULL
19695 };
19696
19697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19699 if (SWIG_arg_fail(1)) SWIG_fail;
19700 {
19701 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19702 if (SWIG_arg_fail(2)) SWIG_fail;
19703 }
19704 {
19705 PyThreadState* __tstate = wxPyBeginAllowThreads();
19706 {
19707 wxDateTime &_result_ref = (arg1)->Set(arg2);
19708 result = (wxDateTime *) &_result_ref;
19709 }
19710
19711 wxPyEndAllowThreads(__tstate);
19712 if (PyErr_Occurred()) SWIG_fail;
19713 }
19714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19715 return resultobj;
19716 fail:
19717 return NULL;
19718 }
19719
19720
19721 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19722 PyObject *resultobj;
19723 wxDateTime *arg1 = (wxDateTime *) 0 ;
19724 double arg2 ;
19725 wxDateTime *result;
19726 PyObject * obj0 = 0 ;
19727 PyObject * obj1 = 0 ;
19728 char *kwnames[] = {
19729 (char *) "self",(char *) "jdn", NULL
19730 };
19731
19732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19734 if (SWIG_arg_fail(1)) SWIG_fail;
19735 {
19736 arg2 = (double)(SWIG_As_double(obj1));
19737 if (SWIG_arg_fail(2)) SWIG_fail;
19738 }
19739 {
19740 PyThreadState* __tstate = wxPyBeginAllowThreads();
19741 {
19742 wxDateTime &_result_ref = (arg1)->Set(arg2);
19743 result = (wxDateTime *) &_result_ref;
19744 }
19745
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj;
19758 wxDateTime *arg1 = (wxDateTime *) 0 ;
19759 int arg2 ;
19760 int arg3 = (int) 0 ;
19761 int arg4 = (int) 0 ;
19762 int arg5 = (int) 0 ;
19763 wxDateTime *result;
19764 PyObject * obj0 = 0 ;
19765 PyObject * obj1 = 0 ;
19766 PyObject * obj2 = 0 ;
19767 PyObject * obj3 = 0 ;
19768 PyObject * obj4 = 0 ;
19769 char *kwnames[] = {
19770 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19771 };
19772
19773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19775 if (SWIG_arg_fail(1)) SWIG_fail;
19776 {
19777 arg2 = (int)(SWIG_As_int(obj1));
19778 if (SWIG_arg_fail(2)) SWIG_fail;
19779 }
19780 if (obj2) {
19781 {
19782 arg3 = (int)(SWIG_As_int(obj2));
19783 if (SWIG_arg_fail(3)) SWIG_fail;
19784 }
19785 }
19786 if (obj3) {
19787 {
19788 arg4 = (int)(SWIG_As_int(obj3));
19789 if (SWIG_arg_fail(4)) SWIG_fail;
19790 }
19791 }
19792 if (obj4) {
19793 {
19794 arg5 = (int)(SWIG_As_int(obj4));
19795 if (SWIG_arg_fail(5)) SWIG_fail;
19796 }
19797 }
19798 {
19799 PyThreadState* __tstate = wxPyBeginAllowThreads();
19800 {
19801 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19802 result = (wxDateTime *) &_result_ref;
19803 }
19804
19805 wxPyEndAllowThreads(__tstate);
19806 if (PyErr_Occurred()) SWIG_fail;
19807 }
19808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19809 return resultobj;
19810 fail:
19811 return NULL;
19812 }
19813
19814
19815 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19816 PyObject *resultobj;
19817 wxDateTime *arg1 = (wxDateTime *) 0 ;
19818 int arg2 ;
19819 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19820 int arg4 = (int) wxDateTime::Inv_Year ;
19821 int arg5 = (int) 0 ;
19822 int arg6 = (int) 0 ;
19823 int arg7 = (int) 0 ;
19824 int arg8 = (int) 0 ;
19825 wxDateTime *result;
19826 PyObject * obj0 = 0 ;
19827 PyObject * obj1 = 0 ;
19828 PyObject * obj2 = 0 ;
19829 PyObject * obj3 = 0 ;
19830 PyObject * obj4 = 0 ;
19831 PyObject * obj5 = 0 ;
19832 PyObject * obj6 = 0 ;
19833 PyObject * obj7 = 0 ;
19834 char *kwnames[] = {
19835 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19836 };
19837
19838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19840 if (SWIG_arg_fail(1)) SWIG_fail;
19841 {
19842 arg2 = (int)(SWIG_As_int(obj1));
19843 if (SWIG_arg_fail(2)) SWIG_fail;
19844 }
19845 if (obj2) {
19846 {
19847 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19848 if (SWIG_arg_fail(3)) SWIG_fail;
19849 }
19850 }
19851 if (obj3) {
19852 {
19853 arg4 = (int)(SWIG_As_int(obj3));
19854 if (SWIG_arg_fail(4)) SWIG_fail;
19855 }
19856 }
19857 if (obj4) {
19858 {
19859 arg5 = (int)(SWIG_As_int(obj4));
19860 if (SWIG_arg_fail(5)) SWIG_fail;
19861 }
19862 }
19863 if (obj5) {
19864 {
19865 arg6 = (int)(SWIG_As_int(obj5));
19866 if (SWIG_arg_fail(6)) SWIG_fail;
19867 }
19868 }
19869 if (obj6) {
19870 {
19871 arg7 = (int)(SWIG_As_int(obj6));
19872 if (SWIG_arg_fail(7)) SWIG_fail;
19873 }
19874 }
19875 if (obj7) {
19876 {
19877 arg8 = (int)(SWIG_As_int(obj7));
19878 if (SWIG_arg_fail(8)) SWIG_fail;
19879 }
19880 }
19881 {
19882 PyThreadState* __tstate = wxPyBeginAllowThreads();
19883 {
19884 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19885 result = (wxDateTime *) &_result_ref;
19886 }
19887
19888 wxPyEndAllowThreads(__tstate);
19889 if (PyErr_Occurred()) SWIG_fail;
19890 }
19891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj;
19900 wxDateTime *arg1 = (wxDateTime *) 0 ;
19901 wxDateTime *result;
19902 PyObject * obj0 = 0 ;
19903 char *kwnames[] = {
19904 (char *) "self", NULL
19905 };
19906
19907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19909 if (SWIG_arg_fail(1)) SWIG_fail;
19910 {
19911 PyThreadState* __tstate = wxPyBeginAllowThreads();
19912 {
19913 wxDateTime &_result_ref = (arg1)->ResetTime();
19914 result = (wxDateTime *) &_result_ref;
19915 }
19916
19917 wxPyEndAllowThreads(__tstate);
19918 if (PyErr_Occurred()) SWIG_fail;
19919 }
19920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19921 return resultobj;
19922 fail:
19923 return NULL;
19924 }
19925
19926
19927 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19928 PyObject *resultobj;
19929 wxDateTime *arg1 = (wxDateTime *) 0 ;
19930 int arg2 ;
19931 wxDateTime *result;
19932 PyObject * obj0 = 0 ;
19933 PyObject * obj1 = 0 ;
19934 char *kwnames[] = {
19935 (char *) "self",(char *) "year", NULL
19936 };
19937
19938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19940 if (SWIG_arg_fail(1)) SWIG_fail;
19941 {
19942 arg2 = (int)(SWIG_As_int(obj1));
19943 if (SWIG_arg_fail(2)) SWIG_fail;
19944 }
19945 {
19946 PyThreadState* __tstate = wxPyBeginAllowThreads();
19947 {
19948 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19949 result = (wxDateTime *) &_result_ref;
19950 }
19951
19952 wxPyEndAllowThreads(__tstate);
19953 if (PyErr_Occurred()) SWIG_fail;
19954 }
19955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19956 return resultobj;
19957 fail:
19958 return NULL;
19959 }
19960
19961
19962 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19963 PyObject *resultobj;
19964 wxDateTime *arg1 = (wxDateTime *) 0 ;
19965 wxDateTime::Month arg2 ;
19966 wxDateTime *result;
19967 PyObject * obj0 = 0 ;
19968 PyObject * obj1 = 0 ;
19969 char *kwnames[] = {
19970 (char *) "self",(char *) "month", NULL
19971 };
19972
19973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19975 if (SWIG_arg_fail(1)) SWIG_fail;
19976 {
19977 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19978 if (SWIG_arg_fail(2)) SWIG_fail;
19979 }
19980 {
19981 PyThreadState* __tstate = wxPyBeginAllowThreads();
19982 {
19983 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19984 result = (wxDateTime *) &_result_ref;
19985 }
19986
19987 wxPyEndAllowThreads(__tstate);
19988 if (PyErr_Occurred()) SWIG_fail;
19989 }
19990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
19998 PyObject *resultobj;
19999 wxDateTime *arg1 = (wxDateTime *) 0 ;
20000 int arg2 ;
20001 wxDateTime *result;
20002 PyObject * obj0 = 0 ;
20003 PyObject * obj1 = 0 ;
20004 char *kwnames[] = {
20005 (char *) "self",(char *) "day", NULL
20006 };
20007
20008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20010 if (SWIG_arg_fail(1)) SWIG_fail;
20011 {
20012 arg2 = (int)(SWIG_As_int(obj1));
20013 if (SWIG_arg_fail(2)) SWIG_fail;
20014 }
20015 {
20016 PyThreadState* __tstate = wxPyBeginAllowThreads();
20017 {
20018 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20019 result = (wxDateTime *) &_result_ref;
20020 }
20021
20022 wxPyEndAllowThreads(__tstate);
20023 if (PyErr_Occurred()) SWIG_fail;
20024 }
20025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20026 return resultobj;
20027 fail:
20028 return NULL;
20029 }
20030
20031
20032 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20033 PyObject *resultobj;
20034 wxDateTime *arg1 = (wxDateTime *) 0 ;
20035 int arg2 ;
20036 wxDateTime *result;
20037 PyObject * obj0 = 0 ;
20038 PyObject * obj1 = 0 ;
20039 char *kwnames[] = {
20040 (char *) "self",(char *) "hour", NULL
20041 };
20042
20043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20045 if (SWIG_arg_fail(1)) SWIG_fail;
20046 {
20047 arg2 = (int)(SWIG_As_int(obj1));
20048 if (SWIG_arg_fail(2)) SWIG_fail;
20049 }
20050 {
20051 PyThreadState* __tstate = wxPyBeginAllowThreads();
20052 {
20053 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20054 result = (wxDateTime *) &_result_ref;
20055 }
20056
20057 wxPyEndAllowThreads(__tstate);
20058 if (PyErr_Occurred()) SWIG_fail;
20059 }
20060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20061 return resultobj;
20062 fail:
20063 return NULL;
20064 }
20065
20066
20067 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20068 PyObject *resultobj;
20069 wxDateTime *arg1 = (wxDateTime *) 0 ;
20070 int arg2 ;
20071 wxDateTime *result;
20072 PyObject * obj0 = 0 ;
20073 PyObject * obj1 = 0 ;
20074 char *kwnames[] = {
20075 (char *) "self",(char *) "minute", NULL
20076 };
20077
20078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20080 if (SWIG_arg_fail(1)) SWIG_fail;
20081 {
20082 arg2 = (int)(SWIG_As_int(obj1));
20083 if (SWIG_arg_fail(2)) SWIG_fail;
20084 }
20085 {
20086 PyThreadState* __tstate = wxPyBeginAllowThreads();
20087 {
20088 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20089 result = (wxDateTime *) &_result_ref;
20090 }
20091
20092 wxPyEndAllowThreads(__tstate);
20093 if (PyErr_Occurred()) SWIG_fail;
20094 }
20095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20096 return resultobj;
20097 fail:
20098 return NULL;
20099 }
20100
20101
20102 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20103 PyObject *resultobj;
20104 wxDateTime *arg1 = (wxDateTime *) 0 ;
20105 int arg2 ;
20106 wxDateTime *result;
20107 PyObject * obj0 = 0 ;
20108 PyObject * obj1 = 0 ;
20109 char *kwnames[] = {
20110 (char *) "self",(char *) "second", NULL
20111 };
20112
20113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20115 if (SWIG_arg_fail(1)) SWIG_fail;
20116 {
20117 arg2 = (int)(SWIG_As_int(obj1));
20118 if (SWIG_arg_fail(2)) SWIG_fail;
20119 }
20120 {
20121 PyThreadState* __tstate = wxPyBeginAllowThreads();
20122 {
20123 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20124 result = (wxDateTime *) &_result_ref;
20125 }
20126
20127 wxPyEndAllowThreads(__tstate);
20128 if (PyErr_Occurred()) SWIG_fail;
20129 }
20130 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20131 return resultobj;
20132 fail:
20133 return NULL;
20134 }
20135
20136
20137 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20138 PyObject *resultobj;
20139 wxDateTime *arg1 = (wxDateTime *) 0 ;
20140 int arg2 ;
20141 wxDateTime *result;
20142 PyObject * obj0 = 0 ;
20143 PyObject * obj1 = 0 ;
20144 char *kwnames[] = {
20145 (char *) "self",(char *) "millisecond", NULL
20146 };
20147
20148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20150 if (SWIG_arg_fail(1)) SWIG_fail;
20151 {
20152 arg2 = (int)(SWIG_As_int(obj1));
20153 if (SWIG_arg_fail(2)) SWIG_fail;
20154 }
20155 {
20156 PyThreadState* __tstate = wxPyBeginAllowThreads();
20157 {
20158 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20159 result = (wxDateTime *) &_result_ref;
20160 }
20161
20162 wxPyEndAllowThreads(__tstate);
20163 if (PyErr_Occurred()) SWIG_fail;
20164 }
20165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20166 return resultobj;
20167 fail:
20168 return NULL;
20169 }
20170
20171
20172 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20173 PyObject *resultobj;
20174 wxDateTime *arg1 = (wxDateTime *) 0 ;
20175 wxDateTime::WeekDay arg2 ;
20176 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20177 wxDateTime *result;
20178 PyObject * obj0 = 0 ;
20179 PyObject * obj1 = 0 ;
20180 PyObject * obj2 = 0 ;
20181 char *kwnames[] = {
20182 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20183 };
20184
20185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20187 if (SWIG_arg_fail(1)) SWIG_fail;
20188 {
20189 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20190 if (SWIG_arg_fail(2)) SWIG_fail;
20191 }
20192 if (obj2) {
20193 {
20194 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20195 if (SWIG_arg_fail(3)) SWIG_fail;
20196 }
20197 }
20198 {
20199 PyThreadState* __tstate = wxPyBeginAllowThreads();
20200 {
20201 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20202 result = (wxDateTime *) &_result_ref;
20203 }
20204
20205 wxPyEndAllowThreads(__tstate);
20206 if (PyErr_Occurred()) SWIG_fail;
20207 }
20208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20209 return resultobj;
20210 fail:
20211 return NULL;
20212 }
20213
20214
20215 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20216 PyObject *resultobj;
20217 wxDateTime *arg1 = (wxDateTime *) 0 ;
20218 wxDateTime::WeekDay arg2 ;
20219 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20220 wxDateTime result;
20221 PyObject * obj0 = 0 ;
20222 PyObject * obj1 = 0 ;
20223 PyObject * obj2 = 0 ;
20224 char *kwnames[] = {
20225 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20226 };
20227
20228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20230 if (SWIG_arg_fail(1)) SWIG_fail;
20231 {
20232 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20233 if (SWIG_arg_fail(2)) SWIG_fail;
20234 }
20235 if (obj2) {
20236 {
20237 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20238 if (SWIG_arg_fail(3)) SWIG_fail;
20239 }
20240 }
20241 {
20242 PyThreadState* __tstate = wxPyBeginAllowThreads();
20243 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20244
20245 wxPyEndAllowThreads(__tstate);
20246 if (PyErr_Occurred()) SWIG_fail;
20247 }
20248 {
20249 wxDateTime * resultptr;
20250 resultptr = new wxDateTime((wxDateTime &)(result));
20251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20252 }
20253 return resultobj;
20254 fail:
20255 return NULL;
20256 }
20257
20258
20259 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20260 PyObject *resultobj;
20261 wxDateTime *arg1 = (wxDateTime *) 0 ;
20262 wxDateTime::WeekDay arg2 ;
20263 wxDateTime *result;
20264 PyObject * obj0 = 0 ;
20265 PyObject * obj1 = 0 ;
20266 char *kwnames[] = {
20267 (char *) "self",(char *) "weekday", NULL
20268 };
20269
20270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20272 if (SWIG_arg_fail(1)) SWIG_fail;
20273 {
20274 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20275 if (SWIG_arg_fail(2)) SWIG_fail;
20276 }
20277 {
20278 PyThreadState* __tstate = wxPyBeginAllowThreads();
20279 {
20280 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20281 result = (wxDateTime *) &_result_ref;
20282 }
20283
20284 wxPyEndAllowThreads(__tstate);
20285 if (PyErr_Occurred()) SWIG_fail;
20286 }
20287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20288 return resultobj;
20289 fail:
20290 return NULL;
20291 }
20292
20293
20294 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20295 PyObject *resultobj;
20296 wxDateTime *arg1 = (wxDateTime *) 0 ;
20297 wxDateTime::WeekDay arg2 ;
20298 wxDateTime result;
20299 PyObject * obj0 = 0 ;
20300 PyObject * obj1 = 0 ;
20301 char *kwnames[] = {
20302 (char *) "self",(char *) "weekday", NULL
20303 };
20304
20305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20307 if (SWIG_arg_fail(1)) SWIG_fail;
20308 {
20309 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20310 if (SWIG_arg_fail(2)) SWIG_fail;
20311 }
20312 {
20313 PyThreadState* __tstate = wxPyBeginAllowThreads();
20314 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20315
20316 wxPyEndAllowThreads(__tstate);
20317 if (PyErr_Occurred()) SWIG_fail;
20318 }
20319 {
20320 wxDateTime * resultptr;
20321 resultptr = new wxDateTime((wxDateTime &)(result));
20322 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20323 }
20324 return resultobj;
20325 fail:
20326 return NULL;
20327 }
20328
20329
20330 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20331 PyObject *resultobj;
20332 wxDateTime *arg1 = (wxDateTime *) 0 ;
20333 wxDateTime::WeekDay arg2 ;
20334 wxDateTime *result;
20335 PyObject * obj0 = 0 ;
20336 PyObject * obj1 = 0 ;
20337 char *kwnames[] = {
20338 (char *) "self",(char *) "weekday", NULL
20339 };
20340
20341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20343 if (SWIG_arg_fail(1)) SWIG_fail;
20344 {
20345 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20346 if (SWIG_arg_fail(2)) SWIG_fail;
20347 }
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 {
20351 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20352 result = (wxDateTime *) &_result_ref;
20353 }
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20359 return resultobj;
20360 fail:
20361 return NULL;
20362 }
20363
20364
20365 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20366 PyObject *resultobj;
20367 wxDateTime *arg1 = (wxDateTime *) 0 ;
20368 wxDateTime::WeekDay arg2 ;
20369 wxDateTime result;
20370 PyObject * obj0 = 0 ;
20371 PyObject * obj1 = 0 ;
20372 char *kwnames[] = {
20373 (char *) "self",(char *) "weekday", NULL
20374 };
20375
20376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20378 if (SWIG_arg_fail(1)) SWIG_fail;
20379 {
20380 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20381 if (SWIG_arg_fail(2)) SWIG_fail;
20382 }
20383 {
20384 PyThreadState* __tstate = wxPyBeginAllowThreads();
20385 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20386
20387 wxPyEndAllowThreads(__tstate);
20388 if (PyErr_Occurred()) SWIG_fail;
20389 }
20390 {
20391 wxDateTime * resultptr;
20392 resultptr = new wxDateTime((wxDateTime &)(result));
20393 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20394 }
20395 return resultobj;
20396 fail:
20397 return NULL;
20398 }
20399
20400
20401 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20402 PyObject *resultobj;
20403 wxDateTime *arg1 = (wxDateTime *) 0 ;
20404 wxDateTime::WeekDay arg2 ;
20405 int arg3 = (int) 1 ;
20406 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20407 int arg5 = (int) wxDateTime::Inv_Year ;
20408 bool result;
20409 PyObject * obj0 = 0 ;
20410 PyObject * obj1 = 0 ;
20411 PyObject * obj2 = 0 ;
20412 PyObject * obj3 = 0 ;
20413 PyObject * obj4 = 0 ;
20414 char *kwnames[] = {
20415 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20416 };
20417
20418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20420 if (SWIG_arg_fail(1)) SWIG_fail;
20421 {
20422 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20423 if (SWIG_arg_fail(2)) SWIG_fail;
20424 }
20425 if (obj2) {
20426 {
20427 arg3 = (int)(SWIG_As_int(obj2));
20428 if (SWIG_arg_fail(3)) SWIG_fail;
20429 }
20430 }
20431 if (obj3) {
20432 {
20433 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20434 if (SWIG_arg_fail(4)) SWIG_fail;
20435 }
20436 }
20437 if (obj4) {
20438 {
20439 arg5 = (int)(SWIG_As_int(obj4));
20440 if (SWIG_arg_fail(5)) SWIG_fail;
20441 }
20442 }
20443 {
20444 PyThreadState* __tstate = wxPyBeginAllowThreads();
20445 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20446
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 {
20451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20452 }
20453 return resultobj;
20454 fail:
20455 return NULL;
20456 }
20457
20458
20459 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20460 PyObject *resultobj;
20461 wxDateTime *arg1 = (wxDateTime *) 0 ;
20462 wxDateTime::WeekDay arg2 ;
20463 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20464 int arg4 = (int) wxDateTime::Inv_Year ;
20465 bool result;
20466 PyObject * obj0 = 0 ;
20467 PyObject * obj1 = 0 ;
20468 PyObject * obj2 = 0 ;
20469 PyObject * obj3 = 0 ;
20470 char *kwnames[] = {
20471 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20472 };
20473
20474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20476 if (SWIG_arg_fail(1)) SWIG_fail;
20477 {
20478 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20479 if (SWIG_arg_fail(2)) SWIG_fail;
20480 }
20481 if (obj2) {
20482 {
20483 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20484 if (SWIG_arg_fail(3)) SWIG_fail;
20485 }
20486 }
20487 if (obj3) {
20488 {
20489 arg4 = (int)(SWIG_As_int(obj3));
20490 if (SWIG_arg_fail(4)) SWIG_fail;
20491 }
20492 }
20493 {
20494 PyThreadState* __tstate = wxPyBeginAllowThreads();
20495 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20496
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 {
20501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20502 }
20503 return resultobj;
20504 fail:
20505 return NULL;
20506 }
20507
20508
20509 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20510 PyObject *resultobj;
20511 wxDateTime *arg1 = (wxDateTime *) 0 ;
20512 wxDateTime::WeekDay arg2 ;
20513 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20514 int arg4 = (int) wxDateTime::Inv_Year ;
20515 wxDateTime result;
20516 PyObject * obj0 = 0 ;
20517 PyObject * obj1 = 0 ;
20518 PyObject * obj2 = 0 ;
20519 PyObject * obj3 = 0 ;
20520 char *kwnames[] = {
20521 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20522 };
20523
20524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20526 if (SWIG_arg_fail(1)) SWIG_fail;
20527 {
20528 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20529 if (SWIG_arg_fail(2)) SWIG_fail;
20530 }
20531 if (obj2) {
20532 {
20533 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20534 if (SWIG_arg_fail(3)) SWIG_fail;
20535 }
20536 }
20537 if (obj3) {
20538 {
20539 arg4 = (int)(SWIG_As_int(obj3));
20540 if (SWIG_arg_fail(4)) SWIG_fail;
20541 }
20542 }
20543 {
20544 PyThreadState* __tstate = wxPyBeginAllowThreads();
20545 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20546
20547 wxPyEndAllowThreads(__tstate);
20548 if (PyErr_Occurred()) SWIG_fail;
20549 }
20550 {
20551 wxDateTime * resultptr;
20552 resultptr = new wxDateTime((wxDateTime &)(result));
20553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20554 }
20555 return resultobj;
20556 fail:
20557 return NULL;
20558 }
20559
20560
20561 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20562 PyObject *resultobj;
20563 wxDateTime *arg1 = (wxDateTime *) 0 ;
20564 int arg2 ;
20565 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20566 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20567 bool result;
20568 PyObject * obj0 = 0 ;
20569 PyObject * obj1 = 0 ;
20570 PyObject * obj2 = 0 ;
20571 PyObject * obj3 = 0 ;
20572 char *kwnames[] = {
20573 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20574 };
20575
20576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20578 if (SWIG_arg_fail(1)) SWIG_fail;
20579 {
20580 arg2 = (int)(SWIG_As_int(obj1));
20581 if (SWIG_arg_fail(2)) SWIG_fail;
20582 }
20583 if (obj2) {
20584 {
20585 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20586 if (SWIG_arg_fail(3)) SWIG_fail;
20587 }
20588 }
20589 if (obj3) {
20590 {
20591 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20592 if (SWIG_arg_fail(4)) SWIG_fail;
20593 }
20594 }
20595 {
20596 PyThreadState* __tstate = wxPyBeginAllowThreads();
20597 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20598
20599 wxPyEndAllowThreads(__tstate);
20600 if (PyErr_Occurred()) SWIG_fail;
20601 }
20602 {
20603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20604 }
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20612 PyObject *resultobj;
20613 wxDateTime *arg1 = (wxDateTime *) 0 ;
20614 int arg2 ;
20615 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20616 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20617 wxDateTime result;
20618 PyObject * obj0 = 0 ;
20619 PyObject * obj1 = 0 ;
20620 PyObject * obj2 = 0 ;
20621 PyObject * obj3 = 0 ;
20622 char *kwnames[] = {
20623 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20624 };
20625
20626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20628 if (SWIG_arg_fail(1)) SWIG_fail;
20629 {
20630 arg2 = (int)(SWIG_As_int(obj1));
20631 if (SWIG_arg_fail(2)) SWIG_fail;
20632 }
20633 if (obj2) {
20634 {
20635 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20636 if (SWIG_arg_fail(3)) SWIG_fail;
20637 }
20638 }
20639 if (obj3) {
20640 {
20641 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20642 if (SWIG_arg_fail(4)) SWIG_fail;
20643 }
20644 }
20645 {
20646 PyThreadState* __tstate = wxPyBeginAllowThreads();
20647 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20648
20649 wxPyEndAllowThreads(__tstate);
20650 if (PyErr_Occurred()) SWIG_fail;
20651 }
20652 {
20653 wxDateTime * resultptr;
20654 resultptr = new wxDateTime((wxDateTime &)(result));
20655 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20656 }
20657 return resultobj;
20658 fail:
20659 return NULL;
20660 }
20661
20662
20663 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20664 PyObject *resultobj;
20665 int arg1 ;
20666 int arg2 ;
20667 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20668 wxDateTime result;
20669 PyObject * obj0 = 0 ;
20670 PyObject * obj1 = 0 ;
20671 PyObject * obj2 = 0 ;
20672 char *kwnames[] = {
20673 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20674 };
20675
20676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20677 {
20678 arg1 = (int)(SWIG_As_int(obj0));
20679 if (SWIG_arg_fail(1)) SWIG_fail;
20680 }
20681 {
20682 arg2 = (int)(SWIG_As_int(obj1));
20683 if (SWIG_arg_fail(2)) SWIG_fail;
20684 }
20685 if (obj2) {
20686 {
20687 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20688 if (SWIG_arg_fail(3)) SWIG_fail;
20689 }
20690 }
20691 {
20692 PyThreadState* __tstate = wxPyBeginAllowThreads();
20693 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20694
20695 wxPyEndAllowThreads(__tstate);
20696 if (PyErr_Occurred()) SWIG_fail;
20697 }
20698 {
20699 wxDateTime * resultptr;
20700 resultptr = new wxDateTime((wxDateTime &)(result));
20701 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20702 }
20703 return resultobj;
20704 fail:
20705 return NULL;
20706 }
20707
20708
20709 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20710 PyObject *resultobj;
20711 wxDateTime *arg1 = (wxDateTime *) 0 ;
20712 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20713 int arg3 = (int) wxDateTime::Inv_Year ;
20714 wxDateTime *result;
20715 PyObject * obj0 = 0 ;
20716 PyObject * obj1 = 0 ;
20717 PyObject * obj2 = 0 ;
20718 char *kwnames[] = {
20719 (char *) "self",(char *) "month",(char *) "year", NULL
20720 };
20721
20722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20724 if (SWIG_arg_fail(1)) SWIG_fail;
20725 if (obj1) {
20726 {
20727 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20728 if (SWIG_arg_fail(2)) SWIG_fail;
20729 }
20730 }
20731 if (obj2) {
20732 {
20733 arg3 = (int)(SWIG_As_int(obj2));
20734 if (SWIG_arg_fail(3)) SWIG_fail;
20735 }
20736 }
20737 {
20738 PyThreadState* __tstate = wxPyBeginAllowThreads();
20739 {
20740 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20741 result = (wxDateTime *) &_result_ref;
20742 }
20743
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20748 return resultobj;
20749 fail:
20750 return NULL;
20751 }
20752
20753
20754 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20755 PyObject *resultobj;
20756 wxDateTime *arg1 = (wxDateTime *) 0 ;
20757 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20758 int arg3 = (int) wxDateTime::Inv_Year ;
20759 wxDateTime result;
20760 PyObject * obj0 = 0 ;
20761 PyObject * obj1 = 0 ;
20762 PyObject * obj2 = 0 ;
20763 char *kwnames[] = {
20764 (char *) "self",(char *) "month",(char *) "year", NULL
20765 };
20766
20767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20769 if (SWIG_arg_fail(1)) SWIG_fail;
20770 if (obj1) {
20771 {
20772 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20773 if (SWIG_arg_fail(2)) SWIG_fail;
20774 }
20775 }
20776 if (obj2) {
20777 {
20778 arg3 = (int)(SWIG_As_int(obj2));
20779 if (SWIG_arg_fail(3)) SWIG_fail;
20780 }
20781 }
20782 {
20783 PyThreadState* __tstate = wxPyBeginAllowThreads();
20784 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20785
20786 wxPyEndAllowThreads(__tstate);
20787 if (PyErr_Occurred()) SWIG_fail;
20788 }
20789 {
20790 wxDateTime * resultptr;
20791 resultptr = new wxDateTime((wxDateTime &)(result));
20792 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20793 }
20794 return resultobj;
20795 fail:
20796 return NULL;
20797 }
20798
20799
20800 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20801 PyObject *resultobj;
20802 wxDateTime *arg1 = (wxDateTime *) 0 ;
20803 int arg2 ;
20804 wxDateTime *result;
20805 PyObject * obj0 = 0 ;
20806 PyObject * obj1 = 0 ;
20807 char *kwnames[] = {
20808 (char *) "self",(char *) "yday", NULL
20809 };
20810
20811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20813 if (SWIG_arg_fail(1)) SWIG_fail;
20814 {
20815 arg2 = (int)(SWIG_As_int(obj1));
20816 if (SWIG_arg_fail(2)) SWIG_fail;
20817 }
20818 {
20819 PyThreadState* __tstate = wxPyBeginAllowThreads();
20820 {
20821 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20822 result = (wxDateTime *) &_result_ref;
20823 }
20824
20825 wxPyEndAllowThreads(__tstate);
20826 if (PyErr_Occurred()) SWIG_fail;
20827 }
20828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20829 return resultobj;
20830 fail:
20831 return NULL;
20832 }
20833
20834
20835 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20836 PyObject *resultobj;
20837 wxDateTime *arg1 = (wxDateTime *) 0 ;
20838 int arg2 ;
20839 wxDateTime result;
20840 PyObject * obj0 = 0 ;
20841 PyObject * obj1 = 0 ;
20842 char *kwnames[] = {
20843 (char *) "self",(char *) "yday", NULL
20844 };
20845
20846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20848 if (SWIG_arg_fail(1)) SWIG_fail;
20849 {
20850 arg2 = (int)(SWIG_As_int(obj1));
20851 if (SWIG_arg_fail(2)) SWIG_fail;
20852 }
20853 {
20854 PyThreadState* __tstate = wxPyBeginAllowThreads();
20855 result = (arg1)->GetYearDay(arg2);
20856
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 {
20861 wxDateTime * resultptr;
20862 resultptr = new wxDateTime((wxDateTime &)(result));
20863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20864 }
20865 return resultobj;
20866 fail:
20867 return NULL;
20868 }
20869
20870
20871 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20872 PyObject *resultobj;
20873 wxDateTime *arg1 = (wxDateTime *) 0 ;
20874 double result;
20875 PyObject * obj0 = 0 ;
20876 char *kwnames[] = {
20877 (char *) "self", NULL
20878 };
20879
20880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20882 if (SWIG_arg_fail(1)) SWIG_fail;
20883 {
20884 PyThreadState* __tstate = wxPyBeginAllowThreads();
20885 result = (double)(arg1)->GetJulianDayNumber();
20886
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 {
20891 resultobj = SWIG_From_double((double)(result));
20892 }
20893 return resultobj;
20894 fail:
20895 return NULL;
20896 }
20897
20898
20899 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20900 PyObject *resultobj;
20901 wxDateTime *arg1 = (wxDateTime *) 0 ;
20902 double result;
20903 PyObject * obj0 = 0 ;
20904 char *kwnames[] = {
20905 (char *) "self", NULL
20906 };
20907
20908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20910 if (SWIG_arg_fail(1)) SWIG_fail;
20911 {
20912 PyThreadState* __tstate = wxPyBeginAllowThreads();
20913 result = (double)(arg1)->GetJDN();
20914
20915 wxPyEndAllowThreads(__tstate);
20916 if (PyErr_Occurred()) SWIG_fail;
20917 }
20918 {
20919 resultobj = SWIG_From_double((double)(result));
20920 }
20921 return resultobj;
20922 fail:
20923 return NULL;
20924 }
20925
20926
20927 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20928 PyObject *resultobj;
20929 wxDateTime *arg1 = (wxDateTime *) 0 ;
20930 double result;
20931 PyObject * obj0 = 0 ;
20932 char *kwnames[] = {
20933 (char *) "self", NULL
20934 };
20935
20936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20938 if (SWIG_arg_fail(1)) SWIG_fail;
20939 {
20940 PyThreadState* __tstate = wxPyBeginAllowThreads();
20941 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20942
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 {
20947 resultobj = SWIG_From_double((double)(result));
20948 }
20949 return resultobj;
20950 fail:
20951 return NULL;
20952 }
20953
20954
20955 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20956 PyObject *resultobj;
20957 wxDateTime *arg1 = (wxDateTime *) 0 ;
20958 double result;
20959 PyObject * obj0 = 0 ;
20960 char *kwnames[] = {
20961 (char *) "self", NULL
20962 };
20963
20964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20966 if (SWIG_arg_fail(1)) SWIG_fail;
20967 {
20968 PyThreadState* __tstate = wxPyBeginAllowThreads();
20969 result = (double)(arg1)->GetMJD();
20970
20971 wxPyEndAllowThreads(__tstate);
20972 if (PyErr_Occurred()) SWIG_fail;
20973 }
20974 {
20975 resultobj = SWIG_From_double((double)(result));
20976 }
20977 return resultobj;
20978 fail:
20979 return NULL;
20980 }
20981
20982
20983 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20984 PyObject *resultobj;
20985 wxDateTime *arg1 = (wxDateTime *) 0 ;
20986 double result;
20987 PyObject * obj0 = 0 ;
20988 char *kwnames[] = {
20989 (char *) "self", NULL
20990 };
20991
20992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20994 if (SWIG_arg_fail(1)) SWIG_fail;
20995 {
20996 PyThreadState* __tstate = wxPyBeginAllowThreads();
20997 result = (double)(arg1)->GetRataDie();
20998
20999 wxPyEndAllowThreads(__tstate);
21000 if (PyErr_Occurred()) SWIG_fail;
21001 }
21002 {
21003 resultobj = SWIG_From_double((double)(result));
21004 }
21005 return resultobj;
21006 fail:
21007 return NULL;
21008 }
21009
21010
21011 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21012 PyObject *resultobj;
21013 wxDateTime *arg1 = (wxDateTime *) 0 ;
21014 wxDateTime::TimeZone *arg2 = 0 ;
21015 bool arg3 = (bool) false ;
21016 wxDateTime result;
21017 bool temp2 = false ;
21018 PyObject * obj0 = 0 ;
21019 PyObject * obj1 = 0 ;
21020 PyObject * obj2 = 0 ;
21021 char *kwnames[] = {
21022 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21023 };
21024
21025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21027 if (SWIG_arg_fail(1)) SWIG_fail;
21028 {
21029 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21030 temp2 = true;
21031 }
21032 if (obj2) {
21033 {
21034 arg3 = (bool)(SWIG_As_bool(obj2));
21035 if (SWIG_arg_fail(3)) SWIG_fail;
21036 }
21037 }
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21041
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 {
21046 wxDateTime * resultptr;
21047 resultptr = new wxDateTime((wxDateTime &)(result));
21048 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21049 }
21050 {
21051 if (temp2) delete arg2;
21052 }
21053 return resultobj;
21054 fail:
21055 {
21056 if (temp2) delete arg2;
21057 }
21058 return NULL;
21059 }
21060
21061
21062 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21063 PyObject *resultobj;
21064 wxDateTime *arg1 = (wxDateTime *) 0 ;
21065 wxDateTime::TimeZone *arg2 = 0 ;
21066 bool arg3 = (bool) false ;
21067 wxDateTime *result;
21068 bool temp2 = false ;
21069 PyObject * obj0 = 0 ;
21070 PyObject * obj1 = 0 ;
21071 PyObject * obj2 = 0 ;
21072 char *kwnames[] = {
21073 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21074 };
21075
21076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21078 if (SWIG_arg_fail(1)) SWIG_fail;
21079 {
21080 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21081 temp2 = true;
21082 }
21083 if (obj2) {
21084 {
21085 arg3 = (bool)(SWIG_As_bool(obj2));
21086 if (SWIG_arg_fail(3)) SWIG_fail;
21087 }
21088 }
21089 {
21090 PyThreadState* __tstate = wxPyBeginAllowThreads();
21091 {
21092 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21093 result = (wxDateTime *) &_result_ref;
21094 }
21095
21096 wxPyEndAllowThreads(__tstate);
21097 if (PyErr_Occurred()) SWIG_fail;
21098 }
21099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21100 {
21101 if (temp2) delete arg2;
21102 }
21103 return resultobj;
21104 fail:
21105 {
21106 if (temp2) delete arg2;
21107 }
21108 return NULL;
21109 }
21110
21111
21112 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21113 PyObject *resultobj;
21114 wxDateTime *arg1 = (wxDateTime *) 0 ;
21115 bool arg2 = (bool) false ;
21116 wxDateTime result;
21117 PyObject * obj0 = 0 ;
21118 PyObject * obj1 = 0 ;
21119 char *kwnames[] = {
21120 (char *) "self",(char *) "noDST", NULL
21121 };
21122
21123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21125 if (SWIG_arg_fail(1)) SWIG_fail;
21126 if (obj1) {
21127 {
21128 arg2 = (bool)(SWIG_As_bool(obj1));
21129 if (SWIG_arg_fail(2)) SWIG_fail;
21130 }
21131 }
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 result = (arg1)->ToGMT(arg2);
21135
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 {
21140 wxDateTime * resultptr;
21141 resultptr = new wxDateTime((wxDateTime &)(result));
21142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21143 }
21144 return resultobj;
21145 fail:
21146 return NULL;
21147 }
21148
21149
21150 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21151 PyObject *resultobj;
21152 wxDateTime *arg1 = (wxDateTime *) 0 ;
21153 bool arg2 = (bool) false ;
21154 wxDateTime *result;
21155 PyObject * obj0 = 0 ;
21156 PyObject * obj1 = 0 ;
21157 char *kwnames[] = {
21158 (char *) "self",(char *) "noDST", NULL
21159 };
21160
21161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21163 if (SWIG_arg_fail(1)) SWIG_fail;
21164 if (obj1) {
21165 {
21166 arg2 = (bool)(SWIG_As_bool(obj1));
21167 if (SWIG_arg_fail(2)) SWIG_fail;
21168 }
21169 }
21170 {
21171 PyThreadState* __tstate = wxPyBeginAllowThreads();
21172 {
21173 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21174 result = (wxDateTime *) &_result_ref;
21175 }
21176
21177 wxPyEndAllowThreads(__tstate);
21178 if (PyErr_Occurred()) SWIG_fail;
21179 }
21180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21188 PyObject *resultobj;
21189 wxDateTime *arg1 = (wxDateTime *) 0 ;
21190 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21191 int result;
21192 PyObject * obj0 = 0 ;
21193 PyObject * obj1 = 0 ;
21194 char *kwnames[] = {
21195 (char *) "self",(char *) "country", NULL
21196 };
21197
21198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",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 if (obj1) {
21202 {
21203 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21204 if (SWIG_arg_fail(2)) SWIG_fail;
21205 }
21206 }
21207 {
21208 PyThreadState* __tstate = wxPyBeginAllowThreads();
21209 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21210
21211 wxPyEndAllowThreads(__tstate);
21212 if (PyErr_Occurred()) SWIG_fail;
21213 }
21214 {
21215 resultobj = SWIG_From_int((int)(result));
21216 }
21217 return resultobj;
21218 fail:
21219 return NULL;
21220 }
21221
21222
21223 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21224 PyObject *resultobj;
21225 wxDateTime *arg1 = (wxDateTime *) 0 ;
21226 bool result;
21227 PyObject * obj0 = 0 ;
21228 char *kwnames[] = {
21229 (char *) "self", NULL
21230 };
21231
21232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21234 if (SWIG_arg_fail(1)) SWIG_fail;
21235 {
21236 PyThreadState* __tstate = wxPyBeginAllowThreads();
21237 result = (bool)((wxDateTime const *)arg1)->IsValid();
21238
21239 wxPyEndAllowThreads(__tstate);
21240 if (PyErr_Occurred()) SWIG_fail;
21241 }
21242 {
21243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21244 }
21245 return resultobj;
21246 fail:
21247 return NULL;
21248 }
21249
21250
21251 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21252 PyObject *resultobj;
21253 wxDateTime *arg1 = (wxDateTime *) 0 ;
21254 time_t result;
21255 PyObject * obj0 = 0 ;
21256 char *kwnames[] = {
21257 (char *) "self", NULL
21258 };
21259
21260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21262 if (SWIG_arg_fail(1)) SWIG_fail;
21263 {
21264 PyThreadState* __tstate = wxPyBeginAllowThreads();
21265 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21266
21267 wxPyEndAllowThreads(__tstate);
21268 if (PyErr_Occurred()) SWIG_fail;
21269 }
21270 {
21271 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21272 }
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21280 PyObject *resultobj;
21281 wxDateTime *arg1 = (wxDateTime *) 0 ;
21282 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21283 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21284 int result;
21285 bool temp2 = false ;
21286 PyObject * obj0 = 0 ;
21287 PyObject * obj1 = 0 ;
21288 char *kwnames[] = {
21289 (char *) "self",(char *) "tz", NULL
21290 };
21291
21292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21294 if (SWIG_arg_fail(1)) SWIG_fail;
21295 if (obj1) {
21296 {
21297 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21298 temp2 = true;
21299 }
21300 }
21301 {
21302 PyThreadState* __tstate = wxPyBeginAllowThreads();
21303 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21304
21305 wxPyEndAllowThreads(__tstate);
21306 if (PyErr_Occurred()) SWIG_fail;
21307 }
21308 {
21309 resultobj = SWIG_From_int((int)(result));
21310 }
21311 {
21312 if (temp2) delete arg2;
21313 }
21314 return resultobj;
21315 fail:
21316 {
21317 if (temp2) delete arg2;
21318 }
21319 return NULL;
21320 }
21321
21322
21323 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21324 PyObject *resultobj;
21325 wxDateTime *arg1 = (wxDateTime *) 0 ;
21326 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21327 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21328 wxDateTime::Month result;
21329 bool temp2 = false ;
21330 PyObject * obj0 = 0 ;
21331 PyObject * obj1 = 0 ;
21332 char *kwnames[] = {
21333 (char *) "self",(char *) "tz", NULL
21334 };
21335
21336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21338 if (SWIG_arg_fail(1)) SWIG_fail;
21339 if (obj1) {
21340 {
21341 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21342 temp2 = true;
21343 }
21344 }
21345 {
21346 PyThreadState* __tstate = wxPyBeginAllowThreads();
21347 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21348
21349 wxPyEndAllowThreads(__tstate);
21350 if (PyErr_Occurred()) SWIG_fail;
21351 }
21352 resultobj = SWIG_From_int((result));
21353 {
21354 if (temp2) delete arg2;
21355 }
21356 return resultobj;
21357 fail:
21358 {
21359 if (temp2) delete arg2;
21360 }
21361 return NULL;
21362 }
21363
21364
21365 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21366 PyObject *resultobj;
21367 wxDateTime *arg1 = (wxDateTime *) 0 ;
21368 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21369 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21370 int result;
21371 bool temp2 = false ;
21372 PyObject * obj0 = 0 ;
21373 PyObject * obj1 = 0 ;
21374 char *kwnames[] = {
21375 (char *) "self",(char *) "tz", NULL
21376 };
21377
21378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21380 if (SWIG_arg_fail(1)) SWIG_fail;
21381 if (obj1) {
21382 {
21383 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21384 temp2 = true;
21385 }
21386 }
21387 {
21388 PyThreadState* __tstate = wxPyBeginAllowThreads();
21389 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21390
21391 wxPyEndAllowThreads(__tstate);
21392 if (PyErr_Occurred()) SWIG_fail;
21393 }
21394 {
21395 resultobj = SWIG_From_int((int)(result));
21396 }
21397 {
21398 if (temp2) delete arg2;
21399 }
21400 return resultobj;
21401 fail:
21402 {
21403 if (temp2) delete arg2;
21404 }
21405 return NULL;
21406 }
21407
21408
21409 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21410 PyObject *resultobj;
21411 wxDateTime *arg1 = (wxDateTime *) 0 ;
21412 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21413 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21414 wxDateTime::WeekDay result;
21415 bool temp2 = false ;
21416 PyObject * obj0 = 0 ;
21417 PyObject * obj1 = 0 ;
21418 char *kwnames[] = {
21419 (char *) "self",(char *) "tz", NULL
21420 };
21421
21422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21424 if (SWIG_arg_fail(1)) SWIG_fail;
21425 if (obj1) {
21426 {
21427 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21428 temp2 = true;
21429 }
21430 }
21431 {
21432 PyThreadState* __tstate = wxPyBeginAllowThreads();
21433 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21434
21435 wxPyEndAllowThreads(__tstate);
21436 if (PyErr_Occurred()) SWIG_fail;
21437 }
21438 resultobj = SWIG_From_int((result));
21439 {
21440 if (temp2) delete arg2;
21441 }
21442 return resultobj;
21443 fail:
21444 {
21445 if (temp2) delete arg2;
21446 }
21447 return NULL;
21448 }
21449
21450
21451 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21452 PyObject *resultobj;
21453 wxDateTime *arg1 = (wxDateTime *) 0 ;
21454 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21455 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21456 int result;
21457 bool temp2 = false ;
21458 PyObject * obj0 = 0 ;
21459 PyObject * obj1 = 0 ;
21460 char *kwnames[] = {
21461 (char *) "self",(char *) "tz", NULL
21462 };
21463
21464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21466 if (SWIG_arg_fail(1)) SWIG_fail;
21467 if (obj1) {
21468 {
21469 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21470 temp2 = true;
21471 }
21472 }
21473 {
21474 PyThreadState* __tstate = wxPyBeginAllowThreads();
21475 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21476
21477 wxPyEndAllowThreads(__tstate);
21478 if (PyErr_Occurred()) SWIG_fail;
21479 }
21480 {
21481 resultobj = SWIG_From_int((int)(result));
21482 }
21483 {
21484 if (temp2) delete arg2;
21485 }
21486 return resultobj;
21487 fail:
21488 {
21489 if (temp2) delete arg2;
21490 }
21491 return NULL;
21492 }
21493
21494
21495 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21496 PyObject *resultobj;
21497 wxDateTime *arg1 = (wxDateTime *) 0 ;
21498 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21499 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21500 int result;
21501 bool temp2 = false ;
21502 PyObject * obj0 = 0 ;
21503 PyObject * obj1 = 0 ;
21504 char *kwnames[] = {
21505 (char *) "self",(char *) "tz", NULL
21506 };
21507
21508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21510 if (SWIG_arg_fail(1)) SWIG_fail;
21511 if (obj1) {
21512 {
21513 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21514 temp2 = true;
21515 }
21516 }
21517 {
21518 PyThreadState* __tstate = wxPyBeginAllowThreads();
21519 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21520
21521 wxPyEndAllowThreads(__tstate);
21522 if (PyErr_Occurred()) SWIG_fail;
21523 }
21524 {
21525 resultobj = SWIG_From_int((int)(result));
21526 }
21527 {
21528 if (temp2) delete arg2;
21529 }
21530 return resultobj;
21531 fail:
21532 {
21533 if (temp2) delete arg2;
21534 }
21535 return NULL;
21536 }
21537
21538
21539 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21540 PyObject *resultobj;
21541 wxDateTime *arg1 = (wxDateTime *) 0 ;
21542 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21543 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21544 int result;
21545 bool temp2 = false ;
21546 PyObject * obj0 = 0 ;
21547 PyObject * obj1 = 0 ;
21548 char *kwnames[] = {
21549 (char *) "self",(char *) "tz", NULL
21550 };
21551
21552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21554 if (SWIG_arg_fail(1)) SWIG_fail;
21555 if (obj1) {
21556 {
21557 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21558 temp2 = true;
21559 }
21560 }
21561 {
21562 PyThreadState* __tstate = wxPyBeginAllowThreads();
21563 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21564
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 {
21569 resultobj = SWIG_From_int((int)(result));
21570 }
21571 {
21572 if (temp2) delete arg2;
21573 }
21574 return resultobj;
21575 fail:
21576 {
21577 if (temp2) delete arg2;
21578 }
21579 return NULL;
21580 }
21581
21582
21583 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21584 PyObject *resultobj;
21585 wxDateTime *arg1 = (wxDateTime *) 0 ;
21586 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21587 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21588 int result;
21589 bool temp2 = false ;
21590 PyObject * obj0 = 0 ;
21591 PyObject * obj1 = 0 ;
21592 char *kwnames[] = {
21593 (char *) "self",(char *) "tz", NULL
21594 };
21595
21596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21598 if (SWIG_arg_fail(1)) SWIG_fail;
21599 if (obj1) {
21600 {
21601 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21602 temp2 = true;
21603 }
21604 }
21605 {
21606 PyThreadState* __tstate = wxPyBeginAllowThreads();
21607 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21608
21609 wxPyEndAllowThreads(__tstate);
21610 if (PyErr_Occurred()) SWIG_fail;
21611 }
21612 {
21613 resultobj = SWIG_From_int((int)(result));
21614 }
21615 {
21616 if (temp2) delete arg2;
21617 }
21618 return resultobj;
21619 fail:
21620 {
21621 if (temp2) delete arg2;
21622 }
21623 return NULL;
21624 }
21625
21626
21627 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21628 PyObject *resultobj;
21629 wxDateTime *arg1 = (wxDateTime *) 0 ;
21630 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21631 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21632 int result;
21633 bool temp2 = false ;
21634 PyObject * obj0 = 0 ;
21635 PyObject * obj1 = 0 ;
21636 char *kwnames[] = {
21637 (char *) "self",(char *) "tz", NULL
21638 };
21639
21640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21642 if (SWIG_arg_fail(1)) SWIG_fail;
21643 if (obj1) {
21644 {
21645 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21646 temp2 = true;
21647 }
21648 }
21649 {
21650 PyThreadState* __tstate = wxPyBeginAllowThreads();
21651 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21652
21653 wxPyEndAllowThreads(__tstate);
21654 if (PyErr_Occurred()) SWIG_fail;
21655 }
21656 {
21657 resultobj = SWIG_From_int((int)(result));
21658 }
21659 {
21660 if (temp2) delete arg2;
21661 }
21662 return resultobj;
21663 fail:
21664 {
21665 if (temp2) delete arg2;
21666 }
21667 return NULL;
21668 }
21669
21670
21671 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21672 PyObject *resultobj;
21673 wxDateTime *arg1 = (wxDateTime *) 0 ;
21674 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21675 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21676 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21677 int result;
21678 bool temp3 = false ;
21679 PyObject * obj0 = 0 ;
21680 PyObject * obj1 = 0 ;
21681 PyObject * obj2 = 0 ;
21682 char *kwnames[] = {
21683 (char *) "self",(char *) "flags",(char *) "tz", NULL
21684 };
21685
21686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21688 if (SWIG_arg_fail(1)) SWIG_fail;
21689 if (obj1) {
21690 {
21691 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21692 if (SWIG_arg_fail(2)) SWIG_fail;
21693 }
21694 }
21695 if (obj2) {
21696 {
21697 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21698 temp3 = true;
21699 }
21700 }
21701 {
21702 PyThreadState* __tstate = wxPyBeginAllowThreads();
21703 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21704
21705 wxPyEndAllowThreads(__tstate);
21706 if (PyErr_Occurred()) SWIG_fail;
21707 }
21708 {
21709 resultobj = SWIG_From_int((int)(result));
21710 }
21711 {
21712 if (temp3) delete arg3;
21713 }
21714 return resultobj;
21715 fail:
21716 {
21717 if (temp3) delete arg3;
21718 }
21719 return NULL;
21720 }
21721
21722
21723 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21724 PyObject *resultobj;
21725 wxDateTime *arg1 = (wxDateTime *) 0 ;
21726 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21727 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21728 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21729 int result;
21730 bool temp3 = false ;
21731 PyObject * obj0 = 0 ;
21732 PyObject * obj1 = 0 ;
21733 PyObject * obj2 = 0 ;
21734 char *kwnames[] = {
21735 (char *) "self",(char *) "flags",(char *) "tz", NULL
21736 };
21737
21738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21740 if (SWIG_arg_fail(1)) SWIG_fail;
21741 if (obj1) {
21742 {
21743 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21744 if (SWIG_arg_fail(2)) SWIG_fail;
21745 }
21746 }
21747 if (obj2) {
21748 {
21749 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21750 temp3 = true;
21751 }
21752 }
21753 {
21754 PyThreadState* __tstate = wxPyBeginAllowThreads();
21755 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21756
21757 wxPyEndAllowThreads(__tstate);
21758 if (PyErr_Occurred()) SWIG_fail;
21759 }
21760 {
21761 resultobj = SWIG_From_int((int)(result));
21762 }
21763 {
21764 if (temp3) delete arg3;
21765 }
21766 return resultobj;
21767 fail:
21768 {
21769 if (temp3) delete arg3;
21770 }
21771 return NULL;
21772 }
21773
21774
21775 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21776 PyObject *resultobj;
21777 wxDateTime *arg1 = (wxDateTime *) 0 ;
21778 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21779 bool result;
21780 PyObject * obj0 = 0 ;
21781 PyObject * obj1 = 0 ;
21782 char *kwnames[] = {
21783 (char *) "self",(char *) "country", NULL
21784 };
21785
21786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21788 if (SWIG_arg_fail(1)) SWIG_fail;
21789 if (obj1) {
21790 {
21791 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21792 if (SWIG_arg_fail(2)) SWIG_fail;
21793 }
21794 }
21795 {
21796 PyThreadState* __tstate = wxPyBeginAllowThreads();
21797 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21798
21799 wxPyEndAllowThreads(__tstate);
21800 if (PyErr_Occurred()) SWIG_fail;
21801 }
21802 {
21803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21804 }
21805 return resultobj;
21806 fail:
21807 return NULL;
21808 }
21809
21810
21811 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21812 PyObject *resultobj;
21813 wxDateTime *arg1 = (wxDateTime *) 0 ;
21814 wxDateTime *arg2 = 0 ;
21815 bool result;
21816 PyObject * obj0 = 0 ;
21817 PyObject * obj1 = 0 ;
21818 char *kwnames[] = {
21819 (char *) "self",(char *) "datetime", NULL
21820 };
21821
21822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21824 if (SWIG_arg_fail(1)) SWIG_fail;
21825 {
21826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21827 if (SWIG_arg_fail(2)) SWIG_fail;
21828 if (arg2 == NULL) {
21829 SWIG_null_ref("wxDateTime");
21830 }
21831 if (SWIG_arg_fail(2)) SWIG_fail;
21832 }
21833 {
21834 PyThreadState* __tstate = wxPyBeginAllowThreads();
21835 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21836
21837 wxPyEndAllowThreads(__tstate);
21838 if (PyErr_Occurred()) SWIG_fail;
21839 }
21840 {
21841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21842 }
21843 return resultobj;
21844 fail:
21845 return NULL;
21846 }
21847
21848
21849 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21850 PyObject *resultobj;
21851 wxDateTime *arg1 = (wxDateTime *) 0 ;
21852 wxDateTime *arg2 = 0 ;
21853 bool result;
21854 PyObject * obj0 = 0 ;
21855 PyObject * obj1 = 0 ;
21856 char *kwnames[] = {
21857 (char *) "self",(char *) "datetime", NULL
21858 };
21859
21860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21862 if (SWIG_arg_fail(1)) SWIG_fail;
21863 {
21864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21865 if (SWIG_arg_fail(2)) SWIG_fail;
21866 if (arg2 == NULL) {
21867 SWIG_null_ref("wxDateTime");
21868 }
21869 if (SWIG_arg_fail(2)) SWIG_fail;
21870 }
21871 {
21872 PyThreadState* __tstate = wxPyBeginAllowThreads();
21873 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21874
21875 wxPyEndAllowThreads(__tstate);
21876 if (PyErr_Occurred()) SWIG_fail;
21877 }
21878 {
21879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21880 }
21881 return resultobj;
21882 fail:
21883 return NULL;
21884 }
21885
21886
21887 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21888 PyObject *resultobj;
21889 wxDateTime *arg1 = (wxDateTime *) 0 ;
21890 wxDateTime *arg2 = 0 ;
21891 bool result;
21892 PyObject * obj0 = 0 ;
21893 PyObject * obj1 = 0 ;
21894 char *kwnames[] = {
21895 (char *) "self",(char *) "datetime", NULL
21896 };
21897
21898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21900 if (SWIG_arg_fail(1)) SWIG_fail;
21901 {
21902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21903 if (SWIG_arg_fail(2)) SWIG_fail;
21904 if (arg2 == NULL) {
21905 SWIG_null_ref("wxDateTime");
21906 }
21907 if (SWIG_arg_fail(2)) SWIG_fail;
21908 }
21909 {
21910 PyThreadState* __tstate = wxPyBeginAllowThreads();
21911 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21912
21913 wxPyEndAllowThreads(__tstate);
21914 if (PyErr_Occurred()) SWIG_fail;
21915 }
21916 {
21917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21918 }
21919 return resultobj;
21920 fail:
21921 return NULL;
21922 }
21923
21924
21925 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21926 PyObject *resultobj;
21927 wxDateTime *arg1 = (wxDateTime *) 0 ;
21928 wxDateTime *arg2 = 0 ;
21929 wxDateTime *arg3 = 0 ;
21930 bool result;
21931 PyObject * obj0 = 0 ;
21932 PyObject * obj1 = 0 ;
21933 PyObject * obj2 = 0 ;
21934 char *kwnames[] = {
21935 (char *) "self",(char *) "t1",(char *) "t2", NULL
21936 };
21937
21938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21940 if (SWIG_arg_fail(1)) SWIG_fail;
21941 {
21942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21943 if (SWIG_arg_fail(2)) SWIG_fail;
21944 if (arg2 == NULL) {
21945 SWIG_null_ref("wxDateTime");
21946 }
21947 if (SWIG_arg_fail(2)) SWIG_fail;
21948 }
21949 {
21950 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21951 if (SWIG_arg_fail(3)) SWIG_fail;
21952 if (arg3 == NULL) {
21953 SWIG_null_ref("wxDateTime");
21954 }
21955 if (SWIG_arg_fail(3)) SWIG_fail;
21956 }
21957 {
21958 PyThreadState* __tstate = wxPyBeginAllowThreads();
21959 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21960
21961 wxPyEndAllowThreads(__tstate);
21962 if (PyErr_Occurred()) SWIG_fail;
21963 }
21964 {
21965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21966 }
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21974 PyObject *resultobj;
21975 wxDateTime *arg1 = (wxDateTime *) 0 ;
21976 wxDateTime *arg2 = 0 ;
21977 wxDateTime *arg3 = 0 ;
21978 bool result;
21979 PyObject * obj0 = 0 ;
21980 PyObject * obj1 = 0 ;
21981 PyObject * obj2 = 0 ;
21982 char *kwnames[] = {
21983 (char *) "self",(char *) "t1",(char *) "t2", NULL
21984 };
21985
21986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21988 if (SWIG_arg_fail(1)) SWIG_fail;
21989 {
21990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21991 if (SWIG_arg_fail(2)) SWIG_fail;
21992 if (arg2 == NULL) {
21993 SWIG_null_ref("wxDateTime");
21994 }
21995 if (SWIG_arg_fail(2)) SWIG_fail;
21996 }
21997 {
21998 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21999 if (SWIG_arg_fail(3)) SWIG_fail;
22000 if (arg3 == NULL) {
22001 SWIG_null_ref("wxDateTime");
22002 }
22003 if (SWIG_arg_fail(3)) SWIG_fail;
22004 }
22005 {
22006 PyThreadState* __tstate = wxPyBeginAllowThreads();
22007 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22008
22009 wxPyEndAllowThreads(__tstate);
22010 if (PyErr_Occurred()) SWIG_fail;
22011 }
22012 {
22013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22014 }
22015 return resultobj;
22016 fail:
22017 return NULL;
22018 }
22019
22020
22021 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22022 PyObject *resultobj;
22023 wxDateTime *arg1 = (wxDateTime *) 0 ;
22024 wxDateTime *arg2 = 0 ;
22025 bool result;
22026 PyObject * obj0 = 0 ;
22027 PyObject * obj1 = 0 ;
22028 char *kwnames[] = {
22029 (char *) "self",(char *) "dt", NULL
22030 };
22031
22032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22034 if (SWIG_arg_fail(1)) SWIG_fail;
22035 {
22036 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22037 if (SWIG_arg_fail(2)) SWIG_fail;
22038 if (arg2 == NULL) {
22039 SWIG_null_ref("wxDateTime");
22040 }
22041 if (SWIG_arg_fail(2)) SWIG_fail;
22042 }
22043 {
22044 PyThreadState* __tstate = wxPyBeginAllowThreads();
22045 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22046
22047 wxPyEndAllowThreads(__tstate);
22048 if (PyErr_Occurred()) SWIG_fail;
22049 }
22050 {
22051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22052 }
22053 return resultobj;
22054 fail:
22055 return NULL;
22056 }
22057
22058
22059 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22060 PyObject *resultobj;
22061 wxDateTime *arg1 = (wxDateTime *) 0 ;
22062 wxDateTime *arg2 = 0 ;
22063 bool result;
22064 PyObject * obj0 = 0 ;
22065 PyObject * obj1 = 0 ;
22066 char *kwnames[] = {
22067 (char *) "self",(char *) "dt", NULL
22068 };
22069
22070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22072 if (SWIG_arg_fail(1)) SWIG_fail;
22073 {
22074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22075 if (SWIG_arg_fail(2)) SWIG_fail;
22076 if (arg2 == NULL) {
22077 SWIG_null_ref("wxDateTime");
22078 }
22079 if (SWIG_arg_fail(2)) SWIG_fail;
22080 }
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22084
22085 wxPyEndAllowThreads(__tstate);
22086 if (PyErr_Occurred()) SWIG_fail;
22087 }
22088 {
22089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22090 }
22091 return resultobj;
22092 fail:
22093 return NULL;
22094 }
22095
22096
22097 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22098 PyObject *resultobj;
22099 wxDateTime *arg1 = (wxDateTime *) 0 ;
22100 wxDateTime *arg2 = 0 ;
22101 wxTimeSpan *arg3 = 0 ;
22102 bool result;
22103 PyObject * obj0 = 0 ;
22104 PyObject * obj1 = 0 ;
22105 PyObject * obj2 = 0 ;
22106 char *kwnames[] = {
22107 (char *) "self",(char *) "dt",(char *) "ts", NULL
22108 };
22109
22110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22112 if (SWIG_arg_fail(1)) SWIG_fail;
22113 {
22114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22115 if (SWIG_arg_fail(2)) SWIG_fail;
22116 if (arg2 == NULL) {
22117 SWIG_null_ref("wxDateTime");
22118 }
22119 if (SWIG_arg_fail(2)) SWIG_fail;
22120 }
22121 {
22122 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22123 if (SWIG_arg_fail(3)) SWIG_fail;
22124 if (arg3 == NULL) {
22125 SWIG_null_ref("wxTimeSpan");
22126 }
22127 if (SWIG_arg_fail(3)) SWIG_fail;
22128 }
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22132
22133 wxPyEndAllowThreads(__tstate);
22134 if (PyErr_Occurred()) SWIG_fail;
22135 }
22136 {
22137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22138 }
22139 return resultobj;
22140 fail:
22141 return NULL;
22142 }
22143
22144
22145 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22146 PyObject *resultobj;
22147 wxDateTime *arg1 = (wxDateTime *) 0 ;
22148 wxTimeSpan *arg2 = 0 ;
22149 wxDateTime *result;
22150 PyObject * obj0 = 0 ;
22151 PyObject * obj1 = 0 ;
22152 char *kwnames[] = {
22153 (char *) "self",(char *) "diff", NULL
22154 };
22155
22156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22158 if (SWIG_arg_fail(1)) SWIG_fail;
22159 {
22160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22161 if (SWIG_arg_fail(2)) SWIG_fail;
22162 if (arg2 == NULL) {
22163 SWIG_null_ref("wxTimeSpan");
22164 }
22165 if (SWIG_arg_fail(2)) SWIG_fail;
22166 }
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 {
22170 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22171 result = (wxDateTime *) &_result_ref;
22172 }
22173
22174 wxPyEndAllowThreads(__tstate);
22175 if (PyErr_Occurred()) SWIG_fail;
22176 }
22177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22178 return resultobj;
22179 fail:
22180 return NULL;
22181 }
22182
22183
22184 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22185 PyObject *resultobj;
22186 wxDateTime *arg1 = (wxDateTime *) 0 ;
22187 wxDateSpan *arg2 = 0 ;
22188 wxDateTime *result;
22189 PyObject * obj0 = 0 ;
22190 PyObject * obj1 = 0 ;
22191 char *kwnames[] = {
22192 (char *) "self",(char *) "diff", NULL
22193 };
22194
22195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22197 if (SWIG_arg_fail(1)) SWIG_fail;
22198 {
22199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22200 if (SWIG_arg_fail(2)) SWIG_fail;
22201 if (arg2 == NULL) {
22202 SWIG_null_ref("wxDateSpan");
22203 }
22204 if (SWIG_arg_fail(2)) SWIG_fail;
22205 }
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 {
22209 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22210 result = (wxDateTime *) &_result_ref;
22211 }
22212
22213 wxPyEndAllowThreads(__tstate);
22214 if (PyErr_Occurred()) SWIG_fail;
22215 }
22216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22217 return resultobj;
22218 fail:
22219 return NULL;
22220 }
22221
22222
22223 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22224 PyObject *resultobj;
22225 wxDateTime *arg1 = (wxDateTime *) 0 ;
22226 wxTimeSpan *arg2 = 0 ;
22227 wxDateTime *result;
22228 PyObject * obj0 = 0 ;
22229 PyObject * obj1 = 0 ;
22230 char *kwnames[] = {
22231 (char *) "self",(char *) "diff", NULL
22232 };
22233
22234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22236 if (SWIG_arg_fail(1)) SWIG_fail;
22237 {
22238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22239 if (SWIG_arg_fail(2)) SWIG_fail;
22240 if (arg2 == NULL) {
22241 SWIG_null_ref("wxTimeSpan");
22242 }
22243 if (SWIG_arg_fail(2)) SWIG_fail;
22244 }
22245 {
22246 PyThreadState* __tstate = wxPyBeginAllowThreads();
22247 {
22248 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22249 result = (wxDateTime *) &_result_ref;
22250 }
22251
22252 wxPyEndAllowThreads(__tstate);
22253 if (PyErr_Occurred()) SWIG_fail;
22254 }
22255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22263 PyObject *resultobj;
22264 wxDateTime *arg1 = (wxDateTime *) 0 ;
22265 wxDateSpan *arg2 = 0 ;
22266 wxDateTime *result;
22267 PyObject * obj0 = 0 ;
22268 PyObject * obj1 = 0 ;
22269 char *kwnames[] = {
22270 (char *) "self",(char *) "diff", NULL
22271 };
22272
22273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22275 if (SWIG_arg_fail(1)) SWIG_fail;
22276 {
22277 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22278 if (SWIG_arg_fail(2)) SWIG_fail;
22279 if (arg2 == NULL) {
22280 SWIG_null_ref("wxDateSpan");
22281 }
22282 if (SWIG_arg_fail(2)) SWIG_fail;
22283 }
22284 {
22285 PyThreadState* __tstate = wxPyBeginAllowThreads();
22286 {
22287 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22288 result = (wxDateTime *) &_result_ref;
22289 }
22290
22291 wxPyEndAllowThreads(__tstate);
22292 if (PyErr_Occurred()) SWIG_fail;
22293 }
22294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22295 return resultobj;
22296 fail:
22297 return NULL;
22298 }
22299
22300
22301 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22302 PyObject *resultobj;
22303 wxDateTime *arg1 = (wxDateTime *) 0 ;
22304 wxDateTime *arg2 = 0 ;
22305 wxTimeSpan result;
22306 PyObject * obj0 = 0 ;
22307 PyObject * obj1 = 0 ;
22308 char *kwnames[] = {
22309 (char *) "self",(char *) "dt", NULL
22310 };
22311
22312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22314 if (SWIG_arg_fail(1)) SWIG_fail;
22315 {
22316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22317 if (SWIG_arg_fail(2)) SWIG_fail;
22318 if (arg2 == NULL) {
22319 SWIG_null_ref("wxDateTime");
22320 }
22321 if (SWIG_arg_fail(2)) SWIG_fail;
22322 }
22323 {
22324 PyThreadState* __tstate = wxPyBeginAllowThreads();
22325 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22326
22327 wxPyEndAllowThreads(__tstate);
22328 if (PyErr_Occurred()) SWIG_fail;
22329 }
22330 {
22331 wxTimeSpan * resultptr;
22332 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22334 }
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22342 PyObject *resultobj;
22343 wxDateTime *arg1 = (wxDateTime *) 0 ;
22344 wxTimeSpan *arg2 = 0 ;
22345 wxDateTime *result;
22346 PyObject * obj0 = 0 ;
22347 PyObject * obj1 = 0 ;
22348
22349 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22351 if (SWIG_arg_fail(1)) SWIG_fail;
22352 {
22353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22354 if (SWIG_arg_fail(2)) SWIG_fail;
22355 if (arg2 == NULL) {
22356 SWIG_null_ref("wxTimeSpan");
22357 }
22358 if (SWIG_arg_fail(2)) SWIG_fail;
22359 }
22360 {
22361 PyThreadState* __tstate = wxPyBeginAllowThreads();
22362 {
22363 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22364 result = (wxDateTime *) &_result_ref;
22365 }
22366
22367 wxPyEndAllowThreads(__tstate);
22368 if (PyErr_Occurred()) SWIG_fail;
22369 }
22370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22371 return resultobj;
22372 fail:
22373 return NULL;
22374 }
22375
22376
22377 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22378 PyObject *resultobj;
22379 wxDateTime *arg1 = (wxDateTime *) 0 ;
22380 wxDateSpan *arg2 = 0 ;
22381 wxDateTime *result;
22382 PyObject * obj0 = 0 ;
22383 PyObject * obj1 = 0 ;
22384
22385 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22387 if (SWIG_arg_fail(1)) SWIG_fail;
22388 {
22389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22390 if (SWIG_arg_fail(2)) SWIG_fail;
22391 if (arg2 == NULL) {
22392 SWIG_null_ref("wxDateSpan");
22393 }
22394 if (SWIG_arg_fail(2)) SWIG_fail;
22395 }
22396 {
22397 PyThreadState* __tstate = wxPyBeginAllowThreads();
22398 {
22399 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22400 result = (wxDateTime *) &_result_ref;
22401 }
22402
22403 wxPyEndAllowThreads(__tstate);
22404 if (PyErr_Occurred()) SWIG_fail;
22405 }
22406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22407 return resultobj;
22408 fail:
22409 return NULL;
22410 }
22411
22412
22413 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22414 int argc;
22415 PyObject *argv[3];
22416 int ii;
22417
22418 argc = PyObject_Length(args);
22419 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22420 argv[ii] = PyTuple_GetItem(args,ii);
22421 }
22422 if (argc == 2) {
22423 int _v;
22424 {
22425 void *ptr;
22426 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22427 _v = 0;
22428 PyErr_Clear();
22429 } else {
22430 _v = 1;
22431 }
22432 }
22433 if (_v) {
22434 {
22435 void *ptr = 0;
22436 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22437 _v = 0;
22438 PyErr_Clear();
22439 } else {
22440 _v = (ptr != 0);
22441 }
22442 }
22443 if (_v) {
22444 return _wrap_DateTime___iadd____SWIG_0(self,args);
22445 }
22446 }
22447 }
22448 if (argc == 2) {
22449 int _v;
22450 {
22451 void *ptr;
22452 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22453 _v = 0;
22454 PyErr_Clear();
22455 } else {
22456 _v = 1;
22457 }
22458 }
22459 if (_v) {
22460 {
22461 void *ptr = 0;
22462 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22463 _v = 0;
22464 PyErr_Clear();
22465 } else {
22466 _v = (ptr != 0);
22467 }
22468 }
22469 if (_v) {
22470 return _wrap_DateTime___iadd____SWIG_1(self,args);
22471 }
22472 }
22473 }
22474
22475 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22476 return NULL;
22477 }
22478
22479
22480 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22481 PyObject *resultobj;
22482 wxDateTime *arg1 = (wxDateTime *) 0 ;
22483 wxTimeSpan *arg2 = 0 ;
22484 wxDateTime *result;
22485 PyObject * obj0 = 0 ;
22486 PyObject * obj1 = 0 ;
22487
22488 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22490 if (SWIG_arg_fail(1)) SWIG_fail;
22491 {
22492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22493 if (SWIG_arg_fail(2)) SWIG_fail;
22494 if (arg2 == NULL) {
22495 SWIG_null_ref("wxTimeSpan");
22496 }
22497 if (SWIG_arg_fail(2)) SWIG_fail;
22498 }
22499 {
22500 PyThreadState* __tstate = wxPyBeginAllowThreads();
22501 {
22502 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22503 result = (wxDateTime *) &_result_ref;
22504 }
22505
22506 wxPyEndAllowThreads(__tstate);
22507 if (PyErr_Occurred()) SWIG_fail;
22508 }
22509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22510 return resultobj;
22511 fail:
22512 return NULL;
22513 }
22514
22515
22516 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22517 PyObject *resultobj;
22518 wxDateTime *arg1 = (wxDateTime *) 0 ;
22519 wxDateSpan *arg2 = 0 ;
22520 wxDateTime *result;
22521 PyObject * obj0 = 0 ;
22522 PyObject * obj1 = 0 ;
22523
22524 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22526 if (SWIG_arg_fail(1)) SWIG_fail;
22527 {
22528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22529 if (SWIG_arg_fail(2)) SWIG_fail;
22530 if (arg2 == NULL) {
22531 SWIG_null_ref("wxDateSpan");
22532 }
22533 if (SWIG_arg_fail(2)) SWIG_fail;
22534 }
22535 {
22536 PyThreadState* __tstate = wxPyBeginAllowThreads();
22537 {
22538 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22539 result = (wxDateTime *) &_result_ref;
22540 }
22541
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22553 int argc;
22554 PyObject *argv[3];
22555 int ii;
22556
22557 argc = PyObject_Length(args);
22558 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22559 argv[ii] = PyTuple_GetItem(args,ii);
22560 }
22561 if (argc == 2) {
22562 int _v;
22563 {
22564 void *ptr;
22565 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22566 _v = 0;
22567 PyErr_Clear();
22568 } else {
22569 _v = 1;
22570 }
22571 }
22572 if (_v) {
22573 {
22574 void *ptr = 0;
22575 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22576 _v = 0;
22577 PyErr_Clear();
22578 } else {
22579 _v = (ptr != 0);
22580 }
22581 }
22582 if (_v) {
22583 return _wrap_DateTime___isub____SWIG_0(self,args);
22584 }
22585 }
22586 }
22587 if (argc == 2) {
22588 int _v;
22589 {
22590 void *ptr;
22591 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22592 _v = 0;
22593 PyErr_Clear();
22594 } else {
22595 _v = 1;
22596 }
22597 }
22598 if (_v) {
22599 {
22600 void *ptr = 0;
22601 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22602 _v = 0;
22603 PyErr_Clear();
22604 } else {
22605 _v = (ptr != 0);
22606 }
22607 }
22608 if (_v) {
22609 return _wrap_DateTime___isub____SWIG_1(self,args);
22610 }
22611 }
22612 }
22613
22614 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22615 return NULL;
22616 }
22617
22618
22619 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22620 PyObject *resultobj;
22621 wxDateTime *arg1 = (wxDateTime *) 0 ;
22622 wxTimeSpan *arg2 = 0 ;
22623 wxDateTime result;
22624 PyObject * obj0 = 0 ;
22625 PyObject * obj1 = 0 ;
22626
22627 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22629 if (SWIG_arg_fail(1)) SWIG_fail;
22630 {
22631 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22632 if (SWIG_arg_fail(2)) SWIG_fail;
22633 if (arg2 == NULL) {
22634 SWIG_null_ref("wxTimeSpan");
22635 }
22636 if (SWIG_arg_fail(2)) SWIG_fail;
22637 }
22638 {
22639 PyThreadState* __tstate = wxPyBeginAllowThreads();
22640 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22641
22642 wxPyEndAllowThreads(__tstate);
22643 if (PyErr_Occurred()) SWIG_fail;
22644 }
22645 {
22646 wxDateTime * resultptr;
22647 resultptr = new wxDateTime((wxDateTime &)(result));
22648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22649 }
22650 return resultobj;
22651 fail:
22652 return NULL;
22653 }
22654
22655
22656 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22657 PyObject *resultobj;
22658 wxDateTime *arg1 = (wxDateTime *) 0 ;
22659 wxDateSpan *arg2 = 0 ;
22660 wxDateTime result;
22661 PyObject * obj0 = 0 ;
22662 PyObject * obj1 = 0 ;
22663
22664 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22666 if (SWIG_arg_fail(1)) SWIG_fail;
22667 {
22668 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22669 if (SWIG_arg_fail(2)) SWIG_fail;
22670 if (arg2 == NULL) {
22671 SWIG_null_ref("wxDateSpan");
22672 }
22673 if (SWIG_arg_fail(2)) SWIG_fail;
22674 }
22675 {
22676 PyThreadState* __tstate = wxPyBeginAllowThreads();
22677 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22678
22679 wxPyEndAllowThreads(__tstate);
22680 if (PyErr_Occurred()) SWIG_fail;
22681 }
22682 {
22683 wxDateTime * resultptr;
22684 resultptr = new wxDateTime((wxDateTime &)(result));
22685 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22686 }
22687 return resultobj;
22688 fail:
22689 return NULL;
22690 }
22691
22692
22693 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22694 int argc;
22695 PyObject *argv[3];
22696 int ii;
22697
22698 argc = PyObject_Length(args);
22699 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22700 argv[ii] = PyTuple_GetItem(args,ii);
22701 }
22702 if (argc == 2) {
22703 int _v;
22704 {
22705 void *ptr;
22706 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22707 _v = 0;
22708 PyErr_Clear();
22709 } else {
22710 _v = 1;
22711 }
22712 }
22713 if (_v) {
22714 {
22715 void *ptr = 0;
22716 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22717 _v = 0;
22718 PyErr_Clear();
22719 } else {
22720 _v = (ptr != 0);
22721 }
22722 }
22723 if (_v) {
22724 return _wrap_DateTime___add____SWIG_0(self,args);
22725 }
22726 }
22727 }
22728 if (argc == 2) {
22729 int _v;
22730 {
22731 void *ptr;
22732 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22733 _v = 0;
22734 PyErr_Clear();
22735 } else {
22736 _v = 1;
22737 }
22738 }
22739 if (_v) {
22740 {
22741 void *ptr = 0;
22742 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22743 _v = 0;
22744 PyErr_Clear();
22745 } else {
22746 _v = (ptr != 0);
22747 }
22748 }
22749 if (_v) {
22750 return _wrap_DateTime___add____SWIG_1(self,args);
22751 }
22752 }
22753 }
22754
22755 Py_INCREF(Py_NotImplemented);
22756 return Py_NotImplemented;
22757 }
22758
22759
22760 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22761 PyObject *resultobj;
22762 wxDateTime *arg1 = (wxDateTime *) 0 ;
22763 wxDateTime *arg2 = 0 ;
22764 wxTimeSpan result;
22765 PyObject * obj0 = 0 ;
22766 PyObject * obj1 = 0 ;
22767
22768 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22770 if (SWIG_arg_fail(1)) SWIG_fail;
22771 {
22772 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22773 if (SWIG_arg_fail(2)) SWIG_fail;
22774 if (arg2 == NULL) {
22775 SWIG_null_ref("wxDateTime");
22776 }
22777 if (SWIG_arg_fail(2)) SWIG_fail;
22778 }
22779 {
22780 PyThreadState* __tstate = wxPyBeginAllowThreads();
22781 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22782
22783 wxPyEndAllowThreads(__tstate);
22784 if (PyErr_Occurred()) SWIG_fail;
22785 }
22786 {
22787 wxTimeSpan * resultptr;
22788 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22790 }
22791 return resultobj;
22792 fail:
22793 return NULL;
22794 }
22795
22796
22797 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22798 PyObject *resultobj;
22799 wxDateTime *arg1 = (wxDateTime *) 0 ;
22800 wxTimeSpan *arg2 = 0 ;
22801 wxDateTime result;
22802 PyObject * obj0 = 0 ;
22803 PyObject * obj1 = 0 ;
22804
22805 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22807 if (SWIG_arg_fail(1)) SWIG_fail;
22808 {
22809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22810 if (SWIG_arg_fail(2)) SWIG_fail;
22811 if (arg2 == NULL) {
22812 SWIG_null_ref("wxTimeSpan");
22813 }
22814 if (SWIG_arg_fail(2)) SWIG_fail;
22815 }
22816 {
22817 PyThreadState* __tstate = wxPyBeginAllowThreads();
22818 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22819
22820 wxPyEndAllowThreads(__tstate);
22821 if (PyErr_Occurred()) SWIG_fail;
22822 }
22823 {
22824 wxDateTime * resultptr;
22825 resultptr = new wxDateTime((wxDateTime &)(result));
22826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22827 }
22828 return resultobj;
22829 fail:
22830 return NULL;
22831 }
22832
22833
22834 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22835 PyObject *resultobj;
22836 wxDateTime *arg1 = (wxDateTime *) 0 ;
22837 wxDateSpan *arg2 = 0 ;
22838 wxDateTime result;
22839 PyObject * obj0 = 0 ;
22840 PyObject * obj1 = 0 ;
22841
22842 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22844 if (SWIG_arg_fail(1)) SWIG_fail;
22845 {
22846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22847 if (SWIG_arg_fail(2)) SWIG_fail;
22848 if (arg2 == NULL) {
22849 SWIG_null_ref("wxDateSpan");
22850 }
22851 if (SWIG_arg_fail(2)) SWIG_fail;
22852 }
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22856
22857 wxPyEndAllowThreads(__tstate);
22858 if (PyErr_Occurred()) SWIG_fail;
22859 }
22860 {
22861 wxDateTime * resultptr;
22862 resultptr = new wxDateTime((wxDateTime &)(result));
22863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22864 }
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22872 int argc;
22873 PyObject *argv[3];
22874 int ii;
22875
22876 argc = PyObject_Length(args);
22877 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22878 argv[ii] = PyTuple_GetItem(args,ii);
22879 }
22880 if (argc == 2) {
22881 int _v;
22882 {
22883 void *ptr;
22884 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22885 _v = 0;
22886 PyErr_Clear();
22887 } else {
22888 _v = 1;
22889 }
22890 }
22891 if (_v) {
22892 {
22893 void *ptr = 0;
22894 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22895 _v = 0;
22896 PyErr_Clear();
22897 } else {
22898 _v = (ptr != 0);
22899 }
22900 }
22901 if (_v) {
22902 return _wrap_DateTime___sub____SWIG_0(self,args);
22903 }
22904 }
22905 }
22906 if (argc == 2) {
22907 int _v;
22908 {
22909 void *ptr;
22910 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22911 _v = 0;
22912 PyErr_Clear();
22913 } else {
22914 _v = 1;
22915 }
22916 }
22917 if (_v) {
22918 {
22919 void *ptr = 0;
22920 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22921 _v = 0;
22922 PyErr_Clear();
22923 } else {
22924 _v = (ptr != 0);
22925 }
22926 }
22927 if (_v) {
22928 return _wrap_DateTime___sub____SWIG_1(self,args);
22929 }
22930 }
22931 }
22932 if (argc == 2) {
22933 int _v;
22934 {
22935 void *ptr;
22936 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22937 _v = 0;
22938 PyErr_Clear();
22939 } else {
22940 _v = 1;
22941 }
22942 }
22943 if (_v) {
22944 {
22945 void *ptr = 0;
22946 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22947 _v = 0;
22948 PyErr_Clear();
22949 } else {
22950 _v = (ptr != 0);
22951 }
22952 }
22953 if (_v) {
22954 return _wrap_DateTime___sub____SWIG_2(self,args);
22955 }
22956 }
22957 }
22958
22959 Py_INCREF(Py_NotImplemented);
22960 return Py_NotImplemented;
22961 }
22962
22963
22964 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args) {
22965 PyObject *resultobj;
22966 wxDateTime *arg1 = (wxDateTime *) 0 ;
22967 wxDateTime *arg2 = (wxDateTime *) 0 ;
22968 bool result;
22969 PyObject * obj0 = 0 ;
22970 PyObject * obj1 = 0 ;
22971
22972 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___lt__",&obj0,&obj1)) goto fail;
22973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22974 if (SWIG_arg_fail(1)) SWIG_fail;
22975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22976 if (SWIG_arg_fail(2)) SWIG_fail;
22977 {
22978 PyThreadState* __tstate = wxPyBeginAllowThreads();
22979 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22980
22981 wxPyEndAllowThreads(__tstate);
22982 if (PyErr_Occurred()) SWIG_fail;
22983 }
22984 {
22985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22986 }
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args) {
22994 PyObject *resultobj;
22995 wxDateTime *arg1 = (wxDateTime *) 0 ;
22996 wxDateTime *arg2 = (wxDateTime *) 0 ;
22997 bool result;
22998 PyObject * obj0 = 0 ;
22999 PyObject * obj1 = 0 ;
23000
23001 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___le__",&obj0,&obj1)) goto fail;
23002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23003 if (SWIG_arg_fail(1)) SWIG_fail;
23004 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23005 if (SWIG_arg_fail(2)) SWIG_fail;
23006 {
23007 PyThreadState* __tstate = wxPyBeginAllowThreads();
23008 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23009
23010 wxPyEndAllowThreads(__tstate);
23011 if (PyErr_Occurred()) SWIG_fail;
23012 }
23013 {
23014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23015 }
23016 return resultobj;
23017 fail:
23018 return NULL;
23019 }
23020
23021
23022 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args) {
23023 PyObject *resultobj;
23024 wxDateTime *arg1 = (wxDateTime *) 0 ;
23025 wxDateTime *arg2 = (wxDateTime *) 0 ;
23026 bool result;
23027 PyObject * obj0 = 0 ;
23028 PyObject * obj1 = 0 ;
23029
23030 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___gt__",&obj0,&obj1)) goto fail;
23031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23032 if (SWIG_arg_fail(1)) SWIG_fail;
23033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23034 if (SWIG_arg_fail(2)) SWIG_fail;
23035 {
23036 PyThreadState* __tstate = wxPyBeginAllowThreads();
23037 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23038
23039 wxPyEndAllowThreads(__tstate);
23040 if (PyErr_Occurred()) SWIG_fail;
23041 }
23042 {
23043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23044 }
23045 return resultobj;
23046 fail:
23047 return NULL;
23048 }
23049
23050
23051 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args) {
23052 PyObject *resultobj;
23053 wxDateTime *arg1 = (wxDateTime *) 0 ;
23054 wxDateTime *arg2 = (wxDateTime *) 0 ;
23055 bool result;
23056 PyObject * obj0 = 0 ;
23057 PyObject * obj1 = 0 ;
23058
23059 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ge__",&obj0,&obj1)) goto fail;
23060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23061 if (SWIG_arg_fail(1)) SWIG_fail;
23062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23063 if (SWIG_arg_fail(2)) SWIG_fail;
23064 {
23065 PyThreadState* __tstate = wxPyBeginAllowThreads();
23066 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23067
23068 wxPyEndAllowThreads(__tstate);
23069 if (PyErr_Occurred()) SWIG_fail;
23070 }
23071 {
23072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23073 }
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args) {
23081 PyObject *resultobj;
23082 wxDateTime *arg1 = (wxDateTime *) 0 ;
23083 wxDateTime *arg2 = (wxDateTime *) 0 ;
23084 bool result;
23085 PyObject * obj0 = 0 ;
23086 PyObject * obj1 = 0 ;
23087
23088 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___eq__",&obj0,&obj1)) goto fail;
23089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23090 if (SWIG_arg_fail(1)) SWIG_fail;
23091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23092 if (SWIG_arg_fail(2)) SWIG_fail;
23093 {
23094 PyThreadState* __tstate = wxPyBeginAllowThreads();
23095 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23096
23097 wxPyEndAllowThreads(__tstate);
23098 if (PyErr_Occurred()) SWIG_fail;
23099 }
23100 {
23101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23102 }
23103 return resultobj;
23104 fail:
23105 return NULL;
23106 }
23107
23108
23109 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args) {
23110 PyObject *resultobj;
23111 wxDateTime *arg1 = (wxDateTime *) 0 ;
23112 wxDateTime *arg2 = (wxDateTime *) 0 ;
23113 bool result;
23114 PyObject * obj0 = 0 ;
23115 PyObject * obj1 = 0 ;
23116
23117 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ne__",&obj0,&obj1)) goto fail;
23118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23119 if (SWIG_arg_fail(1)) SWIG_fail;
23120 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23121 if (SWIG_arg_fail(2)) SWIG_fail;
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23125
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 {
23130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23131 }
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23139 PyObject *resultobj;
23140 wxDateTime *arg1 = (wxDateTime *) 0 ;
23141 wxString *arg2 = 0 ;
23142 int result;
23143 bool temp2 = false ;
23144 PyObject * obj0 = 0 ;
23145 PyObject * obj1 = 0 ;
23146 char *kwnames[] = {
23147 (char *) "self",(char *) "date", NULL
23148 };
23149
23150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23152 if (SWIG_arg_fail(1)) SWIG_fail;
23153 {
23154 arg2 = wxString_in_helper(obj1);
23155 if (arg2 == NULL) SWIG_fail;
23156 temp2 = true;
23157 }
23158 {
23159 PyThreadState* __tstate = wxPyBeginAllowThreads();
23160 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23161
23162 wxPyEndAllowThreads(__tstate);
23163 if (PyErr_Occurred()) SWIG_fail;
23164 }
23165 {
23166 resultobj = SWIG_From_int((int)(result));
23167 }
23168 {
23169 if (temp2)
23170 delete arg2;
23171 }
23172 return resultobj;
23173 fail:
23174 {
23175 if (temp2)
23176 delete arg2;
23177 }
23178 return NULL;
23179 }
23180
23181
23182 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23183 PyObject *resultobj;
23184 wxDateTime *arg1 = (wxDateTime *) 0 ;
23185 wxString *arg2 = 0 ;
23186 wxString const &arg3_defvalue = wxPyDateFormatStr ;
23187 wxString *arg3 = (wxString *) &arg3_defvalue ;
23188 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23189 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23190 int result;
23191 bool temp2 = false ;
23192 bool temp3 = false ;
23193 PyObject * obj0 = 0 ;
23194 PyObject * obj1 = 0 ;
23195 PyObject * obj2 = 0 ;
23196 PyObject * obj3 = 0 ;
23197 char *kwnames[] = {
23198 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23199 };
23200
23201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23203 if (SWIG_arg_fail(1)) SWIG_fail;
23204 {
23205 arg2 = wxString_in_helper(obj1);
23206 if (arg2 == NULL) SWIG_fail;
23207 temp2 = true;
23208 }
23209 if (obj2) {
23210 {
23211 arg3 = wxString_in_helper(obj2);
23212 if (arg3 == NULL) SWIG_fail;
23213 temp3 = true;
23214 }
23215 }
23216 if (obj3) {
23217 {
23218 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23219 if (SWIG_arg_fail(4)) SWIG_fail;
23220 if (arg4 == NULL) {
23221 SWIG_null_ref("wxDateTime");
23222 }
23223 if (SWIG_arg_fail(4)) SWIG_fail;
23224 }
23225 }
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23229
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 {
23234 resultobj = SWIG_From_int((int)(result));
23235 }
23236 {
23237 if (temp2)
23238 delete arg2;
23239 }
23240 {
23241 if (temp3)
23242 delete arg3;
23243 }
23244 return resultobj;
23245 fail:
23246 {
23247 if (temp2)
23248 delete arg2;
23249 }
23250 {
23251 if (temp3)
23252 delete arg3;
23253 }
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj;
23260 wxDateTime *arg1 = (wxDateTime *) 0 ;
23261 wxString *arg2 = 0 ;
23262 int result;
23263 bool temp2 = false ;
23264 PyObject * obj0 = 0 ;
23265 PyObject * obj1 = 0 ;
23266 char *kwnames[] = {
23267 (char *) "self",(char *) "datetime", NULL
23268 };
23269
23270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23272 if (SWIG_arg_fail(1)) SWIG_fail;
23273 {
23274 arg2 = wxString_in_helper(obj1);
23275 if (arg2 == NULL) SWIG_fail;
23276 temp2 = true;
23277 }
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23281
23282 wxPyEndAllowThreads(__tstate);
23283 if (PyErr_Occurred()) SWIG_fail;
23284 }
23285 {
23286 resultobj = SWIG_From_int((int)(result));
23287 }
23288 {
23289 if (temp2)
23290 delete arg2;
23291 }
23292 return resultobj;
23293 fail:
23294 {
23295 if (temp2)
23296 delete arg2;
23297 }
23298 return NULL;
23299 }
23300
23301
23302 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23303 PyObject *resultobj;
23304 wxDateTime *arg1 = (wxDateTime *) 0 ;
23305 wxString *arg2 = 0 ;
23306 int result;
23307 bool temp2 = false ;
23308 PyObject * obj0 = 0 ;
23309 PyObject * obj1 = 0 ;
23310 char *kwnames[] = {
23311 (char *) "self",(char *) "date", NULL
23312 };
23313
23314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23316 if (SWIG_arg_fail(1)) SWIG_fail;
23317 {
23318 arg2 = wxString_in_helper(obj1);
23319 if (arg2 == NULL) SWIG_fail;
23320 temp2 = true;
23321 }
23322 {
23323 PyThreadState* __tstate = wxPyBeginAllowThreads();
23324 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23325
23326 wxPyEndAllowThreads(__tstate);
23327 if (PyErr_Occurred()) SWIG_fail;
23328 }
23329 {
23330 resultobj = SWIG_From_int((int)(result));
23331 }
23332 {
23333 if (temp2)
23334 delete arg2;
23335 }
23336 return resultobj;
23337 fail:
23338 {
23339 if (temp2)
23340 delete arg2;
23341 }
23342 return NULL;
23343 }
23344
23345
23346 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23347 PyObject *resultobj;
23348 wxDateTime *arg1 = (wxDateTime *) 0 ;
23349 wxString *arg2 = 0 ;
23350 int result;
23351 bool temp2 = false ;
23352 PyObject * obj0 = 0 ;
23353 PyObject * obj1 = 0 ;
23354 char *kwnames[] = {
23355 (char *) "self",(char *) "time", NULL
23356 };
23357
23358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23360 if (SWIG_arg_fail(1)) SWIG_fail;
23361 {
23362 arg2 = wxString_in_helper(obj1);
23363 if (arg2 == NULL) SWIG_fail;
23364 temp2 = true;
23365 }
23366 {
23367 PyThreadState* __tstate = wxPyBeginAllowThreads();
23368 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23369
23370 wxPyEndAllowThreads(__tstate);
23371 if (PyErr_Occurred()) SWIG_fail;
23372 }
23373 {
23374 resultobj = SWIG_From_int((int)(result));
23375 }
23376 {
23377 if (temp2)
23378 delete arg2;
23379 }
23380 return resultobj;
23381 fail:
23382 {
23383 if (temp2)
23384 delete arg2;
23385 }
23386 return NULL;
23387 }
23388
23389
23390 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23391 PyObject *resultobj;
23392 wxDateTime *arg1 = (wxDateTime *) 0 ;
23393 wxString const &arg2_defvalue = wxPyDateFormatStr ;
23394 wxString *arg2 = (wxString *) &arg2_defvalue ;
23395 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23396 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23397 wxString result;
23398 bool temp2 = false ;
23399 bool temp3 = false ;
23400 PyObject * obj0 = 0 ;
23401 PyObject * obj1 = 0 ;
23402 PyObject * obj2 = 0 ;
23403 char *kwnames[] = {
23404 (char *) "self",(char *) "format",(char *) "tz", NULL
23405 };
23406
23407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23409 if (SWIG_arg_fail(1)) SWIG_fail;
23410 if (obj1) {
23411 {
23412 arg2 = wxString_in_helper(obj1);
23413 if (arg2 == NULL) SWIG_fail;
23414 temp2 = true;
23415 }
23416 }
23417 if (obj2) {
23418 {
23419 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23420 temp3 = true;
23421 }
23422 }
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23426
23427 wxPyEndAllowThreads(__tstate);
23428 if (PyErr_Occurred()) SWIG_fail;
23429 }
23430 {
23431 #if wxUSE_UNICODE
23432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23433 #else
23434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23435 #endif
23436 }
23437 {
23438 if (temp2)
23439 delete arg2;
23440 }
23441 {
23442 if (temp3) delete arg3;
23443 }
23444 return resultobj;
23445 fail:
23446 {
23447 if (temp2)
23448 delete arg2;
23449 }
23450 {
23451 if (temp3) delete arg3;
23452 }
23453 return NULL;
23454 }
23455
23456
23457 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23458 PyObject *resultobj;
23459 wxDateTime *arg1 = (wxDateTime *) 0 ;
23460 wxString result;
23461 PyObject * obj0 = 0 ;
23462 char *kwnames[] = {
23463 (char *) "self", NULL
23464 };
23465
23466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23468 if (SWIG_arg_fail(1)) SWIG_fail;
23469 {
23470 PyThreadState* __tstate = wxPyBeginAllowThreads();
23471 result = ((wxDateTime const *)arg1)->FormatDate();
23472
23473 wxPyEndAllowThreads(__tstate);
23474 if (PyErr_Occurred()) SWIG_fail;
23475 }
23476 {
23477 #if wxUSE_UNICODE
23478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23479 #else
23480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23481 #endif
23482 }
23483 return resultobj;
23484 fail:
23485 return NULL;
23486 }
23487
23488
23489 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23490 PyObject *resultobj;
23491 wxDateTime *arg1 = (wxDateTime *) 0 ;
23492 wxString result;
23493 PyObject * obj0 = 0 ;
23494 char *kwnames[] = {
23495 (char *) "self", NULL
23496 };
23497
23498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23500 if (SWIG_arg_fail(1)) SWIG_fail;
23501 {
23502 PyThreadState* __tstate = wxPyBeginAllowThreads();
23503 result = ((wxDateTime const *)arg1)->FormatTime();
23504
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 {
23509 #if wxUSE_UNICODE
23510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23511 #else
23512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23513 #endif
23514 }
23515 return resultobj;
23516 fail:
23517 return NULL;
23518 }
23519
23520
23521 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23522 PyObject *resultobj;
23523 wxDateTime *arg1 = (wxDateTime *) 0 ;
23524 wxString result;
23525 PyObject * obj0 = 0 ;
23526 char *kwnames[] = {
23527 (char *) "self", NULL
23528 };
23529
23530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23532 if (SWIG_arg_fail(1)) SWIG_fail;
23533 {
23534 PyThreadState* __tstate = wxPyBeginAllowThreads();
23535 result = ((wxDateTime const *)arg1)->FormatISODate();
23536
23537 wxPyEndAllowThreads(__tstate);
23538 if (PyErr_Occurred()) SWIG_fail;
23539 }
23540 {
23541 #if wxUSE_UNICODE
23542 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23543 #else
23544 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23545 #endif
23546 }
23547 return resultobj;
23548 fail:
23549 return NULL;
23550 }
23551
23552
23553 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23554 PyObject *resultobj;
23555 wxDateTime *arg1 = (wxDateTime *) 0 ;
23556 wxString result;
23557 PyObject * obj0 = 0 ;
23558 char *kwnames[] = {
23559 (char *) "self", NULL
23560 };
23561
23562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23564 if (SWIG_arg_fail(1)) SWIG_fail;
23565 {
23566 PyThreadState* __tstate = wxPyBeginAllowThreads();
23567 result = ((wxDateTime const *)arg1)->FormatISOTime();
23568
23569 wxPyEndAllowThreads(__tstate);
23570 if (PyErr_Occurred()) SWIG_fail;
23571 }
23572 {
23573 #if wxUSE_UNICODE
23574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23575 #else
23576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23577 #endif
23578 }
23579 return resultobj;
23580 fail:
23581 return NULL;
23582 }
23583
23584
23585 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23586 PyObject *obj;
23587 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23588 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23589 Py_INCREF(obj);
23590 return Py_BuildValue((char *)"");
23591 }
23592 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23593 PyObject *resultobj;
23594 long arg1 ;
23595 wxTimeSpan result;
23596 PyObject * obj0 = 0 ;
23597 char *kwnames[] = {
23598 (char *) "sec", NULL
23599 };
23600
23601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23602 {
23603 arg1 = (long)(SWIG_As_long(obj0));
23604 if (SWIG_arg_fail(1)) SWIG_fail;
23605 }
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = wxTimeSpan::Seconds(arg1);
23609
23610 wxPyEndAllowThreads(__tstate);
23611 if (PyErr_Occurred()) SWIG_fail;
23612 }
23613 {
23614 wxTimeSpan * resultptr;
23615 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23617 }
23618 return resultobj;
23619 fail:
23620 return NULL;
23621 }
23622
23623
23624 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23625 PyObject *resultobj;
23626 wxTimeSpan result;
23627 char *kwnames[] = {
23628 NULL
23629 };
23630
23631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 result = wxTimeSpan::Second();
23635
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 {
23640 wxTimeSpan * resultptr;
23641 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23643 }
23644 return resultobj;
23645 fail:
23646 return NULL;
23647 }
23648
23649
23650 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23651 PyObject *resultobj;
23652 long arg1 ;
23653 wxTimeSpan result;
23654 PyObject * obj0 = 0 ;
23655 char *kwnames[] = {
23656 (char *) "min", NULL
23657 };
23658
23659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23660 {
23661 arg1 = (long)(SWIG_As_long(obj0));
23662 if (SWIG_arg_fail(1)) SWIG_fail;
23663 }
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 result = wxTimeSpan::Minutes(arg1);
23667
23668 wxPyEndAllowThreads(__tstate);
23669 if (PyErr_Occurred()) SWIG_fail;
23670 }
23671 {
23672 wxTimeSpan * resultptr;
23673 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23674 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23675 }
23676 return resultobj;
23677 fail:
23678 return NULL;
23679 }
23680
23681
23682 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23683 PyObject *resultobj;
23684 wxTimeSpan result;
23685 char *kwnames[] = {
23686 NULL
23687 };
23688
23689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23690 {
23691 PyThreadState* __tstate = wxPyBeginAllowThreads();
23692 result = wxTimeSpan::Minute();
23693
23694 wxPyEndAllowThreads(__tstate);
23695 if (PyErr_Occurred()) SWIG_fail;
23696 }
23697 {
23698 wxTimeSpan * resultptr;
23699 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23700 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23701 }
23702 return resultobj;
23703 fail:
23704 return NULL;
23705 }
23706
23707
23708 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23709 PyObject *resultobj;
23710 long arg1 ;
23711 wxTimeSpan result;
23712 PyObject * obj0 = 0 ;
23713 char *kwnames[] = {
23714 (char *) "hours", NULL
23715 };
23716
23717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23718 {
23719 arg1 = (long)(SWIG_As_long(obj0));
23720 if (SWIG_arg_fail(1)) SWIG_fail;
23721 }
23722 {
23723 PyThreadState* __tstate = wxPyBeginAllowThreads();
23724 result = wxTimeSpan::Hours(arg1);
23725
23726 wxPyEndAllowThreads(__tstate);
23727 if (PyErr_Occurred()) SWIG_fail;
23728 }
23729 {
23730 wxTimeSpan * resultptr;
23731 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23732 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23733 }
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23741 PyObject *resultobj;
23742 wxTimeSpan result;
23743 char *kwnames[] = {
23744 NULL
23745 };
23746
23747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 result = wxTimeSpan::Hour();
23751
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 {
23756 wxTimeSpan * resultptr;
23757 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23758 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23759 }
23760 return resultobj;
23761 fail:
23762 return NULL;
23763 }
23764
23765
23766 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23767 PyObject *resultobj;
23768 long arg1 ;
23769 wxTimeSpan result;
23770 PyObject * obj0 = 0 ;
23771 char *kwnames[] = {
23772 (char *) "days", NULL
23773 };
23774
23775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23776 {
23777 arg1 = (long)(SWIG_As_long(obj0));
23778 if (SWIG_arg_fail(1)) SWIG_fail;
23779 }
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 result = wxTimeSpan::Days(arg1);
23783
23784 wxPyEndAllowThreads(__tstate);
23785 if (PyErr_Occurred()) SWIG_fail;
23786 }
23787 {
23788 wxTimeSpan * resultptr;
23789 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23790 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23791 }
23792 return resultobj;
23793 fail:
23794 return NULL;
23795 }
23796
23797
23798 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23799 PyObject *resultobj;
23800 wxTimeSpan result;
23801 char *kwnames[] = {
23802 NULL
23803 };
23804
23805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23806 {
23807 PyThreadState* __tstate = wxPyBeginAllowThreads();
23808 result = wxTimeSpan::Day();
23809
23810 wxPyEndAllowThreads(__tstate);
23811 if (PyErr_Occurred()) SWIG_fail;
23812 }
23813 {
23814 wxTimeSpan * resultptr;
23815 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23816 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23817 }
23818 return resultobj;
23819 fail:
23820 return NULL;
23821 }
23822
23823
23824 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23825 PyObject *resultobj;
23826 long arg1 ;
23827 wxTimeSpan result;
23828 PyObject * obj0 = 0 ;
23829 char *kwnames[] = {
23830 (char *) "days", NULL
23831 };
23832
23833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23834 {
23835 arg1 = (long)(SWIG_As_long(obj0));
23836 if (SWIG_arg_fail(1)) SWIG_fail;
23837 }
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = wxTimeSpan::Weeks(arg1);
23841
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 {
23846 wxTimeSpan * resultptr;
23847 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23848 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23849 }
23850 return resultobj;
23851 fail:
23852 return NULL;
23853 }
23854
23855
23856 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj;
23858 wxTimeSpan result;
23859 char *kwnames[] = {
23860 NULL
23861 };
23862
23863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23864 {
23865 PyThreadState* __tstate = wxPyBeginAllowThreads();
23866 result = wxTimeSpan::Week();
23867
23868 wxPyEndAllowThreads(__tstate);
23869 if (PyErr_Occurred()) SWIG_fail;
23870 }
23871 {
23872 wxTimeSpan * resultptr;
23873 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23874 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23875 }
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23883 PyObject *resultobj;
23884 long arg1 = (long) 0 ;
23885 long arg2 = (long) 0 ;
23886 long arg3 = (long) 0 ;
23887 long arg4 = (long) 0 ;
23888 wxTimeSpan *result;
23889 PyObject * obj0 = 0 ;
23890 PyObject * obj1 = 0 ;
23891 PyObject * obj2 = 0 ;
23892 PyObject * obj3 = 0 ;
23893 char *kwnames[] = {
23894 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23895 };
23896
23897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23898 if (obj0) {
23899 {
23900 arg1 = (long)(SWIG_As_long(obj0));
23901 if (SWIG_arg_fail(1)) SWIG_fail;
23902 }
23903 }
23904 if (obj1) {
23905 {
23906 arg2 = (long)(SWIG_As_long(obj1));
23907 if (SWIG_arg_fail(2)) SWIG_fail;
23908 }
23909 }
23910 if (obj2) {
23911 {
23912 arg3 = (long)(SWIG_As_long(obj2));
23913 if (SWIG_arg_fail(3)) SWIG_fail;
23914 }
23915 }
23916 if (obj3) {
23917 {
23918 arg4 = (long)(SWIG_As_long(obj3));
23919 if (SWIG_arg_fail(4)) SWIG_fail;
23920 }
23921 }
23922 {
23923 PyThreadState* __tstate = wxPyBeginAllowThreads();
23924 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23925
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23930 return resultobj;
23931 fail:
23932 return NULL;
23933 }
23934
23935
23936 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23937 PyObject *resultobj;
23938 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23939 PyObject * obj0 = 0 ;
23940 char *kwnames[] = {
23941 (char *) "self", NULL
23942 };
23943
23944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23946 if (SWIG_arg_fail(1)) SWIG_fail;
23947 {
23948 PyThreadState* __tstate = wxPyBeginAllowThreads();
23949 delete arg1;
23950
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 Py_INCREF(Py_None); resultobj = Py_None;
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23962 PyObject *resultobj;
23963 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23964 wxTimeSpan *arg2 = 0 ;
23965 wxTimeSpan *result;
23966 PyObject * obj0 = 0 ;
23967 PyObject * obj1 = 0 ;
23968 char *kwnames[] = {
23969 (char *) "self",(char *) "diff", NULL
23970 };
23971
23972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23974 if (SWIG_arg_fail(1)) SWIG_fail;
23975 {
23976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23977 if (SWIG_arg_fail(2)) SWIG_fail;
23978 if (arg2 == NULL) {
23979 SWIG_null_ref("wxTimeSpan");
23980 }
23981 if (SWIG_arg_fail(2)) SWIG_fail;
23982 }
23983 {
23984 PyThreadState* __tstate = wxPyBeginAllowThreads();
23985 {
23986 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23987 result = (wxTimeSpan *) &_result_ref;
23988 }
23989
23990 wxPyEndAllowThreads(__tstate);
23991 if (PyErr_Occurred()) SWIG_fail;
23992 }
23993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23994 return resultobj;
23995 fail:
23996 return NULL;
23997 }
23998
23999
24000 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24001 PyObject *resultobj;
24002 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24003 wxTimeSpan *arg2 = 0 ;
24004 wxTimeSpan *result;
24005 PyObject * obj0 = 0 ;
24006 PyObject * obj1 = 0 ;
24007 char *kwnames[] = {
24008 (char *) "self",(char *) "diff", NULL
24009 };
24010
24011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24013 if (SWIG_arg_fail(1)) SWIG_fail;
24014 {
24015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24016 if (SWIG_arg_fail(2)) SWIG_fail;
24017 if (arg2 == NULL) {
24018 SWIG_null_ref("wxTimeSpan");
24019 }
24020 if (SWIG_arg_fail(2)) SWIG_fail;
24021 }
24022 {
24023 PyThreadState* __tstate = wxPyBeginAllowThreads();
24024 {
24025 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24026 result = (wxTimeSpan *) &_result_ref;
24027 }
24028
24029 wxPyEndAllowThreads(__tstate);
24030 if (PyErr_Occurred()) SWIG_fail;
24031 }
24032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24033 return resultobj;
24034 fail:
24035 return NULL;
24036 }
24037
24038
24039 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24040 PyObject *resultobj;
24041 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24042 int arg2 ;
24043 wxTimeSpan *result;
24044 PyObject * obj0 = 0 ;
24045 PyObject * obj1 = 0 ;
24046 char *kwnames[] = {
24047 (char *) "self",(char *) "n", NULL
24048 };
24049
24050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24052 if (SWIG_arg_fail(1)) SWIG_fail;
24053 {
24054 arg2 = (int)(SWIG_As_int(obj1));
24055 if (SWIG_arg_fail(2)) SWIG_fail;
24056 }
24057 {
24058 PyThreadState* __tstate = wxPyBeginAllowThreads();
24059 {
24060 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24061 result = (wxTimeSpan *) &_result_ref;
24062 }
24063
24064 wxPyEndAllowThreads(__tstate);
24065 if (PyErr_Occurred()) SWIG_fail;
24066 }
24067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24068 return resultobj;
24069 fail:
24070 return NULL;
24071 }
24072
24073
24074 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24075 PyObject *resultobj;
24076 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24077 wxTimeSpan *result;
24078 PyObject * obj0 = 0 ;
24079 char *kwnames[] = {
24080 (char *) "self", NULL
24081 };
24082
24083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24085 if (SWIG_arg_fail(1)) SWIG_fail;
24086 {
24087 PyThreadState* __tstate = wxPyBeginAllowThreads();
24088 {
24089 wxTimeSpan &_result_ref = (arg1)->Neg();
24090 result = (wxTimeSpan *) &_result_ref;
24091 }
24092
24093 wxPyEndAllowThreads(__tstate);
24094 if (PyErr_Occurred()) SWIG_fail;
24095 }
24096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24097 return resultobj;
24098 fail:
24099 return NULL;
24100 }
24101
24102
24103 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24104 PyObject *resultobj;
24105 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24106 wxTimeSpan result;
24107 PyObject * obj0 = 0 ;
24108 char *kwnames[] = {
24109 (char *) "self", NULL
24110 };
24111
24112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24114 if (SWIG_arg_fail(1)) SWIG_fail;
24115 {
24116 PyThreadState* __tstate = wxPyBeginAllowThreads();
24117 result = ((wxTimeSpan const *)arg1)->Abs();
24118
24119 wxPyEndAllowThreads(__tstate);
24120 if (PyErr_Occurred()) SWIG_fail;
24121 }
24122 {
24123 wxTimeSpan * resultptr;
24124 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24125 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24126 }
24127 return resultobj;
24128 fail:
24129 return NULL;
24130 }
24131
24132
24133 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24134 PyObject *resultobj;
24135 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24136 wxTimeSpan *arg2 = 0 ;
24137 wxTimeSpan *result;
24138 PyObject * obj0 = 0 ;
24139 PyObject * obj1 = 0 ;
24140 char *kwnames[] = {
24141 (char *) "self",(char *) "diff", NULL
24142 };
24143
24144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24146 if (SWIG_arg_fail(1)) SWIG_fail;
24147 {
24148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24149 if (SWIG_arg_fail(2)) SWIG_fail;
24150 if (arg2 == NULL) {
24151 SWIG_null_ref("wxTimeSpan");
24152 }
24153 if (SWIG_arg_fail(2)) SWIG_fail;
24154 }
24155 {
24156 PyThreadState* __tstate = wxPyBeginAllowThreads();
24157 {
24158 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24159 result = (wxTimeSpan *) &_result_ref;
24160 }
24161
24162 wxPyEndAllowThreads(__tstate);
24163 if (PyErr_Occurred()) SWIG_fail;
24164 }
24165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24173 PyObject *resultobj;
24174 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24175 wxTimeSpan *arg2 = 0 ;
24176 wxTimeSpan *result;
24177 PyObject * obj0 = 0 ;
24178 PyObject * obj1 = 0 ;
24179 char *kwnames[] = {
24180 (char *) "self",(char *) "diff", NULL
24181 };
24182
24183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24185 if (SWIG_arg_fail(1)) SWIG_fail;
24186 {
24187 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24188 if (SWIG_arg_fail(2)) SWIG_fail;
24189 if (arg2 == NULL) {
24190 SWIG_null_ref("wxTimeSpan");
24191 }
24192 if (SWIG_arg_fail(2)) SWIG_fail;
24193 }
24194 {
24195 PyThreadState* __tstate = wxPyBeginAllowThreads();
24196 {
24197 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24198 result = (wxTimeSpan *) &_result_ref;
24199 }
24200
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24205 return resultobj;
24206 fail:
24207 return NULL;
24208 }
24209
24210
24211 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj;
24213 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24214 int arg2 ;
24215 wxTimeSpan *result;
24216 PyObject * obj0 = 0 ;
24217 PyObject * obj1 = 0 ;
24218 char *kwnames[] = {
24219 (char *) "self",(char *) "n", NULL
24220 };
24221
24222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24224 if (SWIG_arg_fail(1)) SWIG_fail;
24225 {
24226 arg2 = (int)(SWIG_As_int(obj1));
24227 if (SWIG_arg_fail(2)) SWIG_fail;
24228 }
24229 {
24230 PyThreadState* __tstate = wxPyBeginAllowThreads();
24231 {
24232 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24233 result = (wxTimeSpan *) &_result_ref;
24234 }
24235
24236 wxPyEndAllowThreads(__tstate);
24237 if (PyErr_Occurred()) SWIG_fail;
24238 }
24239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24240 return resultobj;
24241 fail:
24242 return NULL;
24243 }
24244
24245
24246 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24247 PyObject *resultobj;
24248 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24249 wxTimeSpan *result;
24250 PyObject * obj0 = 0 ;
24251 char *kwnames[] = {
24252 (char *) "self", NULL
24253 };
24254
24255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24257 if (SWIG_arg_fail(1)) SWIG_fail;
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 {
24261 wxTimeSpan &_result_ref = (arg1)->operator -();
24262 result = (wxTimeSpan *) &_result_ref;
24263 }
24264
24265 wxPyEndAllowThreads(__tstate);
24266 if (PyErr_Occurred()) SWIG_fail;
24267 }
24268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24269 return resultobj;
24270 fail:
24271 return NULL;
24272 }
24273
24274
24275 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24276 PyObject *resultobj;
24277 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24278 wxTimeSpan *arg2 = 0 ;
24279 wxTimeSpan result;
24280 PyObject * obj0 = 0 ;
24281 PyObject * obj1 = 0 ;
24282 char *kwnames[] = {
24283 (char *) "self",(char *) "other", NULL
24284 };
24285
24286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24288 if (SWIG_arg_fail(1)) SWIG_fail;
24289 {
24290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24291 if (SWIG_arg_fail(2)) SWIG_fail;
24292 if (arg2 == NULL) {
24293 SWIG_null_ref("wxTimeSpan");
24294 }
24295 if (SWIG_arg_fail(2)) SWIG_fail;
24296 }
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24300
24301 wxPyEndAllowThreads(__tstate);
24302 if (PyErr_Occurred()) SWIG_fail;
24303 }
24304 {
24305 wxTimeSpan * resultptr;
24306 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24307 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24308 }
24309 return resultobj;
24310 fail:
24311 return NULL;
24312 }
24313
24314
24315 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24316 PyObject *resultobj;
24317 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24318 wxTimeSpan *arg2 = 0 ;
24319 wxTimeSpan result;
24320 PyObject * obj0 = 0 ;
24321 PyObject * obj1 = 0 ;
24322 char *kwnames[] = {
24323 (char *) "self",(char *) "other", NULL
24324 };
24325
24326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24328 if (SWIG_arg_fail(1)) SWIG_fail;
24329 {
24330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24331 if (SWIG_arg_fail(2)) SWIG_fail;
24332 if (arg2 == NULL) {
24333 SWIG_null_ref("wxTimeSpan");
24334 }
24335 if (SWIG_arg_fail(2)) SWIG_fail;
24336 }
24337 {
24338 PyThreadState* __tstate = wxPyBeginAllowThreads();
24339 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24340
24341 wxPyEndAllowThreads(__tstate);
24342 if (PyErr_Occurred()) SWIG_fail;
24343 }
24344 {
24345 wxTimeSpan * resultptr;
24346 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24347 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24348 }
24349 return resultobj;
24350 fail:
24351 return NULL;
24352 }
24353
24354
24355 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24356 PyObject *resultobj;
24357 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24358 int arg2 ;
24359 wxTimeSpan result;
24360 PyObject * obj0 = 0 ;
24361 PyObject * obj1 = 0 ;
24362 char *kwnames[] = {
24363 (char *) "self",(char *) "n", NULL
24364 };
24365
24366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24368 if (SWIG_arg_fail(1)) SWIG_fail;
24369 {
24370 arg2 = (int)(SWIG_As_int(obj1));
24371 if (SWIG_arg_fail(2)) SWIG_fail;
24372 }
24373 {
24374 PyThreadState* __tstate = wxPyBeginAllowThreads();
24375 result = wxTimeSpan___mul__(arg1,arg2);
24376
24377 wxPyEndAllowThreads(__tstate);
24378 if (PyErr_Occurred()) SWIG_fail;
24379 }
24380 {
24381 wxTimeSpan * resultptr;
24382 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24383 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24384 }
24385 return resultobj;
24386 fail:
24387 return NULL;
24388 }
24389
24390
24391 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24392 PyObject *resultobj;
24393 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24394 int arg2 ;
24395 wxTimeSpan result;
24396 PyObject * obj0 = 0 ;
24397 PyObject * obj1 = 0 ;
24398 char *kwnames[] = {
24399 (char *) "self",(char *) "n", NULL
24400 };
24401
24402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24404 if (SWIG_arg_fail(1)) SWIG_fail;
24405 {
24406 arg2 = (int)(SWIG_As_int(obj1));
24407 if (SWIG_arg_fail(2)) SWIG_fail;
24408 }
24409 {
24410 PyThreadState* __tstate = wxPyBeginAllowThreads();
24411 result = wxTimeSpan___rmul__(arg1,arg2);
24412
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 {
24417 wxTimeSpan * resultptr;
24418 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24420 }
24421 return resultobj;
24422 fail:
24423 return NULL;
24424 }
24425
24426
24427 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24428 PyObject *resultobj;
24429 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24430 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24431 bool result;
24432 PyObject * obj0 = 0 ;
24433 PyObject * obj1 = 0 ;
24434 char *kwnames[] = {
24435 (char *) "self",(char *) "other", NULL
24436 };
24437
24438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24440 if (SWIG_arg_fail(1)) SWIG_fail;
24441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24442 if (SWIG_arg_fail(2)) SWIG_fail;
24443 {
24444 PyThreadState* __tstate = wxPyBeginAllowThreads();
24445 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24446
24447 wxPyEndAllowThreads(__tstate);
24448 if (PyErr_Occurred()) SWIG_fail;
24449 }
24450 {
24451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24452 }
24453 return resultobj;
24454 fail:
24455 return NULL;
24456 }
24457
24458
24459 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24460 PyObject *resultobj;
24461 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24462 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24463 bool result;
24464 PyObject * obj0 = 0 ;
24465 PyObject * obj1 = 0 ;
24466 char *kwnames[] = {
24467 (char *) "self",(char *) "other", NULL
24468 };
24469
24470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24472 if (SWIG_arg_fail(1)) SWIG_fail;
24473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24474 if (SWIG_arg_fail(2)) SWIG_fail;
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24478
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24492 PyObject *resultobj;
24493 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24494 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24495 bool result;
24496 PyObject * obj0 = 0 ;
24497 PyObject * obj1 = 0 ;
24498 char *kwnames[] = {
24499 (char *) "self",(char *) "other", NULL
24500 };
24501
24502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24504 if (SWIG_arg_fail(1)) SWIG_fail;
24505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24506 if (SWIG_arg_fail(2)) SWIG_fail;
24507 {
24508 PyThreadState* __tstate = wxPyBeginAllowThreads();
24509 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24510
24511 wxPyEndAllowThreads(__tstate);
24512 if (PyErr_Occurred()) SWIG_fail;
24513 }
24514 {
24515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24516 }
24517 return resultobj;
24518 fail:
24519 return NULL;
24520 }
24521
24522
24523 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24524 PyObject *resultobj;
24525 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24526 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24527 bool result;
24528 PyObject * obj0 = 0 ;
24529 PyObject * obj1 = 0 ;
24530 char *kwnames[] = {
24531 (char *) "self",(char *) "other", NULL
24532 };
24533
24534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24536 if (SWIG_arg_fail(1)) SWIG_fail;
24537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24538 if (SWIG_arg_fail(2)) SWIG_fail;
24539 {
24540 PyThreadState* __tstate = wxPyBeginAllowThreads();
24541 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24542
24543 wxPyEndAllowThreads(__tstate);
24544 if (PyErr_Occurred()) SWIG_fail;
24545 }
24546 {
24547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24548 }
24549 return resultobj;
24550 fail:
24551 return NULL;
24552 }
24553
24554
24555 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24556 PyObject *resultobj;
24557 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24558 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24559 bool result;
24560 PyObject * obj0 = 0 ;
24561 PyObject * obj1 = 0 ;
24562 char *kwnames[] = {
24563 (char *) "self",(char *) "other", NULL
24564 };
24565
24566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24568 if (SWIG_arg_fail(1)) SWIG_fail;
24569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24570 if (SWIG_arg_fail(2)) SWIG_fail;
24571 {
24572 PyThreadState* __tstate = wxPyBeginAllowThreads();
24573 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24574
24575 wxPyEndAllowThreads(__tstate);
24576 if (PyErr_Occurred()) SWIG_fail;
24577 }
24578 {
24579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24580 }
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj;
24589 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24590 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24591 bool result;
24592 PyObject * obj0 = 0 ;
24593 PyObject * obj1 = 0 ;
24594 char *kwnames[] = {
24595 (char *) "self",(char *) "other", NULL
24596 };
24597
24598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24600 if (SWIG_arg_fail(1)) SWIG_fail;
24601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24602 if (SWIG_arg_fail(2)) SWIG_fail;
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24606
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 {
24611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24612 }
24613 return resultobj;
24614 fail:
24615 return NULL;
24616 }
24617
24618
24619 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24620 PyObject *resultobj;
24621 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24622 bool result;
24623 PyObject * obj0 = 0 ;
24624 char *kwnames[] = {
24625 (char *) "self", NULL
24626 };
24627
24628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24630 if (SWIG_arg_fail(1)) SWIG_fail;
24631 {
24632 PyThreadState* __tstate = wxPyBeginAllowThreads();
24633 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24634
24635 wxPyEndAllowThreads(__tstate);
24636 if (PyErr_Occurred()) SWIG_fail;
24637 }
24638 {
24639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24640 }
24641 return resultobj;
24642 fail:
24643 return NULL;
24644 }
24645
24646
24647 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24648 PyObject *resultobj;
24649 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24650 bool result;
24651 PyObject * obj0 = 0 ;
24652 char *kwnames[] = {
24653 (char *) "self", NULL
24654 };
24655
24656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24658 if (SWIG_arg_fail(1)) SWIG_fail;
24659 {
24660 PyThreadState* __tstate = wxPyBeginAllowThreads();
24661 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24662
24663 wxPyEndAllowThreads(__tstate);
24664 if (PyErr_Occurred()) SWIG_fail;
24665 }
24666 {
24667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24668 }
24669 return resultobj;
24670 fail:
24671 return NULL;
24672 }
24673
24674
24675 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24676 PyObject *resultobj;
24677 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24678 bool result;
24679 PyObject * obj0 = 0 ;
24680 char *kwnames[] = {
24681 (char *) "self", NULL
24682 };
24683
24684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24686 if (SWIG_arg_fail(1)) SWIG_fail;
24687 {
24688 PyThreadState* __tstate = wxPyBeginAllowThreads();
24689 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24690
24691 wxPyEndAllowThreads(__tstate);
24692 if (PyErr_Occurred()) SWIG_fail;
24693 }
24694 {
24695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24696 }
24697 return resultobj;
24698 fail:
24699 return NULL;
24700 }
24701
24702
24703 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24704 PyObject *resultobj;
24705 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24706 wxTimeSpan *arg2 = 0 ;
24707 bool result;
24708 PyObject * obj0 = 0 ;
24709 PyObject * obj1 = 0 ;
24710 char *kwnames[] = {
24711 (char *) "self",(char *) "ts", NULL
24712 };
24713
24714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24716 if (SWIG_arg_fail(1)) SWIG_fail;
24717 {
24718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24719 if (SWIG_arg_fail(2)) SWIG_fail;
24720 if (arg2 == NULL) {
24721 SWIG_null_ref("wxTimeSpan");
24722 }
24723 if (SWIG_arg_fail(2)) SWIG_fail;
24724 }
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24728
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 {
24733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24734 }
24735 return resultobj;
24736 fail:
24737 return NULL;
24738 }
24739
24740
24741 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24742 PyObject *resultobj;
24743 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24744 wxTimeSpan *arg2 = 0 ;
24745 bool result;
24746 PyObject * obj0 = 0 ;
24747 PyObject * obj1 = 0 ;
24748 char *kwnames[] = {
24749 (char *) "self",(char *) "ts", NULL
24750 };
24751
24752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24754 if (SWIG_arg_fail(1)) SWIG_fail;
24755 {
24756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24757 if (SWIG_arg_fail(2)) SWIG_fail;
24758 if (arg2 == NULL) {
24759 SWIG_null_ref("wxTimeSpan");
24760 }
24761 if (SWIG_arg_fail(2)) SWIG_fail;
24762 }
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24766
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 {
24771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24772 }
24773 return resultobj;
24774 fail:
24775 return NULL;
24776 }
24777
24778
24779 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24780 PyObject *resultobj;
24781 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24782 wxTimeSpan *arg2 = 0 ;
24783 bool result;
24784 PyObject * obj0 = 0 ;
24785 PyObject * obj1 = 0 ;
24786 char *kwnames[] = {
24787 (char *) "self",(char *) "t", NULL
24788 };
24789
24790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24792 if (SWIG_arg_fail(1)) SWIG_fail;
24793 {
24794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24795 if (SWIG_arg_fail(2)) SWIG_fail;
24796 if (arg2 == NULL) {
24797 SWIG_null_ref("wxTimeSpan");
24798 }
24799 if (SWIG_arg_fail(2)) SWIG_fail;
24800 }
24801 {
24802 PyThreadState* __tstate = wxPyBeginAllowThreads();
24803 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24804
24805 wxPyEndAllowThreads(__tstate);
24806 if (PyErr_Occurred()) SWIG_fail;
24807 }
24808 {
24809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24810 }
24811 return resultobj;
24812 fail:
24813 return NULL;
24814 }
24815
24816
24817 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24818 PyObject *resultobj;
24819 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24820 int result;
24821 PyObject * obj0 = 0 ;
24822 char *kwnames[] = {
24823 (char *) "self", NULL
24824 };
24825
24826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24828 if (SWIG_arg_fail(1)) SWIG_fail;
24829 {
24830 PyThreadState* __tstate = wxPyBeginAllowThreads();
24831 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24832
24833 wxPyEndAllowThreads(__tstate);
24834 if (PyErr_Occurred()) SWIG_fail;
24835 }
24836 {
24837 resultobj = SWIG_From_int((int)(result));
24838 }
24839 return resultobj;
24840 fail:
24841 return NULL;
24842 }
24843
24844
24845 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24846 PyObject *resultobj;
24847 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24848 int result;
24849 PyObject * obj0 = 0 ;
24850 char *kwnames[] = {
24851 (char *) "self", NULL
24852 };
24853
24854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24856 if (SWIG_arg_fail(1)) SWIG_fail;
24857 {
24858 PyThreadState* __tstate = wxPyBeginAllowThreads();
24859 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24860
24861 wxPyEndAllowThreads(__tstate);
24862 if (PyErr_Occurred()) SWIG_fail;
24863 }
24864 {
24865 resultobj = SWIG_From_int((int)(result));
24866 }
24867 return resultobj;
24868 fail:
24869 return NULL;
24870 }
24871
24872
24873 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24874 PyObject *resultobj;
24875 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24876 int result;
24877 PyObject * obj0 = 0 ;
24878 char *kwnames[] = {
24879 (char *) "self", NULL
24880 };
24881
24882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24884 if (SWIG_arg_fail(1)) SWIG_fail;
24885 {
24886 PyThreadState* __tstate = wxPyBeginAllowThreads();
24887 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24888
24889 wxPyEndAllowThreads(__tstate);
24890 if (PyErr_Occurred()) SWIG_fail;
24891 }
24892 {
24893 resultobj = SWIG_From_int((int)(result));
24894 }
24895 return resultobj;
24896 fail:
24897 return NULL;
24898 }
24899
24900
24901 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24902 PyObject *resultobj;
24903 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24904 int result;
24905 PyObject * obj0 = 0 ;
24906 char *kwnames[] = {
24907 (char *) "self", NULL
24908 };
24909
24910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24912 if (SWIG_arg_fail(1)) SWIG_fail;
24913 {
24914 PyThreadState* __tstate = wxPyBeginAllowThreads();
24915 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24916
24917 wxPyEndAllowThreads(__tstate);
24918 if (PyErr_Occurred()) SWIG_fail;
24919 }
24920 {
24921 resultobj = SWIG_From_int((int)(result));
24922 }
24923 return resultobj;
24924 fail:
24925 return NULL;
24926 }
24927
24928
24929 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj;
24931 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24932 wxLongLong result;
24933 PyObject * obj0 = 0 ;
24934 char *kwnames[] = {
24935 (char *) "self", NULL
24936 };
24937
24938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
24939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24940 if (SWIG_arg_fail(1)) SWIG_fail;
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24944
24945 wxPyEndAllowThreads(__tstate);
24946 if (PyErr_Occurred()) SWIG_fail;
24947 }
24948 {
24949 PyObject *hi, *lo, *shifter, *shifted;
24950 hi = PyLong_FromLong( (&result)->GetHi() );
24951 lo = PyLong_FromLong( (&result)->GetLo() );
24952 shifter = PyLong_FromLong(32);
24953 shifted = PyNumber_Lshift(hi, shifter);
24954 resultobj = PyNumber_Or(shifted, lo);
24955 Py_DECREF(hi);
24956 Py_DECREF(lo);
24957 Py_DECREF(shifter);
24958 Py_DECREF(shifted);
24959 }
24960 return resultobj;
24961 fail:
24962 return NULL;
24963 }
24964
24965
24966 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24967 PyObject *resultobj;
24968 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24969 wxLongLong result;
24970 PyObject * obj0 = 0 ;
24971 char *kwnames[] = {
24972 (char *) "self", NULL
24973 };
24974
24975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
24976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24977 if (SWIG_arg_fail(1)) SWIG_fail;
24978 {
24979 PyThreadState* __tstate = wxPyBeginAllowThreads();
24980 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
24981
24982 wxPyEndAllowThreads(__tstate);
24983 if (PyErr_Occurred()) SWIG_fail;
24984 }
24985 {
24986 PyObject *hi, *lo, *shifter, *shifted;
24987 hi = PyLong_FromLong( (&result)->GetHi() );
24988 lo = PyLong_FromLong( (&result)->GetLo() );
24989 shifter = PyLong_FromLong(32);
24990 shifted = PyNumber_Lshift(hi, shifter);
24991 resultobj = PyNumber_Or(shifted, lo);
24992 Py_DECREF(hi);
24993 Py_DECREF(lo);
24994 Py_DECREF(shifter);
24995 Py_DECREF(shifted);
24996 }
24997 return resultobj;
24998 fail:
24999 return NULL;
25000 }
25001
25002
25003 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25004 PyObject *resultobj;
25005 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25006 wxString const &arg2_defvalue = wxPyTimeSpanFormatStr ;
25007 wxString *arg2 = (wxString *) &arg2_defvalue ;
25008 wxString result;
25009 bool temp2 = false ;
25010 PyObject * obj0 = 0 ;
25011 PyObject * obj1 = 0 ;
25012 char *kwnames[] = {
25013 (char *) "self",(char *) "format", NULL
25014 };
25015
25016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25018 if (SWIG_arg_fail(1)) SWIG_fail;
25019 if (obj1) {
25020 {
25021 arg2 = wxString_in_helper(obj1);
25022 if (arg2 == NULL) SWIG_fail;
25023 temp2 = true;
25024 }
25025 }
25026 {
25027 PyThreadState* __tstate = wxPyBeginAllowThreads();
25028 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25029
25030 wxPyEndAllowThreads(__tstate);
25031 if (PyErr_Occurred()) SWIG_fail;
25032 }
25033 {
25034 #if wxUSE_UNICODE
25035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25036 #else
25037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25038 #endif
25039 }
25040 {
25041 if (temp2)
25042 delete arg2;
25043 }
25044 return resultobj;
25045 fail:
25046 {
25047 if (temp2)
25048 delete arg2;
25049 }
25050 return NULL;
25051 }
25052
25053
25054 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25055 PyObject *obj;
25056 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25057 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25058 Py_INCREF(obj);
25059 return Py_BuildValue((char *)"");
25060 }
25061 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25062 PyObject *resultobj;
25063 int arg1 = (int) 0 ;
25064 int arg2 = (int) 0 ;
25065 int arg3 = (int) 0 ;
25066 int arg4 = (int) 0 ;
25067 wxDateSpan *result;
25068 PyObject * obj0 = 0 ;
25069 PyObject * obj1 = 0 ;
25070 PyObject * obj2 = 0 ;
25071 PyObject * obj3 = 0 ;
25072 char *kwnames[] = {
25073 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25074 };
25075
25076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25077 if (obj0) {
25078 {
25079 arg1 = (int)(SWIG_As_int(obj0));
25080 if (SWIG_arg_fail(1)) SWIG_fail;
25081 }
25082 }
25083 if (obj1) {
25084 {
25085 arg2 = (int)(SWIG_As_int(obj1));
25086 if (SWIG_arg_fail(2)) SWIG_fail;
25087 }
25088 }
25089 if (obj2) {
25090 {
25091 arg3 = (int)(SWIG_As_int(obj2));
25092 if (SWIG_arg_fail(3)) SWIG_fail;
25093 }
25094 }
25095 if (obj3) {
25096 {
25097 arg4 = (int)(SWIG_As_int(obj3));
25098 if (SWIG_arg_fail(4)) SWIG_fail;
25099 }
25100 }
25101 {
25102 PyThreadState* __tstate = wxPyBeginAllowThreads();
25103 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25104
25105 wxPyEndAllowThreads(__tstate);
25106 if (PyErr_Occurred()) SWIG_fail;
25107 }
25108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25109 return resultobj;
25110 fail:
25111 return NULL;
25112 }
25113
25114
25115 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25116 PyObject *resultobj;
25117 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25118 PyObject * obj0 = 0 ;
25119 char *kwnames[] = {
25120 (char *) "self", NULL
25121 };
25122
25123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25125 if (SWIG_arg_fail(1)) SWIG_fail;
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 delete arg1;
25129
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 Py_INCREF(Py_None); resultobj = Py_None;
25134 return resultobj;
25135 fail:
25136 return NULL;
25137 }
25138
25139
25140 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25141 PyObject *resultobj;
25142 int arg1 ;
25143 wxDateSpan result;
25144 PyObject * obj0 = 0 ;
25145 char *kwnames[] = {
25146 (char *) "days", NULL
25147 };
25148
25149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25150 {
25151 arg1 = (int)(SWIG_As_int(obj0));
25152 if (SWIG_arg_fail(1)) SWIG_fail;
25153 }
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = wxDateSpan::Days(arg1);
25157
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 {
25162 wxDateSpan * resultptr;
25163 resultptr = new wxDateSpan((wxDateSpan &)(result));
25164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25165 }
25166 return resultobj;
25167 fail:
25168 return NULL;
25169 }
25170
25171
25172 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25173 PyObject *resultobj;
25174 wxDateSpan result;
25175 char *kwnames[] = {
25176 NULL
25177 };
25178
25179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = wxDateSpan::Day();
25183
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 {
25188 wxDateSpan * resultptr;
25189 resultptr = new wxDateSpan((wxDateSpan &)(result));
25190 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25191 }
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj;
25200 int arg1 ;
25201 wxDateSpan result;
25202 PyObject * obj0 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "weeks", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25208 {
25209 arg1 = (int)(SWIG_As_int(obj0));
25210 if (SWIG_arg_fail(1)) SWIG_fail;
25211 }
25212 {
25213 PyThreadState* __tstate = wxPyBeginAllowThreads();
25214 result = wxDateSpan::Weeks(arg1);
25215
25216 wxPyEndAllowThreads(__tstate);
25217 if (PyErr_Occurred()) SWIG_fail;
25218 }
25219 {
25220 wxDateSpan * resultptr;
25221 resultptr = new wxDateSpan((wxDateSpan &)(result));
25222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25223 }
25224 return resultobj;
25225 fail:
25226 return NULL;
25227 }
25228
25229
25230 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25231 PyObject *resultobj;
25232 wxDateSpan result;
25233 char *kwnames[] = {
25234 NULL
25235 };
25236
25237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25238 {
25239 PyThreadState* __tstate = wxPyBeginAllowThreads();
25240 result = wxDateSpan::Week();
25241
25242 wxPyEndAllowThreads(__tstate);
25243 if (PyErr_Occurred()) SWIG_fail;
25244 }
25245 {
25246 wxDateSpan * resultptr;
25247 resultptr = new wxDateSpan((wxDateSpan &)(result));
25248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25249 }
25250 return resultobj;
25251 fail:
25252 return NULL;
25253 }
25254
25255
25256 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25257 PyObject *resultobj;
25258 int arg1 ;
25259 wxDateSpan result;
25260 PyObject * obj0 = 0 ;
25261 char *kwnames[] = {
25262 (char *) "mon", NULL
25263 };
25264
25265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25266 {
25267 arg1 = (int)(SWIG_As_int(obj0));
25268 if (SWIG_arg_fail(1)) SWIG_fail;
25269 }
25270 {
25271 PyThreadState* __tstate = wxPyBeginAllowThreads();
25272 result = wxDateSpan::Months(arg1);
25273
25274 wxPyEndAllowThreads(__tstate);
25275 if (PyErr_Occurred()) SWIG_fail;
25276 }
25277 {
25278 wxDateSpan * resultptr;
25279 resultptr = new wxDateSpan((wxDateSpan &)(result));
25280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25281 }
25282 return resultobj;
25283 fail:
25284 return NULL;
25285 }
25286
25287
25288 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25289 PyObject *resultobj;
25290 wxDateSpan result;
25291 char *kwnames[] = {
25292 NULL
25293 };
25294
25295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25296 {
25297 PyThreadState* __tstate = wxPyBeginAllowThreads();
25298 result = wxDateSpan::Month();
25299
25300 wxPyEndAllowThreads(__tstate);
25301 if (PyErr_Occurred()) SWIG_fail;
25302 }
25303 {
25304 wxDateSpan * resultptr;
25305 resultptr = new wxDateSpan((wxDateSpan &)(result));
25306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25307 }
25308 return resultobj;
25309 fail:
25310 return NULL;
25311 }
25312
25313
25314 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25315 PyObject *resultobj;
25316 int arg1 ;
25317 wxDateSpan result;
25318 PyObject * obj0 = 0 ;
25319 char *kwnames[] = {
25320 (char *) "years", NULL
25321 };
25322
25323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25324 {
25325 arg1 = (int)(SWIG_As_int(obj0));
25326 if (SWIG_arg_fail(1)) SWIG_fail;
25327 }
25328 {
25329 PyThreadState* __tstate = wxPyBeginAllowThreads();
25330 result = wxDateSpan::Years(arg1);
25331
25332 wxPyEndAllowThreads(__tstate);
25333 if (PyErr_Occurred()) SWIG_fail;
25334 }
25335 {
25336 wxDateSpan * resultptr;
25337 resultptr = new wxDateSpan((wxDateSpan &)(result));
25338 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25339 }
25340 return resultobj;
25341 fail:
25342 return NULL;
25343 }
25344
25345
25346 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25347 PyObject *resultobj;
25348 wxDateSpan result;
25349 char *kwnames[] = {
25350 NULL
25351 };
25352
25353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25354 {
25355 PyThreadState* __tstate = wxPyBeginAllowThreads();
25356 result = wxDateSpan::Year();
25357
25358 wxPyEndAllowThreads(__tstate);
25359 if (PyErr_Occurred()) SWIG_fail;
25360 }
25361 {
25362 wxDateSpan * resultptr;
25363 resultptr = new wxDateSpan((wxDateSpan &)(result));
25364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25365 }
25366 return resultobj;
25367 fail:
25368 return NULL;
25369 }
25370
25371
25372 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25373 PyObject *resultobj;
25374 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25375 int arg2 ;
25376 wxDateSpan *result;
25377 PyObject * obj0 = 0 ;
25378 PyObject * obj1 = 0 ;
25379 char *kwnames[] = {
25380 (char *) "self",(char *) "n", NULL
25381 };
25382
25383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25385 if (SWIG_arg_fail(1)) SWIG_fail;
25386 {
25387 arg2 = (int)(SWIG_As_int(obj1));
25388 if (SWIG_arg_fail(2)) SWIG_fail;
25389 }
25390 {
25391 PyThreadState* __tstate = wxPyBeginAllowThreads();
25392 {
25393 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25394 result = (wxDateSpan *) &_result_ref;
25395 }
25396
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25401 return resultobj;
25402 fail:
25403 return NULL;
25404 }
25405
25406
25407 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25408 PyObject *resultobj;
25409 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25410 int arg2 ;
25411 wxDateSpan *result;
25412 PyObject * obj0 = 0 ;
25413 PyObject * obj1 = 0 ;
25414 char *kwnames[] = {
25415 (char *) "self",(char *) "n", NULL
25416 };
25417
25418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25420 if (SWIG_arg_fail(1)) SWIG_fail;
25421 {
25422 arg2 = (int)(SWIG_As_int(obj1));
25423 if (SWIG_arg_fail(2)) SWIG_fail;
25424 }
25425 {
25426 PyThreadState* __tstate = wxPyBeginAllowThreads();
25427 {
25428 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25429 result = (wxDateSpan *) &_result_ref;
25430 }
25431
25432 wxPyEndAllowThreads(__tstate);
25433 if (PyErr_Occurred()) SWIG_fail;
25434 }
25435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25436 return resultobj;
25437 fail:
25438 return NULL;
25439 }
25440
25441
25442 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25443 PyObject *resultobj;
25444 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25445 int arg2 ;
25446 wxDateSpan *result;
25447 PyObject * obj0 = 0 ;
25448 PyObject * obj1 = 0 ;
25449 char *kwnames[] = {
25450 (char *) "self",(char *) "n", NULL
25451 };
25452
25453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25455 if (SWIG_arg_fail(1)) SWIG_fail;
25456 {
25457 arg2 = (int)(SWIG_As_int(obj1));
25458 if (SWIG_arg_fail(2)) SWIG_fail;
25459 }
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 {
25463 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25464 result = (wxDateSpan *) &_result_ref;
25465 }
25466
25467 wxPyEndAllowThreads(__tstate);
25468 if (PyErr_Occurred()) SWIG_fail;
25469 }
25470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25471 return resultobj;
25472 fail:
25473 return NULL;
25474 }
25475
25476
25477 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25478 PyObject *resultobj;
25479 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25480 int arg2 ;
25481 wxDateSpan *result;
25482 PyObject * obj0 = 0 ;
25483 PyObject * obj1 = 0 ;
25484 char *kwnames[] = {
25485 (char *) "self",(char *) "n", NULL
25486 };
25487
25488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25490 if (SWIG_arg_fail(1)) SWIG_fail;
25491 {
25492 arg2 = (int)(SWIG_As_int(obj1));
25493 if (SWIG_arg_fail(2)) SWIG_fail;
25494 }
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 {
25498 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25499 result = (wxDateSpan *) &_result_ref;
25500 }
25501
25502 wxPyEndAllowThreads(__tstate);
25503 if (PyErr_Occurred()) SWIG_fail;
25504 }
25505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25506 return resultobj;
25507 fail:
25508 return NULL;
25509 }
25510
25511
25512 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25513 PyObject *resultobj;
25514 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25515 int result;
25516 PyObject * obj0 = 0 ;
25517 char *kwnames[] = {
25518 (char *) "self", NULL
25519 };
25520
25521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25523 if (SWIG_arg_fail(1)) SWIG_fail;
25524 {
25525 PyThreadState* __tstate = wxPyBeginAllowThreads();
25526 result = (int)((wxDateSpan const *)arg1)->GetYears();
25527
25528 wxPyEndAllowThreads(__tstate);
25529 if (PyErr_Occurred()) SWIG_fail;
25530 }
25531 {
25532 resultobj = SWIG_From_int((int)(result));
25533 }
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25541 PyObject *resultobj;
25542 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25543 int result;
25544 PyObject * obj0 = 0 ;
25545 char *kwnames[] = {
25546 (char *) "self", NULL
25547 };
25548
25549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25551 if (SWIG_arg_fail(1)) SWIG_fail;
25552 {
25553 PyThreadState* __tstate = wxPyBeginAllowThreads();
25554 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25555
25556 wxPyEndAllowThreads(__tstate);
25557 if (PyErr_Occurred()) SWIG_fail;
25558 }
25559 {
25560 resultobj = SWIG_From_int((int)(result));
25561 }
25562 return resultobj;
25563 fail:
25564 return NULL;
25565 }
25566
25567
25568 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25569 PyObject *resultobj;
25570 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25571 int result;
25572 PyObject * obj0 = 0 ;
25573 char *kwnames[] = {
25574 (char *) "self", NULL
25575 };
25576
25577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25579 if (SWIG_arg_fail(1)) SWIG_fail;
25580 {
25581 PyThreadState* __tstate = wxPyBeginAllowThreads();
25582 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25583
25584 wxPyEndAllowThreads(__tstate);
25585 if (PyErr_Occurred()) SWIG_fail;
25586 }
25587 {
25588 resultobj = SWIG_From_int((int)(result));
25589 }
25590 return resultobj;
25591 fail:
25592 return NULL;
25593 }
25594
25595
25596 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25597 PyObject *resultobj;
25598 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25599 int result;
25600 PyObject * obj0 = 0 ;
25601 char *kwnames[] = {
25602 (char *) "self", NULL
25603 };
25604
25605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25607 if (SWIG_arg_fail(1)) SWIG_fail;
25608 {
25609 PyThreadState* __tstate = wxPyBeginAllowThreads();
25610 result = (int)((wxDateSpan const *)arg1)->GetDays();
25611
25612 wxPyEndAllowThreads(__tstate);
25613 if (PyErr_Occurred()) SWIG_fail;
25614 }
25615 {
25616 resultobj = SWIG_From_int((int)(result));
25617 }
25618 return resultobj;
25619 fail:
25620 return NULL;
25621 }
25622
25623
25624 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25625 PyObject *resultobj;
25626 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25627 int result;
25628 PyObject * obj0 = 0 ;
25629 char *kwnames[] = {
25630 (char *) "self", NULL
25631 };
25632
25633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25635 if (SWIG_arg_fail(1)) SWIG_fail;
25636 {
25637 PyThreadState* __tstate = wxPyBeginAllowThreads();
25638 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25639
25640 wxPyEndAllowThreads(__tstate);
25641 if (PyErr_Occurred()) SWIG_fail;
25642 }
25643 {
25644 resultobj = SWIG_From_int((int)(result));
25645 }
25646 return resultobj;
25647 fail:
25648 return NULL;
25649 }
25650
25651
25652 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25653 PyObject *resultobj;
25654 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25655 wxDateSpan *arg2 = 0 ;
25656 wxDateSpan *result;
25657 PyObject * obj0 = 0 ;
25658 PyObject * obj1 = 0 ;
25659 char *kwnames[] = {
25660 (char *) "self",(char *) "other", NULL
25661 };
25662
25663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25665 if (SWIG_arg_fail(1)) SWIG_fail;
25666 {
25667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25668 if (SWIG_arg_fail(2)) SWIG_fail;
25669 if (arg2 == NULL) {
25670 SWIG_null_ref("wxDateSpan");
25671 }
25672 if (SWIG_arg_fail(2)) SWIG_fail;
25673 }
25674 {
25675 PyThreadState* __tstate = wxPyBeginAllowThreads();
25676 {
25677 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25678 result = (wxDateSpan *) &_result_ref;
25679 }
25680
25681 wxPyEndAllowThreads(__tstate);
25682 if (PyErr_Occurred()) SWIG_fail;
25683 }
25684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25685 return resultobj;
25686 fail:
25687 return NULL;
25688 }
25689
25690
25691 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25692 PyObject *resultobj;
25693 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25694 wxDateSpan *arg2 = 0 ;
25695 wxDateSpan *result;
25696 PyObject * obj0 = 0 ;
25697 PyObject * obj1 = 0 ;
25698 char *kwnames[] = {
25699 (char *) "self",(char *) "other", NULL
25700 };
25701
25702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25704 if (SWIG_arg_fail(1)) SWIG_fail;
25705 {
25706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25707 if (SWIG_arg_fail(2)) SWIG_fail;
25708 if (arg2 == NULL) {
25709 SWIG_null_ref("wxDateSpan");
25710 }
25711 if (SWIG_arg_fail(2)) SWIG_fail;
25712 }
25713 {
25714 PyThreadState* __tstate = wxPyBeginAllowThreads();
25715 {
25716 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25717 result = (wxDateSpan *) &_result_ref;
25718 }
25719
25720 wxPyEndAllowThreads(__tstate);
25721 if (PyErr_Occurred()) SWIG_fail;
25722 }
25723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25724 return resultobj;
25725 fail:
25726 return NULL;
25727 }
25728
25729
25730 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25731 PyObject *resultobj;
25732 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25733 wxDateSpan *result;
25734 PyObject * obj0 = 0 ;
25735 char *kwnames[] = {
25736 (char *) "self", NULL
25737 };
25738
25739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25741 if (SWIG_arg_fail(1)) SWIG_fail;
25742 {
25743 PyThreadState* __tstate = wxPyBeginAllowThreads();
25744 {
25745 wxDateSpan &_result_ref = (arg1)->Neg();
25746 result = (wxDateSpan *) &_result_ref;
25747 }
25748
25749 wxPyEndAllowThreads(__tstate);
25750 if (PyErr_Occurred()) SWIG_fail;
25751 }
25752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25753 return resultobj;
25754 fail:
25755 return NULL;
25756 }
25757
25758
25759 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25760 PyObject *resultobj;
25761 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25762 int arg2 ;
25763 wxDateSpan *result;
25764 PyObject * obj0 = 0 ;
25765 PyObject * obj1 = 0 ;
25766 char *kwnames[] = {
25767 (char *) "self",(char *) "factor", NULL
25768 };
25769
25770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25772 if (SWIG_arg_fail(1)) SWIG_fail;
25773 {
25774 arg2 = (int)(SWIG_As_int(obj1));
25775 if (SWIG_arg_fail(2)) SWIG_fail;
25776 }
25777 {
25778 PyThreadState* __tstate = wxPyBeginAllowThreads();
25779 {
25780 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25781 result = (wxDateSpan *) &_result_ref;
25782 }
25783
25784 wxPyEndAllowThreads(__tstate);
25785 if (PyErr_Occurred()) SWIG_fail;
25786 }
25787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25788 return resultobj;
25789 fail:
25790 return NULL;
25791 }
25792
25793
25794 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25795 PyObject *resultobj;
25796 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25797 wxDateSpan *arg2 = 0 ;
25798 wxDateSpan *result;
25799 PyObject * obj0 = 0 ;
25800 PyObject * obj1 = 0 ;
25801 char *kwnames[] = {
25802 (char *) "self",(char *) "other", NULL
25803 };
25804
25805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25807 if (SWIG_arg_fail(1)) SWIG_fail;
25808 {
25809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25810 if (SWIG_arg_fail(2)) SWIG_fail;
25811 if (arg2 == NULL) {
25812 SWIG_null_ref("wxDateSpan");
25813 }
25814 if (SWIG_arg_fail(2)) SWIG_fail;
25815 }
25816 {
25817 PyThreadState* __tstate = wxPyBeginAllowThreads();
25818 {
25819 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25820 result = (wxDateSpan *) &_result_ref;
25821 }
25822
25823 wxPyEndAllowThreads(__tstate);
25824 if (PyErr_Occurred()) SWIG_fail;
25825 }
25826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25827 return resultobj;
25828 fail:
25829 return NULL;
25830 }
25831
25832
25833 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25834 PyObject *resultobj;
25835 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25836 wxDateSpan *arg2 = 0 ;
25837 wxDateSpan *result;
25838 PyObject * obj0 = 0 ;
25839 PyObject * obj1 = 0 ;
25840 char *kwnames[] = {
25841 (char *) "self",(char *) "other", NULL
25842 };
25843
25844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25846 if (SWIG_arg_fail(1)) SWIG_fail;
25847 {
25848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25849 if (SWIG_arg_fail(2)) SWIG_fail;
25850 if (arg2 == NULL) {
25851 SWIG_null_ref("wxDateSpan");
25852 }
25853 if (SWIG_arg_fail(2)) SWIG_fail;
25854 }
25855 {
25856 PyThreadState* __tstate = wxPyBeginAllowThreads();
25857 {
25858 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25859 result = (wxDateSpan *) &_result_ref;
25860 }
25861
25862 wxPyEndAllowThreads(__tstate);
25863 if (PyErr_Occurred()) SWIG_fail;
25864 }
25865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25866 return resultobj;
25867 fail:
25868 return NULL;
25869 }
25870
25871
25872 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25873 PyObject *resultobj;
25874 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25875 wxDateSpan *result;
25876 PyObject * obj0 = 0 ;
25877 char *kwnames[] = {
25878 (char *) "self", NULL
25879 };
25880
25881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25883 if (SWIG_arg_fail(1)) SWIG_fail;
25884 {
25885 PyThreadState* __tstate = wxPyBeginAllowThreads();
25886 {
25887 wxDateSpan &_result_ref = (arg1)->operator -();
25888 result = (wxDateSpan *) &_result_ref;
25889 }
25890
25891 wxPyEndAllowThreads(__tstate);
25892 if (PyErr_Occurred()) SWIG_fail;
25893 }
25894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25895 return resultobj;
25896 fail:
25897 return NULL;
25898 }
25899
25900
25901 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25902 PyObject *resultobj;
25903 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25904 int arg2 ;
25905 wxDateSpan *result;
25906 PyObject * obj0 = 0 ;
25907 PyObject * obj1 = 0 ;
25908 char *kwnames[] = {
25909 (char *) "self",(char *) "factor", NULL
25910 };
25911
25912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25914 if (SWIG_arg_fail(1)) SWIG_fail;
25915 {
25916 arg2 = (int)(SWIG_As_int(obj1));
25917 if (SWIG_arg_fail(2)) SWIG_fail;
25918 }
25919 {
25920 PyThreadState* __tstate = wxPyBeginAllowThreads();
25921 {
25922 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25923 result = (wxDateSpan *) &_result_ref;
25924 }
25925
25926 wxPyEndAllowThreads(__tstate);
25927 if (PyErr_Occurred()) SWIG_fail;
25928 }
25929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25930 return resultobj;
25931 fail:
25932 return NULL;
25933 }
25934
25935
25936 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25937 PyObject *resultobj;
25938 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25939 wxDateSpan *arg2 = 0 ;
25940 wxDateSpan result;
25941 PyObject * obj0 = 0 ;
25942 PyObject * obj1 = 0 ;
25943 char *kwnames[] = {
25944 (char *) "self",(char *) "other", NULL
25945 };
25946
25947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25949 if (SWIG_arg_fail(1)) SWIG_fail;
25950 {
25951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25952 if (SWIG_arg_fail(2)) SWIG_fail;
25953 if (arg2 == NULL) {
25954 SWIG_null_ref("wxDateSpan");
25955 }
25956 if (SWIG_arg_fail(2)) SWIG_fail;
25957 }
25958 {
25959 PyThreadState* __tstate = wxPyBeginAllowThreads();
25960 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25961
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 {
25966 wxDateSpan * resultptr;
25967 resultptr = new wxDateSpan((wxDateSpan &)(result));
25968 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25969 }
25970 return resultobj;
25971 fail:
25972 return NULL;
25973 }
25974
25975
25976 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25977 PyObject *resultobj;
25978 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25979 wxDateSpan *arg2 = 0 ;
25980 wxDateSpan result;
25981 PyObject * obj0 = 0 ;
25982 PyObject * obj1 = 0 ;
25983 char *kwnames[] = {
25984 (char *) "self",(char *) "other", NULL
25985 };
25986
25987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25989 if (SWIG_arg_fail(1)) SWIG_fail;
25990 {
25991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25992 if (SWIG_arg_fail(2)) SWIG_fail;
25993 if (arg2 == NULL) {
25994 SWIG_null_ref("wxDateSpan");
25995 }
25996 if (SWIG_arg_fail(2)) SWIG_fail;
25997 }
25998 {
25999 PyThreadState* __tstate = wxPyBeginAllowThreads();
26000 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26001
26002 wxPyEndAllowThreads(__tstate);
26003 if (PyErr_Occurred()) SWIG_fail;
26004 }
26005 {
26006 wxDateSpan * resultptr;
26007 resultptr = new wxDateSpan((wxDateSpan &)(result));
26008 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26009 }
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26017 PyObject *resultobj;
26018 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26019 int arg2 ;
26020 wxDateSpan result;
26021 PyObject * obj0 = 0 ;
26022 PyObject * obj1 = 0 ;
26023 char *kwnames[] = {
26024 (char *) "self",(char *) "n", NULL
26025 };
26026
26027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26029 if (SWIG_arg_fail(1)) SWIG_fail;
26030 {
26031 arg2 = (int)(SWIG_As_int(obj1));
26032 if (SWIG_arg_fail(2)) SWIG_fail;
26033 }
26034 {
26035 PyThreadState* __tstate = wxPyBeginAllowThreads();
26036 result = wxDateSpan___mul__(arg1,arg2);
26037
26038 wxPyEndAllowThreads(__tstate);
26039 if (PyErr_Occurred()) SWIG_fail;
26040 }
26041 {
26042 wxDateSpan * resultptr;
26043 resultptr = new wxDateSpan((wxDateSpan &)(result));
26044 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26045 }
26046 return resultobj;
26047 fail:
26048 return NULL;
26049 }
26050
26051
26052 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26053 PyObject *resultobj;
26054 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26055 int arg2 ;
26056 wxDateSpan result;
26057 PyObject * obj0 = 0 ;
26058 PyObject * obj1 = 0 ;
26059 char *kwnames[] = {
26060 (char *) "self",(char *) "n", NULL
26061 };
26062
26063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26065 if (SWIG_arg_fail(1)) SWIG_fail;
26066 {
26067 arg2 = (int)(SWIG_As_int(obj1));
26068 if (SWIG_arg_fail(2)) SWIG_fail;
26069 }
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 result = wxDateSpan___rmul__(arg1,arg2);
26073
26074 wxPyEndAllowThreads(__tstate);
26075 if (PyErr_Occurred()) SWIG_fail;
26076 }
26077 {
26078 wxDateSpan * resultptr;
26079 resultptr = new wxDateSpan((wxDateSpan &)(result));
26080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26081 }
26082 return resultobj;
26083 fail:
26084 return NULL;
26085 }
26086
26087
26088 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26089 PyObject *resultobj;
26090 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26091 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26092 bool result;
26093 PyObject * obj0 = 0 ;
26094 PyObject * obj1 = 0 ;
26095 char *kwnames[] = {
26096 (char *) "self",(char *) "other", NULL
26097 };
26098
26099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26101 if (SWIG_arg_fail(1)) SWIG_fail;
26102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26103 if (SWIG_arg_fail(2)) SWIG_fail;
26104 {
26105 PyThreadState* __tstate = wxPyBeginAllowThreads();
26106 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26107
26108 wxPyEndAllowThreads(__tstate);
26109 if (PyErr_Occurred()) SWIG_fail;
26110 }
26111 {
26112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26113 }
26114 return resultobj;
26115 fail:
26116 return NULL;
26117 }
26118
26119
26120 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26121 PyObject *resultobj;
26122 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26123 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26124 bool result;
26125 PyObject * obj0 = 0 ;
26126 PyObject * obj1 = 0 ;
26127 char *kwnames[] = {
26128 (char *) "self",(char *) "other", NULL
26129 };
26130
26131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26133 if (SWIG_arg_fail(1)) SWIG_fail;
26134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26135 if (SWIG_arg_fail(2)) SWIG_fail;
26136 {
26137 PyThreadState* __tstate = wxPyBeginAllowThreads();
26138 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26139
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 {
26144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26145 }
26146 return resultobj;
26147 fail:
26148 return NULL;
26149 }
26150
26151
26152 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26153 PyObject *obj;
26154 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26155 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26156 Py_INCREF(obj);
26157 return Py_BuildValue((char *)"");
26158 }
26159 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26160 PyObject *resultobj;
26161 long result;
26162 char *kwnames[] = {
26163 NULL
26164 };
26165
26166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26167 {
26168 PyThreadState* __tstate = wxPyBeginAllowThreads();
26169 result = (long)wxGetLocalTime();
26170
26171 wxPyEndAllowThreads(__tstate);
26172 if (PyErr_Occurred()) SWIG_fail;
26173 }
26174 {
26175 resultobj = SWIG_From_long((long)(result));
26176 }
26177 return resultobj;
26178 fail:
26179 return NULL;
26180 }
26181
26182
26183 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26184 PyObject *resultobj;
26185 long result;
26186 char *kwnames[] = {
26187 NULL
26188 };
26189
26190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26191 {
26192 PyThreadState* __tstate = wxPyBeginAllowThreads();
26193 result = (long)wxGetUTCTime();
26194
26195 wxPyEndAllowThreads(__tstate);
26196 if (PyErr_Occurred()) SWIG_fail;
26197 }
26198 {
26199 resultobj = SWIG_From_long((long)(result));
26200 }
26201 return resultobj;
26202 fail:
26203 return NULL;
26204 }
26205
26206
26207 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26208 PyObject *resultobj;
26209 long result;
26210 char *kwnames[] = {
26211 NULL
26212 };
26213
26214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26215 {
26216 PyThreadState* __tstate = wxPyBeginAllowThreads();
26217 result = (long)wxGetCurrentTime();
26218
26219 wxPyEndAllowThreads(__tstate);
26220 if (PyErr_Occurred()) SWIG_fail;
26221 }
26222 {
26223 resultobj = SWIG_From_long((long)(result));
26224 }
26225 return resultobj;
26226 fail:
26227 return NULL;
26228 }
26229
26230
26231 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26232 PyObject *resultobj;
26233 wxLongLong result;
26234 char *kwnames[] = {
26235 NULL
26236 };
26237
26238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26239 {
26240 PyThreadState* __tstate = wxPyBeginAllowThreads();
26241 result = wxGetLocalTimeMillis();
26242
26243 wxPyEndAllowThreads(__tstate);
26244 if (PyErr_Occurred()) SWIG_fail;
26245 }
26246 {
26247 PyObject *hi, *lo, *shifter, *shifted;
26248 hi = PyLong_FromLong( (&result)->GetHi() );
26249 lo = PyLong_FromLong( (&result)->GetLo() );
26250 shifter = PyLong_FromLong(32);
26251 shifted = PyNumber_Lshift(hi, shifter);
26252 resultobj = PyNumber_Or(shifted, lo);
26253 Py_DECREF(hi);
26254 Py_DECREF(lo);
26255 Py_DECREF(shifter);
26256 Py_DECREF(shifted);
26257 }
26258 return resultobj;
26259 fail:
26260 return NULL;
26261 }
26262
26263
26264 static int _wrap_DefaultDateTime_set(PyObject *) {
26265 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26266 return 1;
26267 }
26268
26269
26270 static PyObject *_wrap_DefaultDateTime_get(void) {
26271 PyObject *pyobj;
26272
26273 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26274 return pyobj;
26275 }
26276
26277
26278 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26279 PyObject *resultobj;
26280 wxDataFormatId arg1 ;
26281 wxDataFormat *result;
26282 PyObject * obj0 = 0 ;
26283 char *kwnames[] = {
26284 (char *) "type", NULL
26285 };
26286
26287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26288 {
26289 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26290 if (SWIG_arg_fail(1)) SWIG_fail;
26291 }
26292 {
26293 PyThreadState* __tstate = wxPyBeginAllowThreads();
26294 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26295
26296 wxPyEndAllowThreads(__tstate);
26297 if (PyErr_Occurred()) SWIG_fail;
26298 }
26299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26300 return resultobj;
26301 fail:
26302 return NULL;
26303 }
26304
26305
26306 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26307 PyObject *resultobj;
26308 wxString *arg1 = 0 ;
26309 wxDataFormat *result;
26310 bool temp1 = false ;
26311 PyObject * obj0 = 0 ;
26312 char *kwnames[] = {
26313 (char *) "format", NULL
26314 };
26315
26316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26317 {
26318 arg1 = wxString_in_helper(obj0);
26319 if (arg1 == NULL) SWIG_fail;
26320 temp1 = true;
26321 }
26322 {
26323 PyThreadState* __tstate = wxPyBeginAllowThreads();
26324 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26325
26326 wxPyEndAllowThreads(__tstate);
26327 if (PyErr_Occurred()) SWIG_fail;
26328 }
26329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26330 {
26331 if (temp1)
26332 delete arg1;
26333 }
26334 return resultobj;
26335 fail:
26336 {
26337 if (temp1)
26338 delete arg1;
26339 }
26340 return NULL;
26341 }
26342
26343
26344 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26345 PyObject *resultobj;
26346 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26347 PyObject * obj0 = 0 ;
26348 char *kwnames[] = {
26349 (char *) "self", NULL
26350 };
26351
26352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26354 if (SWIG_arg_fail(1)) SWIG_fail;
26355 {
26356 PyThreadState* __tstate = wxPyBeginAllowThreads();
26357 delete arg1;
26358
26359 wxPyEndAllowThreads(__tstate);
26360 if (PyErr_Occurred()) SWIG_fail;
26361 }
26362 Py_INCREF(Py_None); resultobj = Py_None;
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26370 PyObject *resultobj;
26371 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26372 wxDataFormatId arg2 ;
26373 bool result;
26374 PyObject * obj0 = 0 ;
26375 PyObject * obj1 = 0 ;
26376
26377 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26379 if (SWIG_arg_fail(1)) SWIG_fail;
26380 {
26381 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26382 if (SWIG_arg_fail(2)) SWIG_fail;
26383 }
26384 {
26385 PyThreadState* __tstate = wxPyBeginAllowThreads();
26386 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26387
26388 wxPyEndAllowThreads(__tstate);
26389 if (PyErr_Occurred()) SWIG_fail;
26390 }
26391 {
26392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26393 }
26394 return resultobj;
26395 fail:
26396 return NULL;
26397 }
26398
26399
26400 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26401 PyObject *resultobj;
26402 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26403 wxDataFormatId arg2 ;
26404 bool result;
26405 PyObject * obj0 = 0 ;
26406 PyObject * obj1 = 0 ;
26407
26408 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26410 if (SWIG_arg_fail(1)) SWIG_fail;
26411 {
26412 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26413 if (SWIG_arg_fail(2)) SWIG_fail;
26414 }
26415 {
26416 PyThreadState* __tstate = wxPyBeginAllowThreads();
26417 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26418
26419 wxPyEndAllowThreads(__tstate);
26420 if (PyErr_Occurred()) SWIG_fail;
26421 }
26422 {
26423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26424 }
26425 return resultobj;
26426 fail:
26427 return NULL;
26428 }
26429
26430
26431 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26432 PyObject *resultobj;
26433 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26434 wxDataFormat *arg2 = 0 ;
26435 bool result;
26436 PyObject * obj0 = 0 ;
26437 PyObject * obj1 = 0 ;
26438
26439 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26441 if (SWIG_arg_fail(1)) SWIG_fail;
26442 {
26443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26444 if (SWIG_arg_fail(2)) SWIG_fail;
26445 if (arg2 == NULL) {
26446 SWIG_null_ref("wxDataFormat");
26447 }
26448 if (SWIG_arg_fail(2)) SWIG_fail;
26449 }
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26453
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 {
26458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26459 }
26460 return resultobj;
26461 fail:
26462 return NULL;
26463 }
26464
26465
26466 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26467 int argc;
26468 PyObject *argv[3];
26469 int ii;
26470
26471 argc = PyObject_Length(args);
26472 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26473 argv[ii] = PyTuple_GetItem(args,ii);
26474 }
26475 if (argc == 2) {
26476 int _v;
26477 {
26478 void *ptr;
26479 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26480 _v = 0;
26481 PyErr_Clear();
26482 } else {
26483 _v = 1;
26484 }
26485 }
26486 if (_v) {
26487 {
26488 void *ptr = 0;
26489 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26490 _v = 0;
26491 PyErr_Clear();
26492 } else {
26493 _v = (ptr != 0);
26494 }
26495 }
26496 if (_v) {
26497 return _wrap_DataFormat___eq____SWIG_1(self,args);
26498 }
26499 }
26500 }
26501 if (argc == 2) {
26502 int _v;
26503 {
26504 void *ptr;
26505 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26506 _v = 0;
26507 PyErr_Clear();
26508 } else {
26509 _v = 1;
26510 }
26511 }
26512 if (_v) {
26513 _v = SWIG_Check_int(argv[1]);
26514 if (_v) {
26515 return _wrap_DataFormat___eq____SWIG_0(self,args);
26516 }
26517 }
26518 }
26519
26520 Py_INCREF(Py_NotImplemented);
26521 return Py_NotImplemented;
26522 }
26523
26524
26525 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26526 PyObject *resultobj;
26527 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26528 wxDataFormat *arg2 = 0 ;
26529 bool result;
26530 PyObject * obj0 = 0 ;
26531 PyObject * obj1 = 0 ;
26532
26533 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26535 if (SWIG_arg_fail(1)) SWIG_fail;
26536 {
26537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26538 if (SWIG_arg_fail(2)) SWIG_fail;
26539 if (arg2 == NULL) {
26540 SWIG_null_ref("wxDataFormat");
26541 }
26542 if (SWIG_arg_fail(2)) SWIG_fail;
26543 }
26544 {
26545 PyThreadState* __tstate = wxPyBeginAllowThreads();
26546 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26547
26548 wxPyEndAllowThreads(__tstate);
26549 if (PyErr_Occurred()) SWIG_fail;
26550 }
26551 {
26552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26553 }
26554 return resultobj;
26555 fail:
26556 return NULL;
26557 }
26558
26559
26560 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26561 int argc;
26562 PyObject *argv[3];
26563 int ii;
26564
26565 argc = PyObject_Length(args);
26566 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26567 argv[ii] = PyTuple_GetItem(args,ii);
26568 }
26569 if (argc == 2) {
26570 int _v;
26571 {
26572 void *ptr;
26573 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26574 _v = 0;
26575 PyErr_Clear();
26576 } else {
26577 _v = 1;
26578 }
26579 }
26580 if (_v) {
26581 {
26582 void *ptr = 0;
26583 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26584 _v = 0;
26585 PyErr_Clear();
26586 } else {
26587 _v = (ptr != 0);
26588 }
26589 }
26590 if (_v) {
26591 return _wrap_DataFormat___ne____SWIG_1(self,args);
26592 }
26593 }
26594 }
26595 if (argc == 2) {
26596 int _v;
26597 {
26598 void *ptr;
26599 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26600 _v = 0;
26601 PyErr_Clear();
26602 } else {
26603 _v = 1;
26604 }
26605 }
26606 if (_v) {
26607 _v = SWIG_Check_int(argv[1]);
26608 if (_v) {
26609 return _wrap_DataFormat___ne____SWIG_0(self,args);
26610 }
26611 }
26612 }
26613
26614 Py_INCREF(Py_NotImplemented);
26615 return Py_NotImplemented;
26616 }
26617
26618
26619 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26620 PyObject *resultobj;
26621 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26622 wxDataFormatId arg2 ;
26623 PyObject * obj0 = 0 ;
26624 PyObject * obj1 = 0 ;
26625 char *kwnames[] = {
26626 (char *) "self",(char *) "format", NULL
26627 };
26628
26629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26631 if (SWIG_arg_fail(1)) SWIG_fail;
26632 {
26633 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26634 if (SWIG_arg_fail(2)) SWIG_fail;
26635 }
26636 {
26637 PyThreadState* __tstate = wxPyBeginAllowThreads();
26638 (arg1)->SetType((wxDataFormatId )arg2);
26639
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 Py_INCREF(Py_None); resultobj = Py_None;
26644 return resultobj;
26645 fail:
26646 return NULL;
26647 }
26648
26649
26650 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26651 PyObject *resultobj;
26652 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26653 wxDataFormatId result;
26654 PyObject * obj0 = 0 ;
26655 char *kwnames[] = {
26656 (char *) "self", NULL
26657 };
26658
26659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26661 if (SWIG_arg_fail(1)) SWIG_fail;
26662 {
26663 PyThreadState* __tstate = wxPyBeginAllowThreads();
26664 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26665
26666 wxPyEndAllowThreads(__tstate);
26667 if (PyErr_Occurred()) SWIG_fail;
26668 }
26669 resultobj = SWIG_From_int((result));
26670 return resultobj;
26671 fail:
26672 return NULL;
26673 }
26674
26675
26676 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26677 PyObject *resultobj;
26678 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26679 wxString result;
26680 PyObject * obj0 = 0 ;
26681 char *kwnames[] = {
26682 (char *) "self", NULL
26683 };
26684
26685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26687 if (SWIG_arg_fail(1)) SWIG_fail;
26688 {
26689 PyThreadState* __tstate = wxPyBeginAllowThreads();
26690 result = ((wxDataFormat const *)arg1)->GetId();
26691
26692 wxPyEndAllowThreads(__tstate);
26693 if (PyErr_Occurred()) SWIG_fail;
26694 }
26695 {
26696 #if wxUSE_UNICODE
26697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26698 #else
26699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26700 #endif
26701 }
26702 return resultobj;
26703 fail:
26704 return NULL;
26705 }
26706
26707
26708 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26709 PyObject *resultobj;
26710 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26711 wxString *arg2 = 0 ;
26712 bool temp2 = false ;
26713 PyObject * obj0 = 0 ;
26714 PyObject * obj1 = 0 ;
26715 char *kwnames[] = {
26716 (char *) "self",(char *) "format", NULL
26717 };
26718
26719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26721 if (SWIG_arg_fail(1)) SWIG_fail;
26722 {
26723 arg2 = wxString_in_helper(obj1);
26724 if (arg2 == NULL) SWIG_fail;
26725 temp2 = true;
26726 }
26727 {
26728 PyThreadState* __tstate = wxPyBeginAllowThreads();
26729 (arg1)->SetId((wxString const &)*arg2);
26730
26731 wxPyEndAllowThreads(__tstate);
26732 if (PyErr_Occurred()) SWIG_fail;
26733 }
26734 Py_INCREF(Py_None); resultobj = Py_None;
26735 {
26736 if (temp2)
26737 delete arg2;
26738 }
26739 return resultobj;
26740 fail:
26741 {
26742 if (temp2)
26743 delete arg2;
26744 }
26745 return NULL;
26746 }
26747
26748
26749 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26750 PyObject *obj;
26751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26752 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26753 Py_INCREF(obj);
26754 return Py_BuildValue((char *)"");
26755 }
26756 static int _wrap_FormatInvalid_set(PyObject *) {
26757 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26758 return 1;
26759 }
26760
26761
26762 static PyObject *_wrap_FormatInvalid_get(void) {
26763 PyObject *pyobj;
26764
26765 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26766 return pyobj;
26767 }
26768
26769
26770 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj;
26772 wxDataObject *arg1 = (wxDataObject *) 0 ;
26773 PyObject * obj0 = 0 ;
26774 char *kwnames[] = {
26775 (char *) "self", NULL
26776 };
26777
26778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26780 if (SWIG_arg_fail(1)) SWIG_fail;
26781 {
26782 PyThreadState* __tstate = wxPyBeginAllowThreads();
26783 delete arg1;
26784
26785 wxPyEndAllowThreads(__tstate);
26786 if (PyErr_Occurred()) SWIG_fail;
26787 }
26788 Py_INCREF(Py_None); resultobj = Py_None;
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26796 PyObject *resultobj;
26797 wxDataObject *arg1 = (wxDataObject *) 0 ;
26798 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26799 SwigValueWrapper<wxDataFormat > result;
26800 PyObject * obj0 = 0 ;
26801 PyObject * obj1 = 0 ;
26802 char *kwnames[] = {
26803 (char *) "self",(char *) "dir", NULL
26804 };
26805
26806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26808 if (SWIG_arg_fail(1)) SWIG_fail;
26809 if (obj1) {
26810 {
26811 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26812 if (SWIG_arg_fail(2)) SWIG_fail;
26813 }
26814 }
26815 {
26816 PyThreadState* __tstate = wxPyBeginAllowThreads();
26817 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26818
26819 wxPyEndAllowThreads(__tstate);
26820 if (PyErr_Occurred()) SWIG_fail;
26821 }
26822 {
26823 wxDataFormat * resultptr;
26824 resultptr = new wxDataFormat((wxDataFormat &)(result));
26825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26826 }
26827 return resultobj;
26828 fail:
26829 return NULL;
26830 }
26831
26832
26833 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26834 PyObject *resultobj;
26835 wxDataObject *arg1 = (wxDataObject *) 0 ;
26836 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26837 size_t result;
26838 PyObject * obj0 = 0 ;
26839 PyObject * obj1 = 0 ;
26840 char *kwnames[] = {
26841 (char *) "self",(char *) "dir", NULL
26842 };
26843
26844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26846 if (SWIG_arg_fail(1)) SWIG_fail;
26847 if (obj1) {
26848 {
26849 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26850 if (SWIG_arg_fail(2)) SWIG_fail;
26851 }
26852 }
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26856
26857 wxPyEndAllowThreads(__tstate);
26858 if (PyErr_Occurred()) SWIG_fail;
26859 }
26860 {
26861 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26862 }
26863 return resultobj;
26864 fail:
26865 return NULL;
26866 }
26867
26868
26869 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26870 PyObject *resultobj;
26871 wxDataObject *arg1 = (wxDataObject *) 0 ;
26872 wxDataFormat *arg2 = 0 ;
26873 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26874 bool result;
26875 PyObject * obj0 = 0 ;
26876 PyObject * obj1 = 0 ;
26877 PyObject * obj2 = 0 ;
26878 char *kwnames[] = {
26879 (char *) "self",(char *) "format",(char *) "dir", NULL
26880 };
26881
26882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26884 if (SWIG_arg_fail(1)) SWIG_fail;
26885 {
26886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26887 if (SWIG_arg_fail(2)) SWIG_fail;
26888 if (arg2 == NULL) {
26889 SWIG_null_ref("wxDataFormat");
26890 }
26891 if (SWIG_arg_fail(2)) SWIG_fail;
26892 }
26893 if (obj2) {
26894 {
26895 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26896 if (SWIG_arg_fail(3)) SWIG_fail;
26897 }
26898 }
26899 {
26900 PyThreadState* __tstate = wxPyBeginAllowThreads();
26901 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26902
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 {
26907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26908 }
26909 return resultobj;
26910 fail:
26911 return NULL;
26912 }
26913
26914
26915 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26916 PyObject *resultobj;
26917 wxDataObject *arg1 = (wxDataObject *) 0 ;
26918 wxDataFormat *arg2 = 0 ;
26919 size_t result;
26920 PyObject * obj0 = 0 ;
26921 PyObject * obj1 = 0 ;
26922 char *kwnames[] = {
26923 (char *) "self",(char *) "format", NULL
26924 };
26925
26926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26928 if (SWIG_arg_fail(1)) SWIG_fail;
26929 {
26930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26931 if (SWIG_arg_fail(2)) SWIG_fail;
26932 if (arg2 == NULL) {
26933 SWIG_null_ref("wxDataFormat");
26934 }
26935 if (SWIG_arg_fail(2)) SWIG_fail;
26936 }
26937 {
26938 PyThreadState* __tstate = wxPyBeginAllowThreads();
26939 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26940
26941 wxPyEndAllowThreads(__tstate);
26942 if (PyErr_Occurred()) SWIG_fail;
26943 }
26944 {
26945 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26946 }
26947 return resultobj;
26948 fail:
26949 return NULL;
26950 }
26951
26952
26953 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26954 PyObject *resultobj;
26955 wxDataObject *arg1 = (wxDataObject *) 0 ;
26956 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26957 PyObject *result;
26958 PyObject * obj0 = 0 ;
26959 PyObject * obj1 = 0 ;
26960 char *kwnames[] = {
26961 (char *) "self",(char *) "dir", NULL
26962 };
26963
26964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26966 if (SWIG_arg_fail(1)) SWIG_fail;
26967 if (obj1) {
26968 {
26969 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26970 if (SWIG_arg_fail(2)) SWIG_fail;
26971 }
26972 }
26973 {
26974 PyThreadState* __tstate = wxPyBeginAllowThreads();
26975 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26976
26977 wxPyEndAllowThreads(__tstate);
26978 if (PyErr_Occurred()) SWIG_fail;
26979 }
26980 resultobj = result;
26981 return resultobj;
26982 fail:
26983 return NULL;
26984 }
26985
26986
26987 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26988 PyObject *resultobj;
26989 wxDataObject *arg1 = (wxDataObject *) 0 ;
26990 wxDataFormat *arg2 = 0 ;
26991 PyObject *result;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 char *kwnames[] = {
26995 (char *) "self",(char *) "format", NULL
26996 };
26997
26998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
26999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27000 if (SWIG_arg_fail(1)) SWIG_fail;
27001 {
27002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27003 if (SWIG_arg_fail(2)) SWIG_fail;
27004 if (arg2 == NULL) {
27005 SWIG_null_ref("wxDataFormat");
27006 }
27007 if (SWIG_arg_fail(2)) SWIG_fail;
27008 }
27009 {
27010 PyThreadState* __tstate = wxPyBeginAllowThreads();
27011 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27012
27013 wxPyEndAllowThreads(__tstate);
27014 if (PyErr_Occurred()) SWIG_fail;
27015 }
27016 resultobj = result;
27017 return resultobj;
27018 fail:
27019 return NULL;
27020 }
27021
27022
27023 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27024 PyObject *resultobj;
27025 wxDataObject *arg1 = (wxDataObject *) 0 ;
27026 wxDataFormat *arg2 = 0 ;
27027 PyObject *arg3 = (PyObject *) 0 ;
27028 bool result;
27029 PyObject * obj0 = 0 ;
27030 PyObject * obj1 = 0 ;
27031 PyObject * obj2 = 0 ;
27032 char *kwnames[] = {
27033 (char *) "self",(char *) "format",(char *) "data", NULL
27034 };
27035
27036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27038 if (SWIG_arg_fail(1)) SWIG_fail;
27039 {
27040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27041 if (SWIG_arg_fail(2)) SWIG_fail;
27042 if (arg2 == NULL) {
27043 SWIG_null_ref("wxDataFormat");
27044 }
27045 if (SWIG_arg_fail(2)) SWIG_fail;
27046 }
27047 arg3 = obj2;
27048 {
27049 PyThreadState* __tstate = wxPyBeginAllowThreads();
27050 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27051
27052 wxPyEndAllowThreads(__tstate);
27053 if (PyErr_Occurred()) SWIG_fail;
27054 }
27055 {
27056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27057 }
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27065 PyObject *obj;
27066 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27067 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27068 Py_INCREF(obj);
27069 return Py_BuildValue((char *)"");
27070 }
27071 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27072 PyObject *resultobj;
27073 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27074 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27075 wxDataObjectSimple *result;
27076 PyObject * obj0 = 0 ;
27077 char *kwnames[] = {
27078 (char *) "format", NULL
27079 };
27080
27081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27082 if (obj0) {
27083 {
27084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27085 if (SWIG_arg_fail(1)) SWIG_fail;
27086 if (arg1 == NULL) {
27087 SWIG_null_ref("wxDataFormat");
27088 }
27089 if (SWIG_arg_fail(1)) SWIG_fail;
27090 }
27091 }
27092 {
27093 PyThreadState* __tstate = wxPyBeginAllowThreads();
27094 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27095
27096 wxPyEndAllowThreads(__tstate);
27097 if (PyErr_Occurred()) SWIG_fail;
27098 }
27099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27100 return resultobj;
27101 fail:
27102 return NULL;
27103 }
27104
27105
27106 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27107 PyObject *resultobj;
27108 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27109 wxDataFormat *result;
27110 PyObject * obj0 = 0 ;
27111 char *kwnames[] = {
27112 (char *) "self", NULL
27113 };
27114
27115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27117 if (SWIG_arg_fail(1)) SWIG_fail;
27118 {
27119 PyThreadState* __tstate = wxPyBeginAllowThreads();
27120 {
27121 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27122 result = (wxDataFormat *) &_result_ref;
27123 }
27124
27125 wxPyEndAllowThreads(__tstate);
27126 if (PyErr_Occurred()) SWIG_fail;
27127 }
27128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27129 return resultobj;
27130 fail:
27131 return NULL;
27132 }
27133
27134
27135 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27136 PyObject *resultobj;
27137 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27138 wxDataFormat *arg2 = 0 ;
27139 PyObject * obj0 = 0 ;
27140 PyObject * obj1 = 0 ;
27141 char *kwnames[] = {
27142 (char *) "self",(char *) "format", NULL
27143 };
27144
27145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27147 if (SWIG_arg_fail(1)) SWIG_fail;
27148 {
27149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27150 if (SWIG_arg_fail(2)) SWIG_fail;
27151 if (arg2 == NULL) {
27152 SWIG_null_ref("wxDataFormat");
27153 }
27154 if (SWIG_arg_fail(2)) SWIG_fail;
27155 }
27156 {
27157 PyThreadState* __tstate = wxPyBeginAllowThreads();
27158 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27159
27160 wxPyEndAllowThreads(__tstate);
27161 if (PyErr_Occurred()) SWIG_fail;
27162 }
27163 Py_INCREF(Py_None); resultobj = Py_None;
27164 return resultobj;
27165 fail:
27166 return NULL;
27167 }
27168
27169
27170 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27171 PyObject *resultobj;
27172 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27173 size_t result;
27174 PyObject * obj0 = 0 ;
27175 char *kwnames[] = {
27176 (char *) "self", NULL
27177 };
27178
27179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27181 if (SWIG_arg_fail(1)) SWIG_fail;
27182 {
27183 PyThreadState* __tstate = wxPyBeginAllowThreads();
27184 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27185
27186 wxPyEndAllowThreads(__tstate);
27187 if (PyErr_Occurred()) SWIG_fail;
27188 }
27189 {
27190 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27191 }
27192 return resultobj;
27193 fail:
27194 return NULL;
27195 }
27196
27197
27198 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27199 PyObject *resultobj;
27200 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27201 PyObject *result;
27202 PyObject * obj0 = 0 ;
27203 char *kwnames[] = {
27204 (char *) "self", NULL
27205 };
27206
27207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27209 if (SWIG_arg_fail(1)) SWIG_fail;
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27213
27214 wxPyEndAllowThreads(__tstate);
27215 if (PyErr_Occurred()) SWIG_fail;
27216 }
27217 resultobj = result;
27218 return resultobj;
27219 fail:
27220 return NULL;
27221 }
27222
27223
27224 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27225 PyObject *resultobj;
27226 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27227 PyObject *arg2 = (PyObject *) 0 ;
27228 bool result;
27229 PyObject * obj0 = 0 ;
27230 PyObject * obj1 = 0 ;
27231 char *kwnames[] = {
27232 (char *) "self",(char *) "data", NULL
27233 };
27234
27235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27237 if (SWIG_arg_fail(1)) SWIG_fail;
27238 arg2 = obj1;
27239 {
27240 PyThreadState* __tstate = wxPyBeginAllowThreads();
27241 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27242
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 {
27247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27248 }
27249 return resultobj;
27250 fail:
27251 return NULL;
27252 }
27253
27254
27255 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27256 PyObject *obj;
27257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27258 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27259 Py_INCREF(obj);
27260 return Py_BuildValue((char *)"");
27261 }
27262 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27263 PyObject *resultobj;
27264 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27265 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27266 wxPyDataObjectSimple *result;
27267 PyObject * obj0 = 0 ;
27268 char *kwnames[] = {
27269 (char *) "format", NULL
27270 };
27271
27272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27273 if (obj0) {
27274 {
27275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27276 if (SWIG_arg_fail(1)) SWIG_fail;
27277 if (arg1 == NULL) {
27278 SWIG_null_ref("wxDataFormat");
27279 }
27280 if (SWIG_arg_fail(1)) SWIG_fail;
27281 }
27282 }
27283 {
27284 PyThreadState* __tstate = wxPyBeginAllowThreads();
27285 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27286
27287 wxPyEndAllowThreads(__tstate);
27288 if (PyErr_Occurred()) SWIG_fail;
27289 }
27290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27291 return resultobj;
27292 fail:
27293 return NULL;
27294 }
27295
27296
27297 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27298 PyObject *resultobj;
27299 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27300 PyObject *arg2 = (PyObject *) 0 ;
27301 PyObject *arg3 = (PyObject *) 0 ;
27302 PyObject * obj0 = 0 ;
27303 PyObject * obj1 = 0 ;
27304 PyObject * obj2 = 0 ;
27305 char *kwnames[] = {
27306 (char *) "self",(char *) "self",(char *) "_class", NULL
27307 };
27308
27309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27311 if (SWIG_arg_fail(1)) SWIG_fail;
27312 arg2 = obj1;
27313 arg3 = obj2;
27314 {
27315 PyThreadState* __tstate = wxPyBeginAllowThreads();
27316 (arg1)->_setCallbackInfo(arg2,arg3);
27317
27318 wxPyEndAllowThreads(__tstate);
27319 if (PyErr_Occurred()) SWIG_fail;
27320 }
27321 Py_INCREF(Py_None); resultobj = Py_None;
27322 return resultobj;
27323 fail:
27324 return NULL;
27325 }
27326
27327
27328 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27329 PyObject *obj;
27330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27331 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27332 Py_INCREF(obj);
27333 return Py_BuildValue((char *)"");
27334 }
27335 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27336 PyObject *resultobj;
27337 wxDataObjectComposite *result;
27338 char *kwnames[] = {
27339 NULL
27340 };
27341
27342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27343 {
27344 PyThreadState* __tstate = wxPyBeginAllowThreads();
27345 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27346
27347 wxPyEndAllowThreads(__tstate);
27348 if (PyErr_Occurred()) SWIG_fail;
27349 }
27350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27351 return resultobj;
27352 fail:
27353 return NULL;
27354 }
27355
27356
27357 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27358 PyObject *resultobj;
27359 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27360 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27361 bool arg3 = (bool) false ;
27362 PyObject * obj0 = 0 ;
27363 PyObject * obj1 = 0 ;
27364 PyObject * obj2 = 0 ;
27365 char *kwnames[] = {
27366 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27367 };
27368
27369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27371 if (SWIG_arg_fail(1)) SWIG_fail;
27372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27373 if (SWIG_arg_fail(2)) SWIG_fail;
27374 if (obj2) {
27375 {
27376 arg3 = (bool)(SWIG_As_bool(obj2));
27377 if (SWIG_arg_fail(3)) SWIG_fail;
27378 }
27379 }
27380 {
27381 PyThreadState* __tstate = wxPyBeginAllowThreads();
27382 (arg1)->Add(arg2,arg3);
27383
27384 wxPyEndAllowThreads(__tstate);
27385 if (PyErr_Occurred()) SWIG_fail;
27386 }
27387 Py_INCREF(Py_None); resultobj = Py_None;
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27395 PyObject *obj;
27396 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27397 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27398 Py_INCREF(obj);
27399 return Py_BuildValue((char *)"");
27400 }
27401 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27402 PyObject *resultobj;
27403 wxString const &arg1_defvalue = wxPyEmptyString ;
27404 wxString *arg1 = (wxString *) &arg1_defvalue ;
27405 wxTextDataObject *result;
27406 bool temp1 = false ;
27407 PyObject * obj0 = 0 ;
27408 char *kwnames[] = {
27409 (char *) "text", NULL
27410 };
27411
27412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27413 if (obj0) {
27414 {
27415 arg1 = wxString_in_helper(obj0);
27416 if (arg1 == NULL) SWIG_fail;
27417 temp1 = true;
27418 }
27419 }
27420 {
27421 PyThreadState* __tstate = wxPyBeginAllowThreads();
27422 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27423
27424 wxPyEndAllowThreads(__tstate);
27425 if (PyErr_Occurred()) SWIG_fail;
27426 }
27427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27428 {
27429 if (temp1)
27430 delete arg1;
27431 }
27432 return resultobj;
27433 fail:
27434 {
27435 if (temp1)
27436 delete arg1;
27437 }
27438 return NULL;
27439 }
27440
27441
27442 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27443 PyObject *resultobj;
27444 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27445 size_t result;
27446 PyObject * obj0 = 0 ;
27447 char *kwnames[] = {
27448 (char *) "self", NULL
27449 };
27450
27451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27453 if (SWIG_arg_fail(1)) SWIG_fail;
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 result = (size_t)(arg1)->GetTextLength();
27457
27458 wxPyEndAllowThreads(__tstate);
27459 if (PyErr_Occurred()) SWIG_fail;
27460 }
27461 {
27462 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27463 }
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27471 PyObject *resultobj;
27472 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27473 wxString result;
27474 PyObject * obj0 = 0 ;
27475 char *kwnames[] = {
27476 (char *) "self", NULL
27477 };
27478
27479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27481 if (SWIG_arg_fail(1)) SWIG_fail;
27482 {
27483 PyThreadState* __tstate = wxPyBeginAllowThreads();
27484 result = (arg1)->GetText();
27485
27486 wxPyEndAllowThreads(__tstate);
27487 if (PyErr_Occurred()) SWIG_fail;
27488 }
27489 {
27490 #if wxUSE_UNICODE
27491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27492 #else
27493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27494 #endif
27495 }
27496 return resultobj;
27497 fail:
27498 return NULL;
27499 }
27500
27501
27502 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27503 PyObject *resultobj;
27504 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27505 wxString *arg2 = 0 ;
27506 bool temp2 = false ;
27507 PyObject * obj0 = 0 ;
27508 PyObject * obj1 = 0 ;
27509 char *kwnames[] = {
27510 (char *) "self",(char *) "text", NULL
27511 };
27512
27513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27515 if (SWIG_arg_fail(1)) SWIG_fail;
27516 {
27517 arg2 = wxString_in_helper(obj1);
27518 if (arg2 == NULL) SWIG_fail;
27519 temp2 = true;
27520 }
27521 {
27522 PyThreadState* __tstate = wxPyBeginAllowThreads();
27523 (arg1)->SetText((wxString const &)*arg2);
27524
27525 wxPyEndAllowThreads(__tstate);
27526 if (PyErr_Occurred()) SWIG_fail;
27527 }
27528 Py_INCREF(Py_None); resultobj = Py_None;
27529 {
27530 if (temp2)
27531 delete arg2;
27532 }
27533 return resultobj;
27534 fail:
27535 {
27536 if (temp2)
27537 delete arg2;
27538 }
27539 return NULL;
27540 }
27541
27542
27543 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27544 PyObject *obj;
27545 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27546 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27547 Py_INCREF(obj);
27548 return Py_BuildValue((char *)"");
27549 }
27550 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27551 PyObject *resultobj;
27552 wxString const &arg1_defvalue = wxPyEmptyString ;
27553 wxString *arg1 = (wxString *) &arg1_defvalue ;
27554 wxPyTextDataObject *result;
27555 bool temp1 = false ;
27556 PyObject * obj0 = 0 ;
27557 char *kwnames[] = {
27558 (char *) "text", NULL
27559 };
27560
27561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27562 if (obj0) {
27563 {
27564 arg1 = wxString_in_helper(obj0);
27565 if (arg1 == NULL) SWIG_fail;
27566 temp1 = true;
27567 }
27568 }
27569 {
27570 PyThreadState* __tstate = wxPyBeginAllowThreads();
27571 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27572
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27577 {
27578 if (temp1)
27579 delete arg1;
27580 }
27581 return resultobj;
27582 fail:
27583 {
27584 if (temp1)
27585 delete arg1;
27586 }
27587 return NULL;
27588 }
27589
27590
27591 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27592 PyObject *resultobj;
27593 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27594 PyObject *arg2 = (PyObject *) 0 ;
27595 PyObject *arg3 = (PyObject *) 0 ;
27596 PyObject * obj0 = 0 ;
27597 PyObject * obj1 = 0 ;
27598 PyObject * obj2 = 0 ;
27599 char *kwnames[] = {
27600 (char *) "self",(char *) "self",(char *) "_class", NULL
27601 };
27602
27603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27605 if (SWIG_arg_fail(1)) SWIG_fail;
27606 arg2 = obj1;
27607 arg3 = obj2;
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 (arg1)->_setCallbackInfo(arg2,arg3);
27611
27612 wxPyEndAllowThreads(__tstate);
27613 if (PyErr_Occurred()) SWIG_fail;
27614 }
27615 Py_INCREF(Py_None); resultobj = Py_None;
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27623 PyObject *obj;
27624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27625 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27626 Py_INCREF(obj);
27627 return Py_BuildValue((char *)"");
27628 }
27629 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27630 PyObject *resultobj;
27631 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27632 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27633 wxBitmapDataObject *result;
27634 PyObject * obj0 = 0 ;
27635 char *kwnames[] = {
27636 (char *) "bitmap", NULL
27637 };
27638
27639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27640 if (obj0) {
27641 {
27642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27643 if (SWIG_arg_fail(1)) SWIG_fail;
27644 if (arg1 == NULL) {
27645 SWIG_null_ref("wxBitmap");
27646 }
27647 if (SWIG_arg_fail(1)) SWIG_fail;
27648 }
27649 }
27650 {
27651 PyThreadState* __tstate = wxPyBeginAllowThreads();
27652 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27653
27654 wxPyEndAllowThreads(__tstate);
27655 if (PyErr_Occurred()) SWIG_fail;
27656 }
27657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27658 return resultobj;
27659 fail:
27660 return NULL;
27661 }
27662
27663
27664 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27665 PyObject *resultobj;
27666 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27667 wxBitmap result;
27668 PyObject * obj0 = 0 ;
27669 char *kwnames[] = {
27670 (char *) "self", NULL
27671 };
27672
27673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27675 if (SWIG_arg_fail(1)) SWIG_fail;
27676 {
27677 PyThreadState* __tstate = wxPyBeginAllowThreads();
27678 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27679
27680 wxPyEndAllowThreads(__tstate);
27681 if (PyErr_Occurred()) SWIG_fail;
27682 }
27683 {
27684 wxBitmap * resultptr;
27685 resultptr = new wxBitmap((wxBitmap &)(result));
27686 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27687 }
27688 return resultobj;
27689 fail:
27690 return NULL;
27691 }
27692
27693
27694 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27695 PyObject *resultobj;
27696 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27697 wxBitmap *arg2 = 0 ;
27698 PyObject * obj0 = 0 ;
27699 PyObject * obj1 = 0 ;
27700 char *kwnames[] = {
27701 (char *) "self",(char *) "bitmap", NULL
27702 };
27703
27704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27706 if (SWIG_arg_fail(1)) SWIG_fail;
27707 {
27708 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27709 if (SWIG_arg_fail(2)) SWIG_fail;
27710 if (arg2 == NULL) {
27711 SWIG_null_ref("wxBitmap");
27712 }
27713 if (SWIG_arg_fail(2)) SWIG_fail;
27714 }
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27718
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 Py_INCREF(Py_None); resultobj = Py_None;
27723 return resultobj;
27724 fail:
27725 return NULL;
27726 }
27727
27728
27729 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27730 PyObject *obj;
27731 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27732 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27733 Py_INCREF(obj);
27734 return Py_BuildValue((char *)"");
27735 }
27736 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27737 PyObject *resultobj;
27738 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27739 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27740 wxPyBitmapDataObject *result;
27741 PyObject * obj0 = 0 ;
27742 char *kwnames[] = {
27743 (char *) "bitmap", NULL
27744 };
27745
27746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27747 if (obj0) {
27748 {
27749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27750 if (SWIG_arg_fail(1)) SWIG_fail;
27751 if (arg1 == NULL) {
27752 SWIG_null_ref("wxBitmap");
27753 }
27754 if (SWIG_arg_fail(1)) SWIG_fail;
27755 }
27756 }
27757 {
27758 PyThreadState* __tstate = wxPyBeginAllowThreads();
27759 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27760
27761 wxPyEndAllowThreads(__tstate);
27762 if (PyErr_Occurred()) SWIG_fail;
27763 }
27764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27772 PyObject *resultobj;
27773 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27774 PyObject *arg2 = (PyObject *) 0 ;
27775 PyObject *arg3 = (PyObject *) 0 ;
27776 PyObject * obj0 = 0 ;
27777 PyObject * obj1 = 0 ;
27778 PyObject * obj2 = 0 ;
27779 char *kwnames[] = {
27780 (char *) "self",(char *) "self",(char *) "_class", NULL
27781 };
27782
27783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27785 if (SWIG_arg_fail(1)) SWIG_fail;
27786 arg2 = obj1;
27787 arg3 = obj2;
27788 {
27789 PyThreadState* __tstate = wxPyBeginAllowThreads();
27790 (arg1)->_setCallbackInfo(arg2,arg3);
27791
27792 wxPyEndAllowThreads(__tstate);
27793 if (PyErr_Occurred()) SWIG_fail;
27794 }
27795 Py_INCREF(Py_None); resultobj = Py_None;
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27803 PyObject *obj;
27804 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27805 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27806 Py_INCREF(obj);
27807 return Py_BuildValue((char *)"");
27808 }
27809 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27810 PyObject *resultobj;
27811 wxFileDataObject *result;
27812 char *kwnames[] = {
27813 NULL
27814 };
27815
27816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27817 {
27818 PyThreadState* __tstate = wxPyBeginAllowThreads();
27819 result = (wxFileDataObject *)new wxFileDataObject();
27820
27821 wxPyEndAllowThreads(__tstate);
27822 if (PyErr_Occurred()) SWIG_fail;
27823 }
27824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27825 return resultobj;
27826 fail:
27827 return NULL;
27828 }
27829
27830
27831 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27832 PyObject *resultobj;
27833 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27834 wxArrayString *result;
27835 PyObject * obj0 = 0 ;
27836 char *kwnames[] = {
27837 (char *) "self", NULL
27838 };
27839
27840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27842 if (SWIG_arg_fail(1)) SWIG_fail;
27843 {
27844 PyThreadState* __tstate = wxPyBeginAllowThreads();
27845 {
27846 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27847 result = (wxArrayString *) &_result_ref;
27848 }
27849
27850 wxPyEndAllowThreads(__tstate);
27851 if (PyErr_Occurred()) SWIG_fail;
27852 }
27853 {
27854 resultobj = wxArrayString2PyList_helper(*result);
27855 }
27856 return resultobj;
27857 fail:
27858 return NULL;
27859 }
27860
27861
27862 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27863 PyObject *resultobj;
27864 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27865 wxString *arg2 = 0 ;
27866 bool temp2 = false ;
27867 PyObject * obj0 = 0 ;
27868 PyObject * obj1 = 0 ;
27869 char *kwnames[] = {
27870 (char *) "self",(char *) "filename", NULL
27871 };
27872
27873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27875 if (SWIG_arg_fail(1)) SWIG_fail;
27876 {
27877 arg2 = wxString_in_helper(obj1);
27878 if (arg2 == NULL) SWIG_fail;
27879 temp2 = true;
27880 }
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 (arg1)->AddFile((wxString const &)*arg2);
27884
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 Py_INCREF(Py_None); resultobj = Py_None;
27889 {
27890 if (temp2)
27891 delete arg2;
27892 }
27893 return resultobj;
27894 fail:
27895 {
27896 if (temp2)
27897 delete arg2;
27898 }
27899 return NULL;
27900 }
27901
27902
27903 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27904 PyObject *obj;
27905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27906 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27907 Py_INCREF(obj);
27908 return Py_BuildValue((char *)"");
27909 }
27910 static PyObject *_wrap_new_CustomDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27911 PyObject *resultobj;
27912 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27913 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27914 wxCustomDataObject *result;
27915 PyObject * obj0 = 0 ;
27916 char *kwnames[] = {
27917 (char *) "format", NULL
27918 };
27919
27920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_CustomDataObject",kwnames,&obj0)) goto fail;
27921 if (obj0) {
27922 {
27923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27924 if (SWIG_arg_fail(1)) SWIG_fail;
27925 if (arg1 == NULL) {
27926 SWIG_null_ref("wxDataFormat");
27927 }
27928 if (SWIG_arg_fail(1)) SWIG_fail;
27929 }
27930 }
27931 {
27932 PyThreadState* __tstate = wxPyBeginAllowThreads();
27933 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27934
27935 wxPyEndAllowThreads(__tstate);
27936 if (PyErr_Occurred()) SWIG_fail;
27937 }
27938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27939 return resultobj;
27940 fail:
27941 return NULL;
27942 }
27943
27944
27945 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27946 PyObject *resultobj;
27947 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27948 PyObject *arg2 = (PyObject *) 0 ;
27949 bool result;
27950 PyObject * obj0 = 0 ;
27951 PyObject * obj1 = 0 ;
27952 char *kwnames[] = {
27953 (char *) "self",(char *) "data", NULL
27954 };
27955
27956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
27957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27958 if (SWIG_arg_fail(1)) SWIG_fail;
27959 arg2 = obj1;
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
27963
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 {
27968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27969 }
27970 return resultobj;
27971 fail:
27972 return NULL;
27973 }
27974
27975
27976 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27977 PyObject *resultobj;
27978 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27979 size_t result;
27980 PyObject * obj0 = 0 ;
27981 char *kwnames[] = {
27982 (char *) "self", NULL
27983 };
27984
27985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
27986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27987 if (SWIG_arg_fail(1)) SWIG_fail;
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 result = (size_t)(arg1)->GetSize();
27991
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 {
27996 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27997 }
27998 return resultobj;
27999 fail:
28000 return NULL;
28001 }
28002
28003
28004 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28005 PyObject *resultobj;
28006 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28007 PyObject *result;
28008 PyObject * obj0 = 0 ;
28009 char *kwnames[] = {
28010 (char *) "self", NULL
28011 };
28012
28013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28015 if (SWIG_arg_fail(1)) SWIG_fail;
28016 {
28017 PyThreadState* __tstate = wxPyBeginAllowThreads();
28018 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28019
28020 wxPyEndAllowThreads(__tstate);
28021 if (PyErr_Occurred()) SWIG_fail;
28022 }
28023 resultobj = result;
28024 return resultobj;
28025 fail:
28026 return NULL;
28027 }
28028
28029
28030 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28031 PyObject *obj;
28032 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28033 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28034 Py_INCREF(obj);
28035 return Py_BuildValue((char *)"");
28036 }
28037 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28038 PyObject *resultobj;
28039 wxURLDataObject *result;
28040 char *kwnames[] = {
28041 NULL
28042 };
28043
28044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28045 {
28046 PyThreadState* __tstate = wxPyBeginAllowThreads();
28047 result = (wxURLDataObject *)new wxURLDataObject();
28048
28049 wxPyEndAllowThreads(__tstate);
28050 if (PyErr_Occurred()) SWIG_fail;
28051 }
28052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28053 return resultobj;
28054 fail:
28055 return NULL;
28056 }
28057
28058
28059 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28060 PyObject *resultobj;
28061 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28062 wxString result;
28063 PyObject * obj0 = 0 ;
28064 char *kwnames[] = {
28065 (char *) "self", NULL
28066 };
28067
28068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28070 if (SWIG_arg_fail(1)) SWIG_fail;
28071 {
28072 PyThreadState* __tstate = wxPyBeginAllowThreads();
28073 result = (arg1)->GetURL();
28074
28075 wxPyEndAllowThreads(__tstate);
28076 if (PyErr_Occurred()) SWIG_fail;
28077 }
28078 {
28079 #if wxUSE_UNICODE
28080 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28081 #else
28082 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28083 #endif
28084 }
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28092 PyObject *resultobj;
28093 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28094 wxString *arg2 = 0 ;
28095 bool temp2 = false ;
28096 PyObject * obj0 = 0 ;
28097 PyObject * obj1 = 0 ;
28098 char *kwnames[] = {
28099 (char *) "self",(char *) "url", NULL
28100 };
28101
28102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28104 if (SWIG_arg_fail(1)) SWIG_fail;
28105 {
28106 arg2 = wxString_in_helper(obj1);
28107 if (arg2 == NULL) SWIG_fail;
28108 temp2 = true;
28109 }
28110 {
28111 PyThreadState* __tstate = wxPyBeginAllowThreads();
28112 (arg1)->SetURL((wxString const &)*arg2);
28113
28114 wxPyEndAllowThreads(__tstate);
28115 if (PyErr_Occurred()) SWIG_fail;
28116 }
28117 Py_INCREF(Py_None); resultobj = Py_None;
28118 {
28119 if (temp2)
28120 delete arg2;
28121 }
28122 return resultobj;
28123 fail:
28124 {
28125 if (temp2)
28126 delete arg2;
28127 }
28128 return NULL;
28129 }
28130
28131
28132 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28133 PyObject *obj;
28134 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28135 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28136 Py_INCREF(obj);
28137 return Py_BuildValue((char *)"");
28138 }
28139 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28140 PyObject *resultobj;
28141 wxMetafileDataObject *result;
28142 char *kwnames[] = {
28143 NULL
28144 };
28145
28146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28147 {
28148 PyThreadState* __tstate = wxPyBeginAllowThreads();
28149 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28150
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28162 PyObject *obj;
28163 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28164 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28165 Py_INCREF(obj);
28166 return Py_BuildValue((char *)"");
28167 }
28168 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28169 PyObject *resultobj;
28170 wxDragResult arg1 ;
28171 bool result;
28172 PyObject * obj0 = 0 ;
28173 char *kwnames[] = {
28174 (char *) "res", NULL
28175 };
28176
28177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28178 {
28179 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28180 if (SWIG_arg_fail(1)) SWIG_fail;
28181 }
28182 {
28183 PyThreadState* __tstate = wxPyBeginAllowThreads();
28184 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28185
28186 wxPyEndAllowThreads(__tstate);
28187 if (PyErr_Occurred()) SWIG_fail;
28188 }
28189 {
28190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28191 }
28192 return resultobj;
28193 fail:
28194 return NULL;
28195 }
28196
28197
28198 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28199 PyObject *resultobj;
28200 wxWindow *arg1 = (wxWindow *) 0 ;
28201 wxIcon const &arg2_defvalue = wxNullIcon ;
28202 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28203 wxIcon const &arg3_defvalue = wxNullIcon ;
28204 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28205 wxIcon const &arg4_defvalue = wxNullIcon ;
28206 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28207 wxPyDropSource *result;
28208 PyObject * obj0 = 0 ;
28209 PyObject * obj1 = 0 ;
28210 PyObject * obj2 = 0 ;
28211 PyObject * obj3 = 0 ;
28212 char *kwnames[] = {
28213 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28214 };
28215
28216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28218 if (SWIG_arg_fail(1)) SWIG_fail;
28219 if (obj1) {
28220 {
28221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28222 if (SWIG_arg_fail(2)) SWIG_fail;
28223 if (arg2 == NULL) {
28224 SWIG_null_ref("wxIcon");
28225 }
28226 if (SWIG_arg_fail(2)) SWIG_fail;
28227 }
28228 }
28229 if (obj2) {
28230 {
28231 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28232 if (SWIG_arg_fail(3)) SWIG_fail;
28233 if (arg3 == NULL) {
28234 SWIG_null_ref("wxIcon");
28235 }
28236 if (SWIG_arg_fail(3)) SWIG_fail;
28237 }
28238 }
28239 if (obj3) {
28240 {
28241 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28242 if (SWIG_arg_fail(4)) SWIG_fail;
28243 if (arg4 == NULL) {
28244 SWIG_null_ref("wxIcon");
28245 }
28246 if (SWIG_arg_fail(4)) SWIG_fail;
28247 }
28248 }
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28252
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28257 return resultobj;
28258 fail:
28259 return NULL;
28260 }
28261
28262
28263 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28264 PyObject *resultobj;
28265 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28266 PyObject *arg2 = (PyObject *) 0 ;
28267 PyObject *arg3 = (PyObject *) 0 ;
28268 int arg4 ;
28269 PyObject * obj0 = 0 ;
28270 PyObject * obj1 = 0 ;
28271 PyObject * obj2 = 0 ;
28272 PyObject * obj3 = 0 ;
28273 char *kwnames[] = {
28274 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28275 };
28276
28277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28279 if (SWIG_arg_fail(1)) SWIG_fail;
28280 arg2 = obj1;
28281 arg3 = obj2;
28282 {
28283 arg4 = (int)(SWIG_As_int(obj3));
28284 if (SWIG_arg_fail(4)) SWIG_fail;
28285 }
28286 {
28287 PyThreadState* __tstate = wxPyBeginAllowThreads();
28288 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28289
28290 wxPyEndAllowThreads(__tstate);
28291 if (PyErr_Occurred()) SWIG_fail;
28292 }
28293 Py_INCREF(Py_None); resultobj = Py_None;
28294 return resultobj;
28295 fail:
28296 return NULL;
28297 }
28298
28299
28300 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28301 PyObject *resultobj;
28302 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28303 PyObject * obj0 = 0 ;
28304 char *kwnames[] = {
28305 (char *) "self", NULL
28306 };
28307
28308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28310 if (SWIG_arg_fail(1)) SWIG_fail;
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 delete arg1;
28314
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 Py_INCREF(Py_None); resultobj = Py_None;
28319 return resultobj;
28320 fail:
28321 return NULL;
28322 }
28323
28324
28325 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28326 PyObject *resultobj;
28327 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28328 wxDataObject *arg2 = 0 ;
28329 PyObject * obj0 = 0 ;
28330 PyObject * obj1 = 0 ;
28331 char *kwnames[] = {
28332 (char *) "self",(char *) "data", NULL
28333 };
28334
28335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28337 if (SWIG_arg_fail(1)) SWIG_fail;
28338 {
28339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28340 if (SWIG_arg_fail(2)) SWIG_fail;
28341 if (arg2 == NULL) {
28342 SWIG_null_ref("wxDataObject");
28343 }
28344 if (SWIG_arg_fail(2)) SWIG_fail;
28345 }
28346 {
28347 PyThreadState* __tstate = wxPyBeginAllowThreads();
28348 (arg1)->SetData(*arg2);
28349
28350 wxPyEndAllowThreads(__tstate);
28351 if (PyErr_Occurred()) SWIG_fail;
28352 }
28353 Py_INCREF(Py_None); resultobj = Py_None;
28354 return resultobj;
28355 fail:
28356 return NULL;
28357 }
28358
28359
28360 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28361 PyObject *resultobj;
28362 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28363 wxDataObject *result;
28364 PyObject * obj0 = 0 ;
28365 char *kwnames[] = {
28366 (char *) "self", NULL
28367 };
28368
28369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28371 if (SWIG_arg_fail(1)) SWIG_fail;
28372 {
28373 PyThreadState* __tstate = wxPyBeginAllowThreads();
28374 result = (wxDataObject *)(arg1)->GetDataObject();
28375
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28380 return resultobj;
28381 fail:
28382 return NULL;
28383 }
28384
28385
28386 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28387 PyObject *resultobj;
28388 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28389 wxDragResult arg2 ;
28390 wxCursor *arg3 = 0 ;
28391 PyObject * obj0 = 0 ;
28392 PyObject * obj1 = 0 ;
28393 PyObject * obj2 = 0 ;
28394 char *kwnames[] = {
28395 (char *) "self",(char *) "res",(char *) "cursor", NULL
28396 };
28397
28398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28400 if (SWIG_arg_fail(1)) SWIG_fail;
28401 {
28402 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28403 if (SWIG_arg_fail(2)) SWIG_fail;
28404 }
28405 {
28406 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28407 if (SWIG_arg_fail(3)) SWIG_fail;
28408 if (arg3 == NULL) {
28409 SWIG_null_ref("wxCursor");
28410 }
28411 if (SWIG_arg_fail(3)) SWIG_fail;
28412 }
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28416
28417 wxPyEndAllowThreads(__tstate);
28418 if (PyErr_Occurred()) SWIG_fail;
28419 }
28420 Py_INCREF(Py_None); resultobj = Py_None;
28421 return resultobj;
28422 fail:
28423 return NULL;
28424 }
28425
28426
28427 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28428 PyObject *resultobj;
28429 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28430 int arg2 = (int) wxDrag_CopyOnly ;
28431 wxDragResult result;
28432 PyObject * obj0 = 0 ;
28433 PyObject * obj1 = 0 ;
28434 char *kwnames[] = {
28435 (char *) "self",(char *) "flags", NULL
28436 };
28437
28438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28440 if (SWIG_arg_fail(1)) SWIG_fail;
28441 if (obj1) {
28442 {
28443 arg2 = (int)(SWIG_As_int(obj1));
28444 if (SWIG_arg_fail(2)) SWIG_fail;
28445 }
28446 }
28447 {
28448 PyThreadState* __tstate = wxPyBeginAllowThreads();
28449 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28450
28451 wxPyEndAllowThreads(__tstate);
28452 if (PyErr_Occurred()) SWIG_fail;
28453 }
28454 resultobj = SWIG_From_int((result));
28455 return resultobj;
28456 fail:
28457 return NULL;
28458 }
28459
28460
28461 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28462 PyObject *resultobj;
28463 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28464 wxDragResult arg2 ;
28465 bool result;
28466 PyObject * obj0 = 0 ;
28467 PyObject * obj1 = 0 ;
28468 char *kwnames[] = {
28469 (char *) "self",(char *) "effect", NULL
28470 };
28471
28472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28474 if (SWIG_arg_fail(1)) SWIG_fail;
28475 {
28476 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28477 if (SWIG_arg_fail(2)) SWIG_fail;
28478 }
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28482
28483 wxPyEndAllowThreads(__tstate);
28484 if (PyErr_Occurred()) SWIG_fail;
28485 }
28486 {
28487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28488 }
28489 return resultobj;
28490 fail:
28491 return NULL;
28492 }
28493
28494
28495 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28496 PyObject *obj;
28497 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28498 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28499 Py_INCREF(obj);
28500 return Py_BuildValue((char *)"");
28501 }
28502 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28503 PyObject *resultobj;
28504 wxDataObject *arg1 = (wxDataObject *) NULL ;
28505 wxPyDropTarget *result;
28506 PyObject * obj0 = 0 ;
28507 char *kwnames[] = {
28508 (char *) "dataObject", NULL
28509 };
28510
28511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28512 if (obj0) {
28513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28514 if (SWIG_arg_fail(1)) SWIG_fail;
28515 }
28516 {
28517 PyThreadState* __tstate = wxPyBeginAllowThreads();
28518 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28519
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28531 PyObject *resultobj;
28532 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28533 PyObject *arg2 = (PyObject *) 0 ;
28534 PyObject *arg3 = (PyObject *) 0 ;
28535 PyObject * obj0 = 0 ;
28536 PyObject * obj1 = 0 ;
28537 PyObject * obj2 = 0 ;
28538 char *kwnames[] = {
28539 (char *) "self",(char *) "self",(char *) "_class", NULL
28540 };
28541
28542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28544 if (SWIG_arg_fail(1)) SWIG_fail;
28545 arg2 = obj1;
28546 arg3 = obj2;
28547 {
28548 PyThreadState* __tstate = wxPyBeginAllowThreads();
28549 (arg1)->_setCallbackInfo(arg2,arg3);
28550
28551 wxPyEndAllowThreads(__tstate);
28552 if (PyErr_Occurred()) SWIG_fail;
28553 }
28554 Py_INCREF(Py_None); resultobj = Py_None;
28555 return resultobj;
28556 fail:
28557 return NULL;
28558 }
28559
28560
28561 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28562 PyObject *resultobj;
28563 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28564 PyObject * obj0 = 0 ;
28565 char *kwnames[] = {
28566 (char *) "self", NULL
28567 };
28568
28569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28571 if (SWIG_arg_fail(1)) SWIG_fail;
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 delete arg1;
28575
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 Py_INCREF(Py_None); resultobj = Py_None;
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj;
28588 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28589 wxDataObject *result;
28590 PyObject * obj0 = 0 ;
28591 char *kwnames[] = {
28592 (char *) "self", NULL
28593 };
28594
28595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28597 if (SWIG_arg_fail(1)) SWIG_fail;
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 result = (wxDataObject *)(arg1)->GetDataObject();
28601
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28606 return resultobj;
28607 fail:
28608 return NULL;
28609 }
28610
28611
28612 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28613 PyObject *resultobj;
28614 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28615 wxDataObject *arg2 = (wxDataObject *) 0 ;
28616 PyObject * obj0 = 0 ;
28617 PyObject * obj1 = 0 ;
28618 char *kwnames[] = {
28619 (char *) "self",(char *) "dataObject", NULL
28620 };
28621
28622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28624 if (SWIG_arg_fail(1)) SWIG_fail;
28625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28626 if (SWIG_arg_fail(2)) SWIG_fail;
28627 {
28628 PyThreadState* __tstate = wxPyBeginAllowThreads();
28629 (arg1)->SetDataObject(arg2);
28630
28631 wxPyEndAllowThreads(__tstate);
28632 if (PyErr_Occurred()) SWIG_fail;
28633 }
28634 Py_INCREF(Py_None); resultobj = Py_None;
28635 return resultobj;
28636 fail:
28637 return NULL;
28638 }
28639
28640
28641 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28642 PyObject *resultobj;
28643 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28644 int arg2 ;
28645 int arg3 ;
28646 wxDragResult arg4 ;
28647 wxDragResult result;
28648 PyObject * obj0 = 0 ;
28649 PyObject * obj1 = 0 ;
28650 PyObject * obj2 = 0 ;
28651 PyObject * obj3 = 0 ;
28652 char *kwnames[] = {
28653 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28654 };
28655
28656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28658 if (SWIG_arg_fail(1)) SWIG_fail;
28659 {
28660 arg2 = (int)(SWIG_As_int(obj1));
28661 if (SWIG_arg_fail(2)) SWIG_fail;
28662 }
28663 {
28664 arg3 = (int)(SWIG_As_int(obj2));
28665 if (SWIG_arg_fail(3)) SWIG_fail;
28666 }
28667 {
28668 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28669 if (SWIG_arg_fail(4)) SWIG_fail;
28670 }
28671 {
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28674
28675 wxPyEndAllowThreads(__tstate);
28676 if (PyErr_Occurred()) SWIG_fail;
28677 }
28678 resultobj = SWIG_From_int((result));
28679 return resultobj;
28680 fail:
28681 return NULL;
28682 }
28683
28684
28685 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28686 PyObject *resultobj;
28687 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28688 int arg2 ;
28689 int arg3 ;
28690 wxDragResult arg4 ;
28691 wxDragResult result;
28692 PyObject * obj0 = 0 ;
28693 PyObject * obj1 = 0 ;
28694 PyObject * obj2 = 0 ;
28695 PyObject * obj3 = 0 ;
28696 char *kwnames[] = {
28697 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28698 };
28699
28700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28702 if (SWIG_arg_fail(1)) SWIG_fail;
28703 {
28704 arg2 = (int)(SWIG_As_int(obj1));
28705 if (SWIG_arg_fail(2)) SWIG_fail;
28706 }
28707 {
28708 arg3 = (int)(SWIG_As_int(obj2));
28709 if (SWIG_arg_fail(3)) SWIG_fail;
28710 }
28711 {
28712 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28713 if (SWIG_arg_fail(4)) SWIG_fail;
28714 }
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28718
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 resultobj = SWIG_From_int((result));
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28730 PyObject *resultobj;
28731 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28732 PyObject * obj0 = 0 ;
28733 char *kwnames[] = {
28734 (char *) "self", NULL
28735 };
28736
28737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28739 if (SWIG_arg_fail(1)) SWIG_fail;
28740 {
28741 PyThreadState* __tstate = wxPyBeginAllowThreads();
28742 (arg1)->base_OnLeave();
28743
28744 wxPyEndAllowThreads(__tstate);
28745 if (PyErr_Occurred()) SWIG_fail;
28746 }
28747 Py_INCREF(Py_None); resultobj = Py_None;
28748 return resultobj;
28749 fail:
28750 return NULL;
28751 }
28752
28753
28754 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28755 PyObject *resultobj;
28756 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28757 int arg2 ;
28758 int arg3 ;
28759 bool result;
28760 PyObject * obj0 = 0 ;
28761 PyObject * obj1 = 0 ;
28762 PyObject * obj2 = 0 ;
28763 char *kwnames[] = {
28764 (char *) "self",(char *) "x",(char *) "y", NULL
28765 };
28766
28767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28769 if (SWIG_arg_fail(1)) SWIG_fail;
28770 {
28771 arg2 = (int)(SWIG_As_int(obj1));
28772 if (SWIG_arg_fail(2)) SWIG_fail;
28773 }
28774 {
28775 arg3 = (int)(SWIG_As_int(obj2));
28776 if (SWIG_arg_fail(3)) SWIG_fail;
28777 }
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28781
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 {
28786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28787 }
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28795 PyObject *resultobj;
28796 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28797 bool result;
28798 PyObject * obj0 = 0 ;
28799 char *kwnames[] = {
28800 (char *) "self", NULL
28801 };
28802
28803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28805 if (SWIG_arg_fail(1)) SWIG_fail;
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 result = (bool)(arg1)->GetData();
28809
28810 wxPyEndAllowThreads(__tstate);
28811 if (PyErr_Occurred()) SWIG_fail;
28812 }
28813 {
28814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28815 }
28816 return resultobj;
28817 fail:
28818 return NULL;
28819 }
28820
28821
28822 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28823 PyObject *obj;
28824 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28825 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28826 Py_INCREF(obj);
28827 return Py_BuildValue((char *)"");
28828 }
28829 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28830 PyObject *resultobj;
28831 wxPyTextDropTarget *result;
28832 char *kwnames[] = {
28833 NULL
28834 };
28835
28836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28840
28841 wxPyEndAllowThreads(__tstate);
28842 if (PyErr_Occurred()) SWIG_fail;
28843 }
28844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28845 return resultobj;
28846 fail:
28847 return NULL;
28848 }
28849
28850
28851 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28852 PyObject *resultobj;
28853 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28854 PyObject *arg2 = (PyObject *) 0 ;
28855 PyObject *arg3 = (PyObject *) 0 ;
28856 PyObject * obj0 = 0 ;
28857 PyObject * obj1 = 0 ;
28858 PyObject * obj2 = 0 ;
28859 char *kwnames[] = {
28860 (char *) "self",(char *) "self",(char *) "_class", NULL
28861 };
28862
28863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28865 if (SWIG_arg_fail(1)) SWIG_fail;
28866 arg2 = obj1;
28867 arg3 = obj2;
28868 {
28869 PyThreadState* __tstate = wxPyBeginAllowThreads();
28870 (arg1)->_setCallbackInfo(arg2,arg3);
28871
28872 wxPyEndAllowThreads(__tstate);
28873 if (PyErr_Occurred()) SWIG_fail;
28874 }
28875 Py_INCREF(Py_None); resultobj = Py_None;
28876 return resultobj;
28877 fail:
28878 return NULL;
28879 }
28880
28881
28882 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj;
28884 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28885 int arg2 ;
28886 int arg3 ;
28887 wxDragResult arg4 ;
28888 wxDragResult result;
28889 PyObject * obj0 = 0 ;
28890 PyObject * obj1 = 0 ;
28891 PyObject * obj2 = 0 ;
28892 PyObject * obj3 = 0 ;
28893 char *kwnames[] = {
28894 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28895 };
28896
28897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28899 if (SWIG_arg_fail(1)) SWIG_fail;
28900 {
28901 arg2 = (int)(SWIG_As_int(obj1));
28902 if (SWIG_arg_fail(2)) SWIG_fail;
28903 }
28904 {
28905 arg3 = (int)(SWIG_As_int(obj2));
28906 if (SWIG_arg_fail(3)) SWIG_fail;
28907 }
28908 {
28909 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28910 if (SWIG_arg_fail(4)) SWIG_fail;
28911 }
28912 {
28913 PyThreadState* __tstate = wxPyBeginAllowThreads();
28914 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28915
28916 wxPyEndAllowThreads(__tstate);
28917 if (PyErr_Occurred()) SWIG_fail;
28918 }
28919 resultobj = SWIG_From_int((result));
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28927 PyObject *resultobj;
28928 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28929 int arg2 ;
28930 int arg3 ;
28931 wxDragResult arg4 ;
28932 wxDragResult result;
28933 PyObject * obj0 = 0 ;
28934 PyObject * obj1 = 0 ;
28935 PyObject * obj2 = 0 ;
28936 PyObject * obj3 = 0 ;
28937 char *kwnames[] = {
28938 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28939 };
28940
28941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28943 if (SWIG_arg_fail(1)) SWIG_fail;
28944 {
28945 arg2 = (int)(SWIG_As_int(obj1));
28946 if (SWIG_arg_fail(2)) SWIG_fail;
28947 }
28948 {
28949 arg3 = (int)(SWIG_As_int(obj2));
28950 if (SWIG_arg_fail(3)) SWIG_fail;
28951 }
28952 {
28953 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28954 if (SWIG_arg_fail(4)) SWIG_fail;
28955 }
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28959
28960 wxPyEndAllowThreads(__tstate);
28961 if (PyErr_Occurred()) SWIG_fail;
28962 }
28963 resultobj = SWIG_From_int((result));
28964 return resultobj;
28965 fail:
28966 return NULL;
28967 }
28968
28969
28970 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28971 PyObject *resultobj;
28972 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28973 PyObject * obj0 = 0 ;
28974 char *kwnames[] = {
28975 (char *) "self", NULL
28976 };
28977
28978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28980 if (SWIG_arg_fail(1)) SWIG_fail;
28981 {
28982 PyThreadState* __tstate = wxPyBeginAllowThreads();
28983 (arg1)->base_OnLeave();
28984
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 Py_INCREF(Py_None); resultobj = Py_None;
28989 return resultobj;
28990 fail:
28991 return NULL;
28992 }
28993
28994
28995 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28996 PyObject *resultobj;
28997 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28998 int arg2 ;
28999 int arg3 ;
29000 bool result;
29001 PyObject * obj0 = 0 ;
29002 PyObject * obj1 = 0 ;
29003 PyObject * obj2 = 0 ;
29004 char *kwnames[] = {
29005 (char *) "self",(char *) "x",(char *) "y", NULL
29006 };
29007
29008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29010 if (SWIG_arg_fail(1)) SWIG_fail;
29011 {
29012 arg2 = (int)(SWIG_As_int(obj1));
29013 if (SWIG_arg_fail(2)) SWIG_fail;
29014 }
29015 {
29016 arg3 = (int)(SWIG_As_int(obj2));
29017 if (SWIG_arg_fail(3)) SWIG_fail;
29018 }
29019 {
29020 PyThreadState* __tstate = wxPyBeginAllowThreads();
29021 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29022
29023 wxPyEndAllowThreads(__tstate);
29024 if (PyErr_Occurred()) SWIG_fail;
29025 }
29026 {
29027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29028 }
29029 return resultobj;
29030 fail:
29031 return NULL;
29032 }
29033
29034
29035 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29036 PyObject *resultobj;
29037 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29038 int arg2 ;
29039 int arg3 ;
29040 wxDragResult arg4 ;
29041 wxDragResult result;
29042 PyObject * obj0 = 0 ;
29043 PyObject * obj1 = 0 ;
29044 PyObject * obj2 = 0 ;
29045 PyObject * obj3 = 0 ;
29046 char *kwnames[] = {
29047 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29048 };
29049
29050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29052 if (SWIG_arg_fail(1)) SWIG_fail;
29053 {
29054 arg2 = (int)(SWIG_As_int(obj1));
29055 if (SWIG_arg_fail(2)) SWIG_fail;
29056 }
29057 {
29058 arg3 = (int)(SWIG_As_int(obj2));
29059 if (SWIG_arg_fail(3)) SWIG_fail;
29060 }
29061 {
29062 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29063 if (SWIG_arg_fail(4)) SWIG_fail;
29064 }
29065 {
29066 PyThreadState* __tstate = wxPyBeginAllowThreads();
29067 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29068
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 resultobj = SWIG_From_int((result));
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29080 PyObject *obj;
29081 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29082 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29083 Py_INCREF(obj);
29084 return Py_BuildValue((char *)"");
29085 }
29086 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29087 PyObject *resultobj;
29088 wxPyFileDropTarget *result;
29089 char *kwnames[] = {
29090 NULL
29091 };
29092
29093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29097
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj;
29110 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29111 PyObject *arg2 = (PyObject *) 0 ;
29112 PyObject *arg3 = (PyObject *) 0 ;
29113 PyObject * obj0 = 0 ;
29114 PyObject * obj1 = 0 ;
29115 PyObject * obj2 = 0 ;
29116 char *kwnames[] = {
29117 (char *) "self",(char *) "self",(char *) "_class", NULL
29118 };
29119
29120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29122 if (SWIG_arg_fail(1)) SWIG_fail;
29123 arg2 = obj1;
29124 arg3 = obj2;
29125 {
29126 PyThreadState* __tstate = wxPyBeginAllowThreads();
29127 (arg1)->_setCallbackInfo(arg2,arg3);
29128
29129 wxPyEndAllowThreads(__tstate);
29130 if (PyErr_Occurred()) SWIG_fail;
29131 }
29132 Py_INCREF(Py_None); resultobj = Py_None;
29133 return resultobj;
29134 fail:
29135 return NULL;
29136 }
29137
29138
29139 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29140 PyObject *resultobj;
29141 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29142 int arg2 ;
29143 int arg3 ;
29144 wxDragResult arg4 ;
29145 wxDragResult result;
29146 PyObject * obj0 = 0 ;
29147 PyObject * obj1 = 0 ;
29148 PyObject * obj2 = 0 ;
29149 PyObject * obj3 = 0 ;
29150 char *kwnames[] = {
29151 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29152 };
29153
29154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29156 if (SWIG_arg_fail(1)) SWIG_fail;
29157 {
29158 arg2 = (int)(SWIG_As_int(obj1));
29159 if (SWIG_arg_fail(2)) SWIG_fail;
29160 }
29161 {
29162 arg3 = (int)(SWIG_As_int(obj2));
29163 if (SWIG_arg_fail(3)) SWIG_fail;
29164 }
29165 {
29166 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29167 if (SWIG_arg_fail(4)) SWIG_fail;
29168 }
29169 {
29170 PyThreadState* __tstate = wxPyBeginAllowThreads();
29171 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29172
29173 wxPyEndAllowThreads(__tstate);
29174 if (PyErr_Occurred()) SWIG_fail;
29175 }
29176 resultobj = SWIG_From_int((result));
29177 return resultobj;
29178 fail:
29179 return NULL;
29180 }
29181
29182
29183 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29184 PyObject *resultobj;
29185 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29186 int arg2 ;
29187 int arg3 ;
29188 wxDragResult arg4 ;
29189 wxDragResult result;
29190 PyObject * obj0 = 0 ;
29191 PyObject * obj1 = 0 ;
29192 PyObject * obj2 = 0 ;
29193 PyObject * obj3 = 0 ;
29194 char *kwnames[] = {
29195 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29196 };
29197
29198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29200 if (SWIG_arg_fail(1)) SWIG_fail;
29201 {
29202 arg2 = (int)(SWIG_As_int(obj1));
29203 if (SWIG_arg_fail(2)) SWIG_fail;
29204 }
29205 {
29206 arg3 = (int)(SWIG_As_int(obj2));
29207 if (SWIG_arg_fail(3)) SWIG_fail;
29208 }
29209 {
29210 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29211 if (SWIG_arg_fail(4)) SWIG_fail;
29212 }
29213 {
29214 PyThreadState* __tstate = wxPyBeginAllowThreads();
29215 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29216
29217 wxPyEndAllowThreads(__tstate);
29218 if (PyErr_Occurred()) SWIG_fail;
29219 }
29220 resultobj = SWIG_From_int((result));
29221 return resultobj;
29222 fail:
29223 return NULL;
29224 }
29225
29226
29227 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29228 PyObject *resultobj;
29229 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29230 PyObject * obj0 = 0 ;
29231 char *kwnames[] = {
29232 (char *) "self", NULL
29233 };
29234
29235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29237 if (SWIG_arg_fail(1)) SWIG_fail;
29238 {
29239 PyThreadState* __tstate = wxPyBeginAllowThreads();
29240 (arg1)->base_OnLeave();
29241
29242 wxPyEndAllowThreads(__tstate);
29243 if (PyErr_Occurred()) SWIG_fail;
29244 }
29245 Py_INCREF(Py_None); resultobj = Py_None;
29246 return resultobj;
29247 fail:
29248 return NULL;
29249 }
29250
29251
29252 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29253 PyObject *resultobj;
29254 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29255 int arg2 ;
29256 int arg3 ;
29257 bool result;
29258 PyObject * obj0 = 0 ;
29259 PyObject * obj1 = 0 ;
29260 PyObject * obj2 = 0 ;
29261 char *kwnames[] = {
29262 (char *) "self",(char *) "x",(char *) "y", NULL
29263 };
29264
29265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29267 if (SWIG_arg_fail(1)) SWIG_fail;
29268 {
29269 arg2 = (int)(SWIG_As_int(obj1));
29270 if (SWIG_arg_fail(2)) SWIG_fail;
29271 }
29272 {
29273 arg3 = (int)(SWIG_As_int(obj2));
29274 if (SWIG_arg_fail(3)) SWIG_fail;
29275 }
29276 {
29277 PyThreadState* __tstate = wxPyBeginAllowThreads();
29278 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29279
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 {
29284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29285 }
29286 return resultobj;
29287 fail:
29288 return NULL;
29289 }
29290
29291
29292 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29293 PyObject *resultobj;
29294 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29295 int arg2 ;
29296 int arg3 ;
29297 wxDragResult arg4 ;
29298 wxDragResult result;
29299 PyObject * obj0 = 0 ;
29300 PyObject * obj1 = 0 ;
29301 PyObject * obj2 = 0 ;
29302 PyObject * obj3 = 0 ;
29303 char *kwnames[] = {
29304 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29305 };
29306
29307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29309 if (SWIG_arg_fail(1)) SWIG_fail;
29310 {
29311 arg2 = (int)(SWIG_As_int(obj1));
29312 if (SWIG_arg_fail(2)) SWIG_fail;
29313 }
29314 {
29315 arg3 = (int)(SWIG_As_int(obj2));
29316 if (SWIG_arg_fail(3)) SWIG_fail;
29317 }
29318 {
29319 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29320 if (SWIG_arg_fail(4)) SWIG_fail;
29321 }
29322 {
29323 PyThreadState* __tstate = wxPyBeginAllowThreads();
29324 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29325
29326 wxPyEndAllowThreads(__tstate);
29327 if (PyErr_Occurred()) SWIG_fail;
29328 }
29329 resultobj = SWIG_From_int((result));
29330 return resultobj;
29331 fail:
29332 return NULL;
29333 }
29334
29335
29336 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29337 PyObject *obj;
29338 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29339 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29340 Py_INCREF(obj);
29341 return Py_BuildValue((char *)"");
29342 }
29343 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29344 PyObject *resultobj;
29345 wxClipboard *result;
29346 char *kwnames[] = {
29347 NULL
29348 };
29349
29350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29351 {
29352 PyThreadState* __tstate = wxPyBeginAllowThreads();
29353 result = (wxClipboard *)new wxClipboard();
29354
29355 wxPyEndAllowThreads(__tstate);
29356 if (PyErr_Occurred()) SWIG_fail;
29357 }
29358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29359 return resultobj;
29360 fail:
29361 return NULL;
29362 }
29363
29364
29365 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29366 PyObject *resultobj;
29367 wxClipboard *arg1 = (wxClipboard *) 0 ;
29368 PyObject * obj0 = 0 ;
29369 char *kwnames[] = {
29370 (char *) "self", NULL
29371 };
29372
29373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29375 if (SWIG_arg_fail(1)) SWIG_fail;
29376 {
29377 PyThreadState* __tstate = wxPyBeginAllowThreads();
29378 delete arg1;
29379
29380 wxPyEndAllowThreads(__tstate);
29381 if (PyErr_Occurred()) SWIG_fail;
29382 }
29383 Py_INCREF(Py_None); resultobj = Py_None;
29384 return resultobj;
29385 fail:
29386 return NULL;
29387 }
29388
29389
29390 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29391 PyObject *resultobj;
29392 wxClipboard *arg1 = (wxClipboard *) 0 ;
29393 bool result;
29394 PyObject * obj0 = 0 ;
29395 char *kwnames[] = {
29396 (char *) "self", NULL
29397 };
29398
29399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29401 if (SWIG_arg_fail(1)) SWIG_fail;
29402 {
29403 PyThreadState* __tstate = wxPyBeginAllowThreads();
29404 result = (bool)(arg1)->Open();
29405
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 {
29410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29411 }
29412 return resultobj;
29413 fail:
29414 return NULL;
29415 }
29416
29417
29418 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29419 PyObject *resultobj;
29420 wxClipboard *arg1 = (wxClipboard *) 0 ;
29421 PyObject * obj0 = 0 ;
29422 char *kwnames[] = {
29423 (char *) "self", NULL
29424 };
29425
29426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29428 if (SWIG_arg_fail(1)) SWIG_fail;
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 (arg1)->Close();
29432
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 Py_INCREF(Py_None); resultobj = Py_None;
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29444 PyObject *resultobj;
29445 wxClipboard *arg1 = (wxClipboard *) 0 ;
29446 bool result;
29447 PyObject * obj0 = 0 ;
29448 char *kwnames[] = {
29449 (char *) "self", NULL
29450 };
29451
29452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29454 if (SWIG_arg_fail(1)) SWIG_fail;
29455 {
29456 PyThreadState* __tstate = wxPyBeginAllowThreads();
29457 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29458
29459 wxPyEndAllowThreads(__tstate);
29460 if (PyErr_Occurred()) SWIG_fail;
29461 }
29462 {
29463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29464 }
29465 return resultobj;
29466 fail:
29467 return NULL;
29468 }
29469
29470
29471 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29472 PyObject *resultobj;
29473 wxClipboard *arg1 = (wxClipboard *) 0 ;
29474 wxDataObject *arg2 = (wxDataObject *) 0 ;
29475 bool result;
29476 PyObject * obj0 = 0 ;
29477 PyObject * obj1 = 0 ;
29478 char *kwnames[] = {
29479 (char *) "self",(char *) "data", NULL
29480 };
29481
29482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29484 if (SWIG_arg_fail(1)) SWIG_fail;
29485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29486 if (SWIG_arg_fail(2)) SWIG_fail;
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 result = (bool)(arg1)->AddData(arg2);
29490
29491 wxPyEndAllowThreads(__tstate);
29492 if (PyErr_Occurred()) SWIG_fail;
29493 }
29494 {
29495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29496 }
29497 return resultobj;
29498 fail:
29499 return NULL;
29500 }
29501
29502
29503 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29504 PyObject *resultobj;
29505 wxClipboard *arg1 = (wxClipboard *) 0 ;
29506 wxDataObject *arg2 = (wxDataObject *) 0 ;
29507 bool result;
29508 PyObject * obj0 = 0 ;
29509 PyObject * obj1 = 0 ;
29510 char *kwnames[] = {
29511 (char *) "self",(char *) "data", NULL
29512 };
29513
29514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29516 if (SWIG_arg_fail(1)) SWIG_fail;
29517 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29518 if (SWIG_arg_fail(2)) SWIG_fail;
29519 {
29520 PyThreadState* __tstate = wxPyBeginAllowThreads();
29521 result = (bool)(arg1)->SetData(arg2);
29522
29523 wxPyEndAllowThreads(__tstate);
29524 if (PyErr_Occurred()) SWIG_fail;
29525 }
29526 {
29527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29528 }
29529 return resultobj;
29530 fail:
29531 return NULL;
29532 }
29533
29534
29535 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29536 PyObject *resultobj;
29537 wxClipboard *arg1 = (wxClipboard *) 0 ;
29538 wxDataFormat *arg2 = 0 ;
29539 bool result;
29540 PyObject * obj0 = 0 ;
29541 PyObject * obj1 = 0 ;
29542 char *kwnames[] = {
29543 (char *) "self",(char *) "format", NULL
29544 };
29545
29546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29548 if (SWIG_arg_fail(1)) SWIG_fail;
29549 {
29550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29551 if (SWIG_arg_fail(2)) SWIG_fail;
29552 if (arg2 == NULL) {
29553 SWIG_null_ref("wxDataFormat");
29554 }
29555 if (SWIG_arg_fail(2)) SWIG_fail;
29556 }
29557 {
29558 PyThreadState* __tstate = wxPyBeginAllowThreads();
29559 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29560
29561 wxPyEndAllowThreads(__tstate);
29562 if (PyErr_Occurred()) SWIG_fail;
29563 }
29564 {
29565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29566 }
29567 return resultobj;
29568 fail:
29569 return NULL;
29570 }
29571
29572
29573 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29574 PyObject *resultobj;
29575 wxClipboard *arg1 = (wxClipboard *) 0 ;
29576 wxDataObject *arg2 = 0 ;
29577 bool result;
29578 PyObject * obj0 = 0 ;
29579 PyObject * obj1 = 0 ;
29580 char *kwnames[] = {
29581 (char *) "self",(char *) "data", NULL
29582 };
29583
29584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29586 if (SWIG_arg_fail(1)) SWIG_fail;
29587 {
29588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29589 if (SWIG_arg_fail(2)) SWIG_fail;
29590 if (arg2 == NULL) {
29591 SWIG_null_ref("wxDataObject");
29592 }
29593 if (SWIG_arg_fail(2)) SWIG_fail;
29594 }
29595 {
29596 PyThreadState* __tstate = wxPyBeginAllowThreads();
29597 result = (bool)(arg1)->GetData(*arg2);
29598
29599 wxPyEndAllowThreads(__tstate);
29600 if (PyErr_Occurred()) SWIG_fail;
29601 }
29602 {
29603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29604 }
29605 return resultobj;
29606 fail:
29607 return NULL;
29608 }
29609
29610
29611 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29612 PyObject *resultobj;
29613 wxClipboard *arg1 = (wxClipboard *) 0 ;
29614 PyObject * obj0 = 0 ;
29615 char *kwnames[] = {
29616 (char *) "self", NULL
29617 };
29618
29619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29621 if (SWIG_arg_fail(1)) SWIG_fail;
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 (arg1)->Clear();
29625
29626 wxPyEndAllowThreads(__tstate);
29627 if (PyErr_Occurred()) SWIG_fail;
29628 }
29629 Py_INCREF(Py_None); resultobj = Py_None;
29630 return resultobj;
29631 fail:
29632 return NULL;
29633 }
29634
29635
29636 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29637 PyObject *resultobj;
29638 wxClipboard *arg1 = (wxClipboard *) 0 ;
29639 bool result;
29640 PyObject * obj0 = 0 ;
29641 char *kwnames[] = {
29642 (char *) "self", NULL
29643 };
29644
29645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29647 if (SWIG_arg_fail(1)) SWIG_fail;
29648 {
29649 PyThreadState* __tstate = wxPyBeginAllowThreads();
29650 result = (bool)(arg1)->Flush();
29651
29652 wxPyEndAllowThreads(__tstate);
29653 if (PyErr_Occurred()) SWIG_fail;
29654 }
29655 {
29656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29657 }
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29665 PyObject *resultobj;
29666 wxClipboard *arg1 = (wxClipboard *) 0 ;
29667 bool arg2 = (bool) true ;
29668 PyObject * obj0 = 0 ;
29669 PyObject * obj1 = 0 ;
29670 char *kwnames[] = {
29671 (char *) "self",(char *) "primary", NULL
29672 };
29673
29674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29676 if (SWIG_arg_fail(1)) SWIG_fail;
29677 if (obj1) {
29678 {
29679 arg2 = (bool)(SWIG_As_bool(obj1));
29680 if (SWIG_arg_fail(2)) SWIG_fail;
29681 }
29682 }
29683 {
29684 PyThreadState* __tstate = wxPyBeginAllowThreads();
29685 (arg1)->UsePrimarySelection(arg2);
29686
29687 wxPyEndAllowThreads(__tstate);
29688 if (PyErr_Occurred()) SWIG_fail;
29689 }
29690 Py_INCREF(Py_None); resultobj = Py_None;
29691 return resultobj;
29692 fail:
29693 return NULL;
29694 }
29695
29696
29697 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29698 PyObject *resultobj;
29699 wxClipboard *result;
29700 char *kwnames[] = {
29701 NULL
29702 };
29703
29704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 result = (wxClipboard *)wxClipboard::Get();
29708
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29720 PyObject *obj;
29721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29722 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29723 Py_INCREF(obj);
29724 return Py_BuildValue((char *)"");
29725 }
29726 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29727 PyObject *resultobj;
29728 wxClipboard *arg1 = (wxClipboard *) NULL ;
29729 wxClipboardLocker *result;
29730 PyObject * obj0 = 0 ;
29731 char *kwnames[] = {
29732 (char *) "clipboard", NULL
29733 };
29734
29735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29736 if (obj0) {
29737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29738 if (SWIG_arg_fail(1)) SWIG_fail;
29739 }
29740 {
29741 PyThreadState* __tstate = wxPyBeginAllowThreads();
29742 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29743
29744 wxPyEndAllowThreads(__tstate);
29745 if (PyErr_Occurred()) SWIG_fail;
29746 }
29747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29748 return resultobj;
29749 fail:
29750 return NULL;
29751 }
29752
29753
29754 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29755 PyObject *resultobj;
29756 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29757 PyObject * obj0 = 0 ;
29758 char *kwnames[] = {
29759 (char *) "self", NULL
29760 };
29761
29762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29764 if (SWIG_arg_fail(1)) SWIG_fail;
29765 {
29766 PyThreadState* __tstate = wxPyBeginAllowThreads();
29767 delete arg1;
29768
29769 wxPyEndAllowThreads(__tstate);
29770 if (PyErr_Occurred()) SWIG_fail;
29771 }
29772 Py_INCREF(Py_None); resultobj = Py_None;
29773 return resultobj;
29774 fail:
29775 return NULL;
29776 }
29777
29778
29779 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29780 PyObject *resultobj;
29781 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29782 bool result;
29783 PyObject * obj0 = 0 ;
29784 char *kwnames[] = {
29785 (char *) "self", NULL
29786 };
29787
29788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29790 if (SWIG_arg_fail(1)) SWIG_fail;
29791 {
29792 PyThreadState* __tstate = wxPyBeginAllowThreads();
29793 result = (bool)wxClipboardLocker___nonzero__(arg1);
29794
29795 wxPyEndAllowThreads(__tstate);
29796 if (PyErr_Occurred()) SWIG_fail;
29797 }
29798 {
29799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29800 }
29801 return resultobj;
29802 fail:
29803 return NULL;
29804 }
29805
29806
29807 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29808 PyObject *obj;
29809 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29810 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29811 Py_INCREF(obj);
29812 return Py_BuildValue((char *)"");
29813 }
29814 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29815 PyObject *resultobj;
29816 int arg1 = (int) 0 ;
29817 int arg2 = (int) 0 ;
29818 int arg3 = (int) 0 ;
29819 int arg4 = (int) 0 ;
29820 wxVideoMode *result;
29821 PyObject * obj0 = 0 ;
29822 PyObject * obj1 = 0 ;
29823 PyObject * obj2 = 0 ;
29824 PyObject * obj3 = 0 ;
29825 char *kwnames[] = {
29826 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29827 };
29828
29829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29830 if (obj0) {
29831 {
29832 arg1 = (int)(SWIG_As_int(obj0));
29833 if (SWIG_arg_fail(1)) SWIG_fail;
29834 }
29835 }
29836 if (obj1) {
29837 {
29838 arg2 = (int)(SWIG_As_int(obj1));
29839 if (SWIG_arg_fail(2)) SWIG_fail;
29840 }
29841 }
29842 if (obj2) {
29843 {
29844 arg3 = (int)(SWIG_As_int(obj2));
29845 if (SWIG_arg_fail(3)) SWIG_fail;
29846 }
29847 }
29848 if (obj3) {
29849 {
29850 arg4 = (int)(SWIG_As_int(obj3));
29851 if (SWIG_arg_fail(4)) SWIG_fail;
29852 }
29853 }
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29857
29858 wxPyEndAllowThreads(__tstate);
29859 if (PyErr_Occurred()) SWIG_fail;
29860 }
29861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29869 PyObject *resultobj;
29870 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29871 PyObject * obj0 = 0 ;
29872 char *kwnames[] = {
29873 (char *) "self", NULL
29874 };
29875
29876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29878 if (SWIG_arg_fail(1)) SWIG_fail;
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 delete arg1;
29882
29883 wxPyEndAllowThreads(__tstate);
29884 if (PyErr_Occurred()) SWIG_fail;
29885 }
29886 Py_INCREF(Py_None); resultobj = Py_None;
29887 return resultobj;
29888 fail:
29889 return NULL;
29890 }
29891
29892
29893 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
29894 PyObject *resultobj;
29895 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29896 wxVideoMode *arg2 = 0 ;
29897 bool result;
29898 PyObject * obj0 = 0 ;
29899 PyObject * obj1 = 0 ;
29900 char *kwnames[] = {
29901 (char *) "self",(char *) "other", NULL
29902 };
29903
29904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
29905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29906 if (SWIG_arg_fail(1)) SWIG_fail;
29907 {
29908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29909 if (SWIG_arg_fail(2)) SWIG_fail;
29910 if (arg2 == NULL) {
29911 SWIG_null_ref("wxVideoMode");
29912 }
29913 if (SWIG_arg_fail(2)) SWIG_fail;
29914 }
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
29918
29919 wxPyEndAllowThreads(__tstate);
29920 if (PyErr_Occurred()) SWIG_fail;
29921 }
29922 {
29923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29924 }
29925 return resultobj;
29926 fail:
29927 return NULL;
29928 }
29929
29930
29931 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29932 PyObject *resultobj;
29933 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29934 int result;
29935 PyObject * obj0 = 0 ;
29936 char *kwnames[] = {
29937 (char *) "self", NULL
29938 };
29939
29940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
29941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29942 if (SWIG_arg_fail(1)) SWIG_fail;
29943 {
29944 PyThreadState* __tstate = wxPyBeginAllowThreads();
29945 result = (int)((wxVideoMode const *)arg1)->GetWidth();
29946
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 {
29951 resultobj = SWIG_From_int((int)(result));
29952 }
29953 return resultobj;
29954 fail:
29955 return NULL;
29956 }
29957
29958
29959 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29960 PyObject *resultobj;
29961 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29962 int result;
29963 PyObject * obj0 = 0 ;
29964 char *kwnames[] = {
29965 (char *) "self", NULL
29966 };
29967
29968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
29969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29970 if (SWIG_arg_fail(1)) SWIG_fail;
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 result = (int)((wxVideoMode const *)arg1)->GetHeight();
29974
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 {
29979 resultobj = SWIG_From_int((int)(result));
29980 }
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj;
29989 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29990 int result;
29991 PyObject * obj0 = 0 ;
29992 char *kwnames[] = {
29993 (char *) "self", NULL
29994 };
29995
29996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
29997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29998 if (SWIG_arg_fail(1)) SWIG_fail;
29999 {
30000 PyThreadState* __tstate = wxPyBeginAllowThreads();
30001 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30002
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 {
30007 resultobj = SWIG_From_int((int)(result));
30008 }
30009 return resultobj;
30010 fail:
30011 return NULL;
30012 }
30013
30014
30015 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30016 PyObject *resultobj;
30017 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30018 bool result;
30019 PyObject * obj0 = 0 ;
30020 char *kwnames[] = {
30021 (char *) "self", NULL
30022 };
30023
30024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30026 if (SWIG_arg_fail(1)) SWIG_fail;
30027 {
30028 PyThreadState* __tstate = wxPyBeginAllowThreads();
30029 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30030
30031 wxPyEndAllowThreads(__tstate);
30032 if (PyErr_Occurred()) SWIG_fail;
30033 }
30034 {
30035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30036 }
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30044 PyObject *resultobj;
30045 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30046 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30047 bool result;
30048 PyObject * obj0 = 0 ;
30049 PyObject * obj1 = 0 ;
30050 char *kwnames[] = {
30051 (char *) "self",(char *) "other", NULL
30052 };
30053
30054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30056 if (SWIG_arg_fail(1)) SWIG_fail;
30057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30058 if (SWIG_arg_fail(2)) SWIG_fail;
30059 {
30060 PyThreadState* __tstate = wxPyBeginAllowThreads();
30061 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30062
30063 wxPyEndAllowThreads(__tstate);
30064 if (PyErr_Occurred()) SWIG_fail;
30065 }
30066 {
30067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30068 }
30069 return resultobj;
30070 fail:
30071 return NULL;
30072 }
30073
30074
30075 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30076 PyObject *resultobj;
30077 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30078 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30079 bool result;
30080 PyObject * obj0 = 0 ;
30081 PyObject * obj1 = 0 ;
30082 char *kwnames[] = {
30083 (char *) "self",(char *) "other", NULL
30084 };
30085
30086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30088 if (SWIG_arg_fail(1)) SWIG_fail;
30089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30090 if (SWIG_arg_fail(2)) SWIG_fail;
30091 {
30092 PyThreadState* __tstate = wxPyBeginAllowThreads();
30093 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30094
30095 wxPyEndAllowThreads(__tstate);
30096 if (PyErr_Occurred()) SWIG_fail;
30097 }
30098 {
30099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30100 }
30101 return resultobj;
30102 fail:
30103 return NULL;
30104 }
30105
30106
30107 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30108 PyObject *resultobj;
30109 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30110 int arg2 ;
30111 PyObject * obj0 = 0 ;
30112 PyObject * obj1 = 0 ;
30113 char *kwnames[] = {
30114 (char *) "self",(char *) "w", NULL
30115 };
30116
30117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30119 if (SWIG_arg_fail(1)) SWIG_fail;
30120 {
30121 arg2 = (int)(SWIG_As_int(obj1));
30122 if (SWIG_arg_fail(2)) SWIG_fail;
30123 }
30124 if (arg1) (arg1)->w = arg2;
30125
30126 Py_INCREF(Py_None); resultobj = Py_None;
30127 return resultobj;
30128 fail:
30129 return NULL;
30130 }
30131
30132
30133 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30134 PyObject *resultobj;
30135 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30136 int result;
30137 PyObject * obj0 = 0 ;
30138 char *kwnames[] = {
30139 (char *) "self", NULL
30140 };
30141
30142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30144 if (SWIG_arg_fail(1)) SWIG_fail;
30145 result = (int) ((arg1)->w);
30146
30147 {
30148 resultobj = SWIG_From_int((int)(result));
30149 }
30150 return resultobj;
30151 fail:
30152 return NULL;
30153 }
30154
30155
30156 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30157 PyObject *resultobj;
30158 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30159 int arg2 ;
30160 PyObject * obj0 = 0 ;
30161 PyObject * obj1 = 0 ;
30162 char *kwnames[] = {
30163 (char *) "self",(char *) "h", NULL
30164 };
30165
30166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30168 if (SWIG_arg_fail(1)) SWIG_fail;
30169 {
30170 arg2 = (int)(SWIG_As_int(obj1));
30171 if (SWIG_arg_fail(2)) SWIG_fail;
30172 }
30173 if (arg1) (arg1)->h = arg2;
30174
30175 Py_INCREF(Py_None); resultobj = Py_None;
30176 return resultobj;
30177 fail:
30178 return NULL;
30179 }
30180
30181
30182 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30183 PyObject *resultobj;
30184 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30185 int result;
30186 PyObject * obj0 = 0 ;
30187 char *kwnames[] = {
30188 (char *) "self", NULL
30189 };
30190
30191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30193 if (SWIG_arg_fail(1)) SWIG_fail;
30194 result = (int) ((arg1)->h);
30195
30196 {
30197 resultobj = SWIG_From_int((int)(result));
30198 }
30199 return resultobj;
30200 fail:
30201 return NULL;
30202 }
30203
30204
30205 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj;
30207 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30208 int arg2 ;
30209 PyObject * obj0 = 0 ;
30210 PyObject * obj1 = 0 ;
30211 char *kwnames[] = {
30212 (char *) "self",(char *) "bpp", NULL
30213 };
30214
30215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30217 if (SWIG_arg_fail(1)) SWIG_fail;
30218 {
30219 arg2 = (int)(SWIG_As_int(obj1));
30220 if (SWIG_arg_fail(2)) SWIG_fail;
30221 }
30222 if (arg1) (arg1)->bpp = arg2;
30223
30224 Py_INCREF(Py_None); resultobj = Py_None;
30225 return resultobj;
30226 fail:
30227 return NULL;
30228 }
30229
30230
30231 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30232 PyObject *resultobj;
30233 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30234 int result;
30235 PyObject * obj0 = 0 ;
30236 char *kwnames[] = {
30237 (char *) "self", NULL
30238 };
30239
30240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30242 if (SWIG_arg_fail(1)) SWIG_fail;
30243 result = (int) ((arg1)->bpp);
30244
30245 {
30246 resultobj = SWIG_From_int((int)(result));
30247 }
30248 return resultobj;
30249 fail:
30250 return NULL;
30251 }
30252
30253
30254 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30255 PyObject *resultobj;
30256 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30257 int arg2 ;
30258 PyObject * obj0 = 0 ;
30259 PyObject * obj1 = 0 ;
30260 char *kwnames[] = {
30261 (char *) "self",(char *) "refresh", NULL
30262 };
30263
30264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30266 if (SWIG_arg_fail(1)) SWIG_fail;
30267 {
30268 arg2 = (int)(SWIG_As_int(obj1));
30269 if (SWIG_arg_fail(2)) SWIG_fail;
30270 }
30271 if (arg1) (arg1)->refresh = arg2;
30272
30273 Py_INCREF(Py_None); resultobj = Py_None;
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30281 PyObject *resultobj;
30282 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30283 int result;
30284 PyObject * obj0 = 0 ;
30285 char *kwnames[] = {
30286 (char *) "self", NULL
30287 };
30288
30289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30291 if (SWIG_arg_fail(1)) SWIG_fail;
30292 result = (int) ((arg1)->refresh);
30293
30294 {
30295 resultobj = SWIG_From_int((int)(result));
30296 }
30297 return resultobj;
30298 fail:
30299 return NULL;
30300 }
30301
30302
30303 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30304 PyObject *obj;
30305 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30306 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30307 Py_INCREF(obj);
30308 return Py_BuildValue((char *)"");
30309 }
30310 static int _wrap_DefaultVideoMode_set(PyObject *) {
30311 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30312 return 1;
30313 }
30314
30315
30316 static PyObject *_wrap_DefaultVideoMode_get(void) {
30317 PyObject *pyobj;
30318
30319 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30320 return pyobj;
30321 }
30322
30323
30324 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30325 PyObject *resultobj;
30326 size_t arg1 = (size_t) 0 ;
30327 wxDisplay *result;
30328 PyObject * obj0 = 0 ;
30329 char *kwnames[] = {
30330 (char *) "index", NULL
30331 };
30332
30333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30334 if (obj0) {
30335 {
30336 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30337 if (SWIG_arg_fail(1)) SWIG_fail;
30338 }
30339 }
30340 {
30341 PyThreadState* __tstate = wxPyBeginAllowThreads();
30342 result = (wxDisplay *)new wxDisplay(arg1);
30343
30344 wxPyEndAllowThreads(__tstate);
30345 if (PyErr_Occurred()) SWIG_fail;
30346 }
30347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30348 return resultobj;
30349 fail:
30350 return NULL;
30351 }
30352
30353
30354 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30355 PyObject *resultobj;
30356 wxDisplay *arg1 = (wxDisplay *) 0 ;
30357 PyObject * obj0 = 0 ;
30358 char *kwnames[] = {
30359 (char *) "self", NULL
30360 };
30361
30362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30364 if (SWIG_arg_fail(1)) SWIG_fail;
30365 {
30366 PyThreadState* __tstate = wxPyBeginAllowThreads();
30367 delete arg1;
30368
30369 wxPyEndAllowThreads(__tstate);
30370 if (PyErr_Occurred()) SWIG_fail;
30371 }
30372 Py_INCREF(Py_None); resultobj = Py_None;
30373 return resultobj;
30374 fail:
30375 return NULL;
30376 }
30377
30378
30379 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30380 PyObject *resultobj;
30381 size_t result;
30382 char *kwnames[] = {
30383 NULL
30384 };
30385
30386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30387 {
30388 PyThreadState* __tstate = wxPyBeginAllowThreads();
30389 result = (size_t)wxDisplay::GetCount();
30390
30391 wxPyEndAllowThreads(__tstate);
30392 if (PyErr_Occurred()) SWIG_fail;
30393 }
30394 {
30395 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30396 }
30397 return resultobj;
30398 fail:
30399 return NULL;
30400 }
30401
30402
30403 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30404 PyObject *resultobj;
30405 wxPoint *arg1 = 0 ;
30406 int result;
30407 wxPoint temp1 ;
30408 PyObject * obj0 = 0 ;
30409 char *kwnames[] = {
30410 (char *) "pt", NULL
30411 };
30412
30413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30414 {
30415 arg1 = &temp1;
30416 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30417 }
30418 {
30419 PyThreadState* __tstate = wxPyBeginAllowThreads();
30420 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30421
30422 wxPyEndAllowThreads(__tstate);
30423 if (PyErr_Occurred()) SWIG_fail;
30424 }
30425 {
30426 resultobj = SWIG_From_int((int)(result));
30427 }
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30435 PyObject *resultobj;
30436 wxWindow *arg1 = (wxWindow *) 0 ;
30437 int result;
30438 PyObject * obj0 = 0 ;
30439 char *kwnames[] = {
30440 (char *) "window", NULL
30441 };
30442
30443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30445 if (SWIG_arg_fail(1)) SWIG_fail;
30446 {
30447 PyThreadState* __tstate = wxPyBeginAllowThreads();
30448 result = (int)Display_GetFromWindow(arg1);
30449
30450 wxPyEndAllowThreads(__tstate);
30451 if (PyErr_Occurred()) SWIG_fail;
30452 }
30453 {
30454 resultobj = SWIG_From_int((int)(result));
30455 }
30456 return resultobj;
30457 fail:
30458 return NULL;
30459 }
30460
30461
30462 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30463 PyObject *resultobj;
30464 wxDisplay *arg1 = (wxDisplay *) 0 ;
30465 bool result;
30466 PyObject * obj0 = 0 ;
30467 char *kwnames[] = {
30468 (char *) "self", NULL
30469 };
30470
30471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30473 if (SWIG_arg_fail(1)) SWIG_fail;
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 result = (bool)((wxDisplay const *)arg1)->IsOk();
30477
30478 wxPyEndAllowThreads(__tstate);
30479 if (PyErr_Occurred()) SWIG_fail;
30480 }
30481 {
30482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30483 }
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30491 PyObject *resultobj;
30492 wxDisplay *arg1 = (wxDisplay *) 0 ;
30493 wxRect result;
30494 PyObject * obj0 = 0 ;
30495 char *kwnames[] = {
30496 (char *) "self", NULL
30497 };
30498
30499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30501 if (SWIG_arg_fail(1)) SWIG_fail;
30502 {
30503 PyThreadState* __tstate = wxPyBeginAllowThreads();
30504 result = ((wxDisplay const *)arg1)->GetGeometry();
30505
30506 wxPyEndAllowThreads(__tstate);
30507 if (PyErr_Occurred()) SWIG_fail;
30508 }
30509 {
30510 wxRect * resultptr;
30511 resultptr = new wxRect((wxRect &)(result));
30512 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30513 }
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30521 PyObject *resultobj;
30522 wxDisplay *arg1 = (wxDisplay *) 0 ;
30523 wxString result;
30524 PyObject * obj0 = 0 ;
30525 char *kwnames[] = {
30526 (char *) "self", NULL
30527 };
30528
30529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30531 if (SWIG_arg_fail(1)) SWIG_fail;
30532 {
30533 PyThreadState* __tstate = wxPyBeginAllowThreads();
30534 result = ((wxDisplay const *)arg1)->GetName();
30535
30536 wxPyEndAllowThreads(__tstate);
30537 if (PyErr_Occurred()) SWIG_fail;
30538 }
30539 {
30540 #if wxUSE_UNICODE
30541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30542 #else
30543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30544 #endif
30545 }
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30553 PyObject *resultobj;
30554 wxDisplay *arg1 = (wxDisplay *) 0 ;
30555 bool result;
30556 PyObject * obj0 = 0 ;
30557 char *kwnames[] = {
30558 (char *) "self", NULL
30559 };
30560
30561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30563 if (SWIG_arg_fail(1)) SWIG_fail;
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30567
30568 wxPyEndAllowThreads(__tstate);
30569 if (PyErr_Occurred()) SWIG_fail;
30570 }
30571 {
30572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30573 }
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30581 PyObject *resultobj;
30582 wxDisplay *arg1 = (wxDisplay *) 0 ;
30583 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30584 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30585 PyObject *result;
30586 PyObject * obj0 = 0 ;
30587 PyObject * obj1 = 0 ;
30588 char *kwnames[] = {
30589 (char *) "self",(char *) "mode", NULL
30590 };
30591
30592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30594 if (SWIG_arg_fail(1)) SWIG_fail;
30595 if (obj1) {
30596 {
30597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30598 if (SWIG_arg_fail(2)) SWIG_fail;
30599 if (arg2 == NULL) {
30600 SWIG_null_ref("wxVideoMode");
30601 }
30602 if (SWIG_arg_fail(2)) SWIG_fail;
30603 }
30604 }
30605 {
30606 PyThreadState* __tstate = wxPyBeginAllowThreads();
30607 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30608
30609 wxPyEndAllowThreads(__tstate);
30610 if (PyErr_Occurred()) SWIG_fail;
30611 }
30612 resultobj = result;
30613 return resultobj;
30614 fail:
30615 return NULL;
30616 }
30617
30618
30619 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30620 PyObject *resultobj;
30621 wxDisplay *arg1 = (wxDisplay *) 0 ;
30622 wxVideoMode result;
30623 PyObject * obj0 = 0 ;
30624 char *kwnames[] = {
30625 (char *) "self", NULL
30626 };
30627
30628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30630 if (SWIG_arg_fail(1)) SWIG_fail;
30631 {
30632 PyThreadState* __tstate = wxPyBeginAllowThreads();
30633 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30634
30635 wxPyEndAllowThreads(__tstate);
30636 if (PyErr_Occurred()) SWIG_fail;
30637 }
30638 {
30639 wxVideoMode * resultptr;
30640 resultptr = new wxVideoMode((wxVideoMode &)(result));
30641 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30642 }
30643 return resultobj;
30644 fail:
30645 return NULL;
30646 }
30647
30648
30649 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30650 PyObject *resultobj;
30651 wxDisplay *arg1 = (wxDisplay *) 0 ;
30652 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30653 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30654 bool result;
30655 PyObject * obj0 = 0 ;
30656 PyObject * obj1 = 0 ;
30657 char *kwnames[] = {
30658 (char *) "self",(char *) "mode", NULL
30659 };
30660
30661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30663 if (SWIG_arg_fail(1)) SWIG_fail;
30664 if (obj1) {
30665 {
30666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30667 if (SWIG_arg_fail(2)) SWIG_fail;
30668 if (arg2 == NULL) {
30669 SWIG_null_ref("wxVideoMode");
30670 }
30671 if (SWIG_arg_fail(2)) SWIG_fail;
30672 }
30673 }
30674 {
30675 PyThreadState* __tstate = wxPyBeginAllowThreads();
30676 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30677
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 {
30682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30683 }
30684 return resultobj;
30685 fail:
30686 return NULL;
30687 }
30688
30689
30690 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30691 PyObject *resultobj;
30692 wxDisplay *arg1 = (wxDisplay *) 0 ;
30693 PyObject * obj0 = 0 ;
30694 char *kwnames[] = {
30695 (char *) "self", NULL
30696 };
30697
30698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30700 if (SWIG_arg_fail(1)) SWIG_fail;
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 (arg1)->ResetMode();
30704
30705 wxPyEndAllowThreads(__tstate);
30706 if (PyErr_Occurred()) SWIG_fail;
30707 }
30708 Py_INCREF(Py_None); resultobj = Py_None;
30709 return resultobj;
30710 fail:
30711 return NULL;
30712 }
30713
30714
30715 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30716 PyObject *obj;
30717 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30718 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30719 Py_INCREF(obj);
30720 return Py_BuildValue((char *)"");
30721 }
30722 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30723 PyObject *resultobj;
30724 wxStandardPaths *result;
30725 char *kwnames[] = {
30726 NULL
30727 };
30728
30729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30730 {
30731 PyThreadState* __tstate = wxPyBeginAllowThreads();
30732 result = (wxStandardPaths *)StandardPaths_Get();
30733
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30745 PyObject *resultobj;
30746 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30747 wxString result;
30748 PyObject * obj0 = 0 ;
30749 char *kwnames[] = {
30750 (char *) "self", NULL
30751 };
30752
30753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30755 if (SWIG_arg_fail(1)) SWIG_fail;
30756 {
30757 PyThreadState* __tstate = wxPyBeginAllowThreads();
30758 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30759
30760 wxPyEndAllowThreads(__tstate);
30761 if (PyErr_Occurred()) SWIG_fail;
30762 }
30763 {
30764 #if wxUSE_UNICODE
30765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30766 #else
30767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30768 #endif
30769 }
30770 return resultobj;
30771 fail:
30772 return NULL;
30773 }
30774
30775
30776 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30777 PyObject *resultobj;
30778 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30779 wxString result;
30780 PyObject * obj0 = 0 ;
30781 char *kwnames[] = {
30782 (char *) "self", NULL
30783 };
30784
30785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30787 if (SWIG_arg_fail(1)) SWIG_fail;
30788 {
30789 PyThreadState* __tstate = wxPyBeginAllowThreads();
30790 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30791
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 {
30796 #if wxUSE_UNICODE
30797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30798 #else
30799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30800 #endif
30801 }
30802 return resultobj;
30803 fail:
30804 return NULL;
30805 }
30806
30807
30808 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30809 PyObject *resultobj;
30810 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30811 wxString result;
30812 PyObject * obj0 = 0 ;
30813 char *kwnames[] = {
30814 (char *) "self", NULL
30815 };
30816
30817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30819 if (SWIG_arg_fail(1)) SWIG_fail;
30820 {
30821 PyThreadState* __tstate = wxPyBeginAllowThreads();
30822 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30823
30824 wxPyEndAllowThreads(__tstate);
30825 if (PyErr_Occurred()) SWIG_fail;
30826 }
30827 {
30828 #if wxUSE_UNICODE
30829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30830 #else
30831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30832 #endif
30833 }
30834 return resultobj;
30835 fail:
30836 return NULL;
30837 }
30838
30839
30840 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30841 PyObject *resultobj;
30842 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30843 wxString result;
30844 PyObject * obj0 = 0 ;
30845 char *kwnames[] = {
30846 (char *) "self", NULL
30847 };
30848
30849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30851 if (SWIG_arg_fail(1)) SWIG_fail;
30852 {
30853 PyThreadState* __tstate = wxPyBeginAllowThreads();
30854 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30855
30856 wxPyEndAllowThreads(__tstate);
30857 if (PyErr_Occurred()) SWIG_fail;
30858 }
30859 {
30860 #if wxUSE_UNICODE
30861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30862 #else
30863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30864 #endif
30865 }
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj;
30874 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30875 wxString result;
30876 PyObject * obj0 = 0 ;
30877 char *kwnames[] = {
30878 (char *) "self", NULL
30879 };
30880
30881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30883 if (SWIG_arg_fail(1)) SWIG_fail;
30884 {
30885 PyThreadState* __tstate = wxPyBeginAllowThreads();
30886 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30887
30888 wxPyEndAllowThreads(__tstate);
30889 if (PyErr_Occurred()) SWIG_fail;
30890 }
30891 {
30892 #if wxUSE_UNICODE
30893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30894 #else
30895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30896 #endif
30897 }
30898 return resultobj;
30899 fail:
30900 return NULL;
30901 }
30902
30903
30904 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30905 PyObject *resultobj;
30906 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30907 wxString result;
30908 PyObject * obj0 = 0 ;
30909 char *kwnames[] = {
30910 (char *) "self", NULL
30911 };
30912
30913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
30914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30915 if (SWIG_arg_fail(1)) SWIG_fail;
30916 {
30917 PyThreadState* __tstate = wxPyBeginAllowThreads();
30918 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
30919
30920 wxPyEndAllowThreads(__tstate);
30921 if (PyErr_Occurred()) SWIG_fail;
30922 }
30923 {
30924 #if wxUSE_UNICODE
30925 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30926 #else
30927 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30928 #endif
30929 }
30930 return resultobj;
30931 fail:
30932 return NULL;
30933 }
30934
30935
30936 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
30937 PyObject *resultobj;
30938 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30939 wxString result;
30940 PyObject * obj0 = 0 ;
30941 char *kwnames[] = {
30942 (char *) "self", NULL
30943 };
30944
30945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
30946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30947 if (SWIG_arg_fail(1)) SWIG_fail;
30948 {
30949 PyThreadState* __tstate = wxPyBeginAllowThreads();
30950 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
30951
30952 wxPyEndAllowThreads(__tstate);
30953 if (PyErr_Occurred()) SWIG_fail;
30954 }
30955 {
30956 #if wxUSE_UNICODE
30957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30958 #else
30959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30960 #endif
30961 }
30962 return resultobj;
30963 fail:
30964 return NULL;
30965 }
30966
30967
30968 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30969 PyObject *resultobj;
30970 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30971 wxString *arg2 = 0 ;
30972 bool temp2 = false ;
30973 PyObject * obj0 = 0 ;
30974 PyObject * obj1 = 0 ;
30975 char *kwnames[] = {
30976 (char *) "self",(char *) "prefix", NULL
30977 };
30978
30979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
30980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30981 if (SWIG_arg_fail(1)) SWIG_fail;
30982 {
30983 arg2 = wxString_in_helper(obj1);
30984 if (arg2 == NULL) SWIG_fail;
30985 temp2 = true;
30986 }
30987 {
30988 PyThreadState* __tstate = wxPyBeginAllowThreads();
30989 (arg1)->SetInstallPrefix((wxString const &)*arg2);
30990
30991 wxPyEndAllowThreads(__tstate);
30992 if (PyErr_Occurred()) SWIG_fail;
30993 }
30994 Py_INCREF(Py_None); resultobj = Py_None;
30995 {
30996 if (temp2)
30997 delete arg2;
30998 }
30999 return resultobj;
31000 fail:
31001 {
31002 if (temp2)
31003 delete arg2;
31004 }
31005 return NULL;
31006 }
31007
31008
31009 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31010 PyObject *resultobj;
31011 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31012 wxString result;
31013 PyObject * obj0 = 0 ;
31014 char *kwnames[] = {
31015 (char *) "self", NULL
31016 };
31017
31018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31020 if (SWIG_arg_fail(1)) SWIG_fail;
31021 {
31022 PyThreadState* __tstate = wxPyBeginAllowThreads();
31023 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31024
31025 wxPyEndAllowThreads(__tstate);
31026 if (PyErr_Occurred()) SWIG_fail;
31027 }
31028 {
31029 #if wxUSE_UNICODE
31030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31031 #else
31032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31033 #endif
31034 }
31035 return resultobj;
31036 fail:
31037 return NULL;
31038 }
31039
31040
31041 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31042 PyObject *obj;
31043 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31044 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31045 Py_INCREF(obj);
31046 return Py_BuildValue((char *)"");
31047 }
31048 static PyMethodDef SwigMethods[] = {
31049 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31050 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31051 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31052 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31053 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31054 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31055 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31056 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31057 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31058 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31059 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31060 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31061 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31062 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31063 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31064 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31065 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31066 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31067 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31068 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31069 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31070 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31071 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31072 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31073 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31074 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31075 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31076 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31077 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31078 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31079 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31080 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31081 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31082 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31083 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31084 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31085 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31086 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31087 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31088 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31089 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31090 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31091 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31092 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31093 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31094 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31095 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31096 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31097 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31098 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31099 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31100 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31101 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31102 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31103 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31104 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31105 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31106 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31111 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31112 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31113 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31114 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31115 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31119 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31120 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31121 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31125 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31126 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31127 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31128 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31129 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31130 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31131 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31132 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31133 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31135 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31136 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31137 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31138 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31139 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31140 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31144 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31150 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31151 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31152 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31154 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31155 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31156 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31157 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31158 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31159 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31160 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31161 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31162 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31168 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31182 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31183 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31185 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31187 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31188 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31193 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31196 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31207 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31210 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31213 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31214 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31217 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31244 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31246 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31248 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31250 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31257 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31263 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31277 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31281 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31284 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31301 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31309 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31356 { (char *)"JoystickEvent_m_pos_set", (PyCFunction) _wrap_JoystickEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"JoystickEvent_m_pos_get", (PyCFunction) _wrap_JoystickEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"JoystickEvent_m_zPosition_set", (PyCFunction) _wrap_JoystickEvent_m_zPosition_set, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"JoystickEvent_m_zPosition_get", (PyCFunction) _wrap_JoystickEvent_m_zPosition_get, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"JoystickEvent_m_buttonChange_set", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_set, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"JoystickEvent_m_buttonChange_get", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_get, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"JoystickEvent_m_buttonState_set", (PyCFunction) _wrap_JoystickEvent_m_buttonState_set, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"JoystickEvent_m_buttonState_get", (PyCFunction) _wrap_JoystickEvent_m_buttonState_get, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"JoystickEvent_m_joyStick_set", (PyCFunction) _wrap_JoystickEvent_m_joyStick_set, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"JoystickEvent_m_joyStick_get", (PyCFunction) _wrap_JoystickEvent_m_joyStick_get, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31384 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31394 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31410 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31426 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31440 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31449 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31492 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31495 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31498 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31502 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31595 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31596 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31597 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31598 { (char *)"DateTime___lt__", _wrap_DateTime___lt__, METH_VARARGS, NULL},
31599 { (char *)"DateTime___le__", _wrap_DateTime___le__, METH_VARARGS, NULL},
31600 { (char *)"DateTime___gt__", _wrap_DateTime___gt__, METH_VARARGS, NULL},
31601 { (char *)"DateTime___ge__", _wrap_DateTime___ge__, METH_VARARGS, NULL},
31602 { (char *)"DateTime___eq__", _wrap_DateTime___eq__, METH_VARARGS, NULL},
31603 { (char *)"DateTime___ne__", _wrap_DateTime___ne__, METH_VARARGS, NULL},
31604 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31615 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31660 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31694 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31702 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31703 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31708 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31717 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31724 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31727 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31730 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31735 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31738 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31742 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31745 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31749 { (char *)"new_CustomDataObject", (PyCFunction) _wrap_new_CustomDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31754 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31758 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31760 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31770 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31781 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31789 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31797 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31811 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31815 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31833 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31847 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31858 { NULL, NULL, 0, NULL }
31859 };
31860
31861
31862 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31863
31864 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31865 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31866 }
31867 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31868 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31869 }
31870 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31871 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31872 }
31873 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31874 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31875 }
31876 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31877 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31878 }
31879 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31880 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31881 }
31882 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31883 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31884 }
31885 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31886 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31887 }
31888 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31889 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31890 }
31891 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31892 return (void *)((wxEvent *) ((wxPyEvent *) x));
31893 }
31894 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31895 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31896 }
31897 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
31898 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
31899 }
31900 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
31901 return (void *)((wxEvent *) ((wxIdleEvent *) x));
31902 }
31903 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
31904 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
31905 }
31906 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
31907 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
31908 }
31909 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
31910 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
31911 }
31912 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
31913 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
31914 }
31915 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
31916 return (void *)((wxEvent *) ((wxActivateEvent *) x));
31917 }
31918 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
31919 return (void *)((wxEvent *) ((wxSizeEvent *) x));
31920 }
31921 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
31922 return (void *)((wxEvent *) ((wxMoveEvent *) x));
31923 }
31924 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
31925 return (void *)((wxEvent *) ((wxPaintEvent *) x));
31926 }
31927 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
31928 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
31929 }
31930 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
31931 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
31932 }
31933 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
31934 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
31935 }
31936 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
31937 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
31938 }
31939 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
31940 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31941 }
31942 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
31943 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
31944 }
31945 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
31946 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
31947 }
31948 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
31949 return (void *)((wxEvent *) ((wxFocusEvent *) x));
31950 }
31951 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
31952 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
31953 }
31954 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
31955 return (void *)((wxEvent *) ((wxProcessEvent *) x));
31956 }
31957 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
31958 return (void *)((wxEvent *) ((wxShowEvent *) x));
31959 }
31960 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
31961 return (void *)((wxEvent *) ((wxCommandEvent *) x));
31962 }
31963 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
31964 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
31965 }
31966 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
31967 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
31968 }
31969 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
31970 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
31971 }
31972 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
31973 return (void *)((wxEvent *) ((wxKeyEvent *) x));
31974 }
31975 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
31976 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
31977 }
31978 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
31979 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
31980 }
31981 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
31982 return (void *)((wxConfigBase *) ((wxConfig *) x));
31983 }
31984 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
31985 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31986 }
31987 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
31988 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
31989 }
31990 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
31991 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
31992 }
31993 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
31994 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31995 }
31996 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
31997 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
31998 }
31999 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32000 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32001 }
32002 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32003 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32004 }
32005 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32006 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32007 }
32008 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32009 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32010 }
32011 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32012 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32013 }
32014 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32015 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32016 }
32017 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32018 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32019 }
32020 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32021 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32022 }
32023 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32024 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32025 }
32026 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32027 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32028 }
32029 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32030 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32031 }
32032 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32033 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32034 }
32035 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32036 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32037 }
32038 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32039 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32040 }
32041 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32042 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32043 }
32044 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32045 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32046 }
32047 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32048 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32049 }
32050 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32051 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32052 }
32053 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32054 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32055 }
32056 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32057 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32058 }
32059 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32060 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32061 }
32062 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32063 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32064 }
32065 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32066 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32067 }
32068 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32069 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32070 }
32071 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32072 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32073 }
32074 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32075 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32076 }
32077 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32078 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32079 }
32080 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32081 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32082 }
32083 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32084 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32085 }
32086 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32087 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32088 }
32089 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32090 return (void *)((wxObject *) ((wxSizerItem *) x));
32091 }
32092 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32093 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32094 }
32095 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32096 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32097 }
32098 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32099 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32100 }
32101 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32102 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32103 }
32104 static void *_p_wxSizerTo_p_wxObject(void *x) {
32105 return (void *)((wxObject *) ((wxSizer *) x));
32106 }
32107 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32108 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32109 }
32110 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32111 return (void *)((wxObject *) ((wxFileHistory *) x));
32112 }
32113 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32114 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32115 }
32116 static void *_p_wxEventTo_p_wxObject(void *x) {
32117 return (void *)((wxObject *) ((wxEvent *) x));
32118 }
32119 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32120 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32121 }
32122 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32123 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32124 }
32125 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32126 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32127 }
32128 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32129 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32130 }
32131 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32132 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32133 }
32134 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32135 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32136 }
32137 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32138 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32139 }
32140 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32141 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32142 }
32143 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32144 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32145 }
32146 static void *_p_wxControlTo_p_wxObject(void *x) {
32147 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32148 }
32149 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32150 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32151 }
32152 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32153 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32154 }
32155 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32156 return (void *)((wxObject *) ((wxFSFile *) x));
32157 }
32158 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32159 return (void *)((wxObject *) ((wxClipboard *) x));
32160 }
32161 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32162 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32163 }
32164 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32165 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32166 }
32167 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32168 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32169 }
32170 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32171 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32172 }
32173 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32174 return (void *)((wxObject *) ((wxToolTip *) x));
32175 }
32176 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32177 return (void *)((wxObject *) ((wxMenuItem *) x));
32178 }
32179 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32180 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32181 }
32182 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32183 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32184 }
32185 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32186 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32187 }
32188 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32189 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32190 }
32191 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32192 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32193 }
32194 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32195 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32196 }
32197 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32198 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32199 }
32200 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32201 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32202 }
32203 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32204 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32205 }
32206 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32207 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32208 }
32209 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32210 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32211 }
32212 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32213 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32214 }
32215 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32216 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32217 }
32218 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32219 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32220 }
32221 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32222 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32223 }
32224 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32225 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32226 }
32227 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32228 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32229 }
32230 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32231 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32232 }
32233 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32234 return (void *)((wxObject *) ((wxImageHandler *) x));
32235 }
32236 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32237 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32238 }
32239 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32240 return (void *)((wxObject *) ((wxEvtHandler *) x));
32241 }
32242 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32243 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32244 }
32245 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32246 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32247 }
32248 static void *_p_wxImageTo_p_wxObject(void *x) {
32249 return (void *)((wxObject *) ((wxImage *) x));
32250 }
32251 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32252 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32253 }
32254 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32255 return (void *)((wxObject *) ((wxSystemOptions *) x));
32256 }
32257 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32258 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32259 }
32260 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32261 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32262 }
32263 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32264 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32265 }
32266 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32267 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32268 }
32269 static void *_p_wxWindowTo_p_wxObject(void *x) {
32270 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32271 }
32272 static void *_p_wxMenuTo_p_wxObject(void *x) {
32273 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32274 }
32275 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32276 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32277 }
32278 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32279 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32280 }
32281 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32282 return (void *)((wxObject *) ((wxFileSystem *) x));
32283 }
32284 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32285 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32286 }
32287 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32288 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32289 }
32290 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32291 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32292 }
32293 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32294 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32295 }
32296 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32297 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32298 }
32299 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32300 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32301 }
32302 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32303 return (void *)((wxObject *) ((wxBusyInfo *) x));
32304 }
32305 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32306 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32307 }
32308 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32309 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32310 }
32311 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32312 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32313 }
32314 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32315 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32316 }
32317 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32318 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32319 }
32320 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32321 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32322 }
32323 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32324 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32325 }
32326 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32327 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32328 }
32329 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32330 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32331 }
32332 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32333 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32334 }
32335 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32336 return (void *)((wxLog *) ((wxLogStderr *) x));
32337 }
32338 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32339 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32340 }
32341 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32342 return (void *)((wxLog *) ((wxLogWindow *) x));
32343 }
32344 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32345 return (void *)((wxLog *) ((wxLogChain *) x));
32346 }
32347 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32348 return (void *)((wxLog *) ((wxLogGui *) x));
32349 }
32350 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32351 return (void *)((wxLog *) ((wxPyLog *) x));
32352 }
32353 static void *_p_wxControlTo_p_wxWindow(void *x) {
32354 return (void *)((wxWindow *) ((wxControl *) x));
32355 }
32356 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32357 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32358 }
32359 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32360 return (void *)((wxWindow *) ((wxMenuBar *) x));
32361 }
32362 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32363 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32364 }
32365 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32366 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32367 }
32368 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}};
32369 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}};
32370 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}};
32371 static swig_type_info _swigt__p_wxLog[] = {{"_p_wxLog", 0, "wxLog *", 0, 0, 0, 0},{"_p_wxLogStderr", _p_wxLogStderrTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogTextCtrl", _p_wxLogTextCtrlTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogWindow", _p_wxLogWindowTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogChain", _p_wxLogChainTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogGui", _p_wxLogGuiTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxPyLog", _p_wxPyLogTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32372 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}};
32373 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32374 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}};
32375 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}};
32376 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}};
32377 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}};
32378 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}};
32379 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}};
32380 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}};
32381 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}};
32382 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}};
32383 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}};
32384 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}};
32385 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}};
32386 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}};
32387 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}};
32388 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}};
32389 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}};
32390 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}};
32391 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}};
32392 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}};
32393 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}};
32394 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}};
32395 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}};
32396 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}};
32397 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}};
32398 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}};
32399 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}};
32400 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}};
32401 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}};
32402 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}};
32403 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}};
32404 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}};
32405 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}};
32406 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}};
32407 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}};
32408 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}};
32409 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}};
32410 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}};
32411 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}};
32412 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}};
32413 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}};
32414 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}};
32415 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}};
32416 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}};
32417 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}};
32418 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}};
32419 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}};
32420 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}};
32421 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}};
32422 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}};
32423 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}};
32424 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}};
32425 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}};
32426 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}};
32427 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}};
32428 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}};
32429 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}};
32430 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}};
32431 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}};
32432 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}};
32433 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}};
32434 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}};
32435 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}};
32436 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}};
32437 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_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}};
32438 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}};
32439 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}};
32440 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}};
32441 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}};
32442 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}};
32443 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}};
32444 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}};
32445 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}};
32446 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}};
32447 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}};
32448 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}};
32449 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}};
32450 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}};
32451 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}};
32452 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}};
32453 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}};
32454 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}};
32455 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}};
32456 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}};
32457 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}};
32458 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}};
32459 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}};
32460 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}};
32461 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}};
32462 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}};
32463
32464 static swig_type_info *swig_types_initial[] = {
32465 _swigt__p_wxLogChain,
32466 _swigt__p_wxMutexGuiLocker,
32467 _swigt__p_wxFileHistory,
32468 _swigt__p_wxLog,
32469 _swigt__p_wxMenu,
32470 _swigt__p_wxEvent,
32471 _swigt__p_wxDateTime__TimeZone,
32472 _swigt__p_wxConfigBase,
32473 _swigt__p_wxDisplay,
32474 _swigt__p_wxFileType,
32475 _swigt__p_wxLogGui,
32476 _swigt__p_wxFont,
32477 _swigt__p_wxDataFormat,
32478 _swigt__p_wxTimerEvent,
32479 _swigt__p_wxCaret,
32480 _swigt__ptrdiff_t,
32481 _swigt__std__ptrdiff_t,
32482 _swigt__p_int,
32483 _swigt__p_wxSize,
32484 _swigt__p_wxClipboard,
32485 _swigt__p_wxStopWatch,
32486 _swigt__p_wxClipboardLocker,
32487 _swigt__p_wxIcon,
32488 _swigt__p_wxLogStderr,
32489 _swigt__p_wxLogTextCtrl,
32490 _swigt__p_wxTextCtrl,
32491 _swigt__p_wxBusyCursor,
32492 _swigt__p_wxBitmapDataObject,
32493 _swigt__p_wxTextDataObject,
32494 _swigt__p_wxDataObject,
32495 _swigt__p_wxPyTextDataObject,
32496 _swigt__p_wxPyBitmapDataObject,
32497 _swigt__p_wxFileDataObject,
32498 _swigt__p_wxCustomDataObject,
32499 _swigt__p_wxURLDataObject,
32500 _swigt__p_wxMetafileDataObject,
32501 _swigt__p_wxSound,
32502 _swigt__p_wxTimerRunner,
32503 _swigt__p_wxLogWindow,
32504 _swigt__p_wxTimeSpan,
32505 _swigt__p_wxArrayString,
32506 _swigt__p_wxWindowDisabler,
32507 _swigt__p_form_ops_t,
32508 _swigt__p_wxToolTip,
32509 _swigt__p_wxDataObjectComposite,
32510 _swigt__p_wxFileConfig,
32511 _swigt__p_wxSystemSettings,
32512 _swigt__p_wxVideoMode,
32513 _swigt__p_wxDataObjectSimple,
32514 _swigt__p_wxPyDataObjectSimple,
32515 _swigt__p_wxDuplexMode,
32516 _swigt__p_wxEvtHandler,
32517 _swigt__p_wxRect,
32518 _swigt__p_char,
32519 _swigt__p_wxSingleInstanceChecker,
32520 _swigt__p_wxStandardPaths,
32521 _swigt__p_wxFileTypeInfo,
32522 _swigt__p_wxFrame,
32523 _swigt__p_wxTimer,
32524 _swigt__p_wxPaperSize,
32525 _swigt__p_wxMimeTypesManager,
32526 _swigt__p_wxPyArtProvider,
32527 _swigt__p_wxPyTipProvider,
32528 _swigt__p_wxTipProvider,
32529 _swigt__p_wxJoystick,
32530 _swigt__p_wxSystemOptions,
32531 _swigt__p_wxPoint,
32532 _swigt__p_wxJoystickEvent,
32533 _swigt__p_wxCursor,
32534 _swigt__p_wxObject,
32535 _swigt__p_wxOutputStream,
32536 _swigt__p_wxDateTime,
32537 _swigt__p_wxPyDropSource,
32538 _swigt__p_unsigned_long,
32539 _swigt__p_wxKillError,
32540 _swigt__p_wxWindow,
32541 _swigt__p_wxString,
32542 _swigt__p_wxPyProcess,
32543 _swigt__p_wxBitmap,
32544 _swigt__p_wxConfig,
32545 _swigt__unsigned_int,
32546 _swigt__p_unsigned_int,
32547 _swigt__p_unsigned_char,
32548 _swigt__p_wxChar,
32549 _swigt__p_wxBusyInfo,
32550 _swigt__p_wxPyDropTarget,
32551 _swigt__p_wxPyTextDropTarget,
32552 _swigt__p_wxPyFileDropTarget,
32553 _swigt__p_wxProcessEvent,
32554 _swigt__p_wxPyLog,
32555 _swigt__p_wxLogNull,
32556 _swigt__p_wxColour,
32557 _swigt__p_wxPyTimer,
32558 _swigt__p_wxConfigPathChanger,
32559 _swigt__p_wxDateSpan,
32560 0
32561 };
32562
32563
32564 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32565
32566 static swig_const_info swig_const_table[] = {
32567 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32568 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32569 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32570 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32571 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32572 {0, 0, 0, 0.0, 0, 0}};
32573
32574 #ifdef __cplusplus
32575 }
32576 #endif
32577
32578
32579 #ifdef __cplusplus
32580 extern "C" {
32581 #endif
32582
32583 /* Python-specific SWIG API */
32584 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32585 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32586 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32587
32588 /* -----------------------------------------------------------------------------
32589 * global variable support code.
32590 * ----------------------------------------------------------------------------- */
32591
32592 typedef struct swig_globalvar {
32593 char *name; /* Name of global variable */
32594 PyObject *(*get_attr)(); /* Return the current value */
32595 int (*set_attr)(PyObject *); /* Set the value */
32596 struct swig_globalvar *next;
32597 } swig_globalvar;
32598
32599 typedef struct swig_varlinkobject {
32600 PyObject_HEAD
32601 swig_globalvar *vars;
32602 } swig_varlinkobject;
32603
32604 static PyObject *
32605 swig_varlink_repr(swig_varlinkobject *v) {
32606 v = v;
32607 return PyString_FromString("<Swig global variables>");
32608 }
32609
32610 static int
32611 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32612 swig_globalvar *var;
32613 flags = flags;
32614 fprintf(fp,"Swig global variables { ");
32615 for (var = v->vars; var; var=var->next) {
32616 fprintf(fp,"%s", var->name);
32617 if (var->next) fprintf(fp,", ");
32618 }
32619 fprintf(fp," }\n");
32620 return 0;
32621 }
32622
32623 static PyObject *
32624 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32625 swig_globalvar *var = v->vars;
32626 while (var) {
32627 if (strcmp(var->name,n) == 0) {
32628 return (*var->get_attr)();
32629 }
32630 var = var->next;
32631 }
32632 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32633 return NULL;
32634 }
32635
32636 static int
32637 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32638 swig_globalvar *var = v->vars;
32639 while (var) {
32640 if (strcmp(var->name,n) == 0) {
32641 return (*var->set_attr)(p);
32642 }
32643 var = var->next;
32644 }
32645 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32646 return 1;
32647 }
32648
32649 static PyTypeObject varlinktype = {
32650 PyObject_HEAD_INIT(0)
32651 0, /* Number of items in variable part (ob_size) */
32652 (char *)"swigvarlink", /* Type name (tp_name) */
32653 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32654 0, /* Itemsize (tp_itemsize) */
32655 0, /* Deallocator (tp_dealloc) */
32656 (printfunc) swig_varlink_print, /* Print (tp_print) */
32657 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32658 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32659 0, /* tp_compare */
32660 (reprfunc) swig_varlink_repr, /* tp_repr */
32661 0, /* tp_as_number */
32662 0, /* tp_as_sequence */
32663 0, /* tp_as_mapping */
32664 0, /* tp_hash */
32665 0, /* tp_call */
32666 0, /* tp_str */
32667 0, /* tp_getattro */
32668 0, /* tp_setattro */
32669 0, /* tp_as_buffer */
32670 0, /* tp_flags */
32671 0, /* tp_doc */
32672 #if PY_VERSION_HEX >= 0x02000000
32673 0, /* tp_traverse */
32674 0, /* tp_clear */
32675 #endif
32676 #if PY_VERSION_HEX >= 0x02010000
32677 0, /* tp_richcompare */
32678 0, /* tp_weaklistoffset */
32679 #endif
32680 #if PY_VERSION_HEX >= 0x02020000
32681 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32682 #endif
32683 #if PY_VERSION_HEX >= 0x02030000
32684 0, /* tp_del */
32685 #endif
32686 #ifdef COUNT_ALLOCS
32687 0,0,0,0 /* tp_alloc -> tp_next */
32688 #endif
32689 };
32690
32691 /* Create a variable linking object for use later */
32692 static PyObject *
32693 SWIG_Python_newvarlink(void) {
32694 swig_varlinkobject *result = 0;
32695 result = PyMem_NEW(swig_varlinkobject,1);
32696 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32697 result->ob_type = &varlinktype;
32698 result->vars = 0;
32699 result->ob_refcnt = 0;
32700 Py_XINCREF((PyObject *) result);
32701 return ((PyObject*) result);
32702 }
32703
32704 static void
32705 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32706 swig_varlinkobject *v;
32707 swig_globalvar *gv;
32708 v= (swig_varlinkobject *) p;
32709 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32710 gv->name = (char *) malloc(strlen(name)+1);
32711 strcpy(gv->name,name);
32712 gv->get_attr = get_attr;
32713 gv->set_attr = set_attr;
32714 gv->next = v->vars;
32715 v->vars = gv;
32716 }
32717
32718 /* -----------------------------------------------------------------------------
32719 * constants/methods manipulation
32720 * ----------------------------------------------------------------------------- */
32721
32722 /* Install Constants */
32723 static void
32724 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32725 PyObject *obj = 0;
32726 size_t i;
32727 for (i = 0; constants[i].type; i++) {
32728 switch(constants[i].type) {
32729 case SWIG_PY_INT:
32730 obj = PyInt_FromLong(constants[i].lvalue);
32731 break;
32732 case SWIG_PY_FLOAT:
32733 obj = PyFloat_FromDouble(constants[i].dvalue);
32734 break;
32735 case SWIG_PY_STRING:
32736 if (constants[i].pvalue) {
32737 obj = PyString_FromString((char *) constants[i].pvalue);
32738 } else {
32739 Py_INCREF(Py_None);
32740 obj = Py_None;
32741 }
32742 break;
32743 case SWIG_PY_POINTER:
32744 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32745 break;
32746 case SWIG_PY_BINARY:
32747 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32748 break;
32749 default:
32750 obj = 0;
32751 break;
32752 }
32753 if (obj) {
32754 PyDict_SetItemString(d,constants[i].name,obj);
32755 Py_DECREF(obj);
32756 }
32757 }
32758 }
32759
32760 /* -----------------------------------------------------------------------------*/
32761 /* Fix SwigMethods to carry the callback ptrs when needed */
32762 /* -----------------------------------------------------------------------------*/
32763
32764 static void
32765 SWIG_Python_FixMethods(PyMethodDef *methods,
32766 swig_const_info *const_table,
32767 swig_type_info **types,
32768 swig_type_info **types_initial) {
32769 size_t i;
32770 for (i = 0; methods[i].ml_name; ++i) {
32771 char *c = methods[i].ml_doc;
32772 if (c && (c = strstr(c, "swig_ptr: "))) {
32773 int j;
32774 swig_const_info *ci = 0;
32775 char *name = c + 10;
32776 for (j = 0; const_table[j].type; j++) {
32777 if (strncmp(const_table[j].name, name,
32778 strlen(const_table[j].name)) == 0) {
32779 ci = &(const_table[j]);
32780 break;
32781 }
32782 }
32783 if (ci) {
32784 size_t shift = (ci->ptype) - types;
32785 swig_type_info *ty = types_initial[shift];
32786 size_t ldoc = (c - methods[i].ml_doc);
32787 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32788 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32789 char *buff = ndoc;
32790 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32791 strncpy(buff, methods[i].ml_doc, ldoc);
32792 buff += ldoc;
32793 strncpy(buff, "swig_ptr: ", 10);
32794 buff += 10;
32795 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32796 methods[i].ml_doc = ndoc;
32797 }
32798 }
32799 }
32800 }
32801
32802 /* -----------------------------------------------------------------------------*
32803 * Initialize type list
32804 * -----------------------------------------------------------------------------*/
32805
32806 #if PY_MAJOR_VERSION < 2
32807 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32808 is copied out of Python/modsupport.c in python version 2.3.4 */
32809 static int
32810 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32811 {
32812 PyObject *dict;
32813 if (!PyModule_Check(m)) {
32814 PyErr_SetString(PyExc_TypeError,
32815 "PyModule_AddObject() needs module as first arg");
32816 return -1;
32817 }
32818 if (!o) {
32819 PyErr_SetString(PyExc_TypeError,
32820 "PyModule_AddObject() needs non-NULL value");
32821 return -1;
32822 }
32823
32824 dict = PyModule_GetDict(m);
32825 if (dict == NULL) {
32826 /* Internal error -- modules must have a dict! */
32827 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32828 PyModule_GetName(m));
32829 return -1;
32830 }
32831 if (PyDict_SetItemString(dict, name, o))
32832 return -1;
32833 Py_DECREF(o);
32834 return 0;
32835 }
32836 #endif
32837
32838 static swig_type_info **
32839 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32840 static PyMethodDef swig_empty_runtime_method_table[] = {
32841 {
32842 NULL, NULL, 0, NULL
32843 }
32844 };/* Sentinel */
32845
32846 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32847 swig_empty_runtime_method_table);
32848 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32849 if (pointer && module) {
32850 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32851 }
32852 return type_list_handle;
32853 }
32854
32855 static swig_type_info **
32856 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32857 swig_type_info **type_pointer;
32858
32859 /* first check if module already created */
32860 type_pointer = SWIG_Python_GetTypeListHandle();
32861 if (type_pointer) {
32862 return type_pointer;
32863 } else {
32864 /* create a new module and variable */
32865 return SWIG_Python_SetTypeListHandle(type_list_handle);
32866 }
32867 }
32868
32869 #ifdef __cplusplus
32870 }
32871 #endif
32872
32873 /* -----------------------------------------------------------------------------*
32874 * Partial Init method
32875 * -----------------------------------------------------------------------------*/
32876
32877 #ifdef SWIG_LINK_RUNTIME
32878 #ifdef __cplusplus
32879 extern "C"
32880 #endif
32881 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32882 #endif
32883
32884 #ifdef __cplusplus
32885 extern "C"
32886 #endif
32887 SWIGEXPORT(void) SWIG_init(void) {
32888 static PyObject *SWIG_globals = 0;
32889 static int typeinit = 0;
32890 PyObject *m, *d;
32891 int i;
32892 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
32893
32894 /* Fix SwigMethods to carry the callback ptrs when needed */
32895 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
32896
32897 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32898 d = PyModule_GetDict(m);
32899
32900 if (!typeinit) {
32901 #ifdef SWIG_LINK_RUNTIME
32902 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
32903 #else
32904 # ifndef SWIG_STATIC_RUNTIME
32905 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
32906 # endif
32907 #endif
32908 for (i = 0; swig_types_initial[i]; i++) {
32909 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
32910 }
32911 typeinit = 1;
32912 }
32913 SWIG_InstallConstants(d,swig_const_table);
32914
32915 {
32916 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
32917 }
32918 {
32919 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
32920 }
32921 {
32922 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
32923 }
32924 {
32925 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
32926 }
32927 {
32928 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
32929 }
32930 {
32931 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
32932 }
32933 {
32934 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
32935 }
32936 {
32937 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
32938 }
32939 {
32940 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
32941 }
32942 {
32943 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
32944 }
32945 {
32946 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
32947 }
32948 {
32949 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
32950 }
32951 {
32952 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
32953 }
32954 {
32955 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
32956 }
32957 {
32958 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
32959 }
32960 {
32961 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
32962 }
32963 {
32964 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
32965 }
32966 {
32967 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
32968 }
32969 {
32970 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
32971 }
32972 {
32973 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
32974 }
32975 {
32976 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
32977 }
32978 {
32979 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
32980 }
32981 {
32982 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
32983 }
32984 {
32985 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
32986 }
32987 {
32988 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
32989 }
32990 {
32991 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
32992 }
32993 {
32994 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
32995 }
32996 {
32997 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
32998 }
32999 {
33000 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33001 }
33002 {
33003 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33004 }
33005 {
33006 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33007 }
33008 {
33009 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33010 }
33011 {
33012 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33013 }
33014 {
33015 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33016 }
33017 {
33018 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33019 }
33020 {
33021 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33022 }
33023 {
33024 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33025 }
33026 {
33027 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33028 }
33029 {
33030 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33031 }
33032 {
33033 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33034 }
33035 {
33036 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33037 }
33038 {
33039 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33040 }
33041 {
33042 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33043 }
33044 {
33045 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33046 }
33047 {
33048 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33049 }
33050 {
33051 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33052 }
33053 {
33054 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33055 }
33056 {
33057 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33058 }
33059 {
33060 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33061 }
33062 {
33063 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33064 }
33065 {
33066 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33067 }
33068 {
33069 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33070 }
33071 {
33072 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33073 }
33074 {
33075 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33076 }
33077 {
33078 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33079 }
33080 {
33081 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33082 }
33083 {
33084 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33085 }
33086 {
33087 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33088 }
33089 {
33090 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33091 }
33092 {
33093 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33094 }
33095 {
33096 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33097 }
33098 {
33099 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33100 }
33101 {
33102 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33103 }
33104 {
33105 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33106 }
33107 {
33108 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33109 }
33110 {
33111 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33112 }
33113 {
33114 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33115 }
33116 {
33117 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33118 }
33119 {
33120 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33121 }
33122 {
33123 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33124 }
33125 {
33126 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33127 }
33128 {
33129 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33130 }
33131 {
33132 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33133 }
33134 {
33135 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33136 }
33137 {
33138 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33139 }
33140 {
33141 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33142 }
33143 {
33144 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33145 }
33146 {
33147 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33148 }
33149 {
33150 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33151 }
33152 {
33153 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33154 }
33155 {
33156 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33157 }
33158 {
33159 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33160 }
33161 {
33162 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33163 }
33164 {
33165 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33166 }
33167 {
33168 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33169 }
33170 {
33171 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33172 }
33173 {
33174 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33175 }
33176 {
33177 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33178 }
33179 {
33180 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33181 }
33182 {
33183 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33184 }
33185 {
33186 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33187 }
33188 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33189 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33190 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33191 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33192 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33193 {
33194 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33195 }
33196 {
33197 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33198 }
33199 {
33200 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33201 }
33202 {
33203 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33204 }
33205 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33206
33207 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33208
33209 {
33210 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33211 }
33212 {
33213 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33214 }
33215 {
33216 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33217 }
33218 {
33219 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33232 }
33233 {
33234 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33235 }
33236 {
33237 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33241 }
33242 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33243 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33244 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33245 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33246 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33247 {
33248 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33249 }
33250 {
33251 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33252 }
33253 {
33254 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33255 }
33256 {
33257 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33258 }
33259 {
33260 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33261 }
33262 {
33263 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33264 }
33265 {
33266 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33267 }
33268 {
33269 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33270 }
33271 {
33272 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33273 }
33274 {
33275 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33276 }
33277 {
33278 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33279 }
33280 {
33281 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33282 }
33283 {
33284 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33285 }
33286 {
33287 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33288 }
33289 {
33290 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33291 }
33292 {
33293 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33294 }
33295 {
33296 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33297 }
33298 {
33299 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33300 }
33301 {
33302 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33303 }
33304 {
33305 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33306 }
33307 {
33308 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33309 }
33310 {
33311 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33312 }
33313 {
33314 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33315 }
33316 {
33317 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33318 }
33319 {
33320 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33321 }
33322 {
33323 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33324 }
33325 {
33326 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33327 }
33328 {
33329 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33330 }
33331 {
33332 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33333 }
33334 {
33335 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33336 }
33337 {
33338 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33339 }
33340 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33341 {
33342 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33349 }
33350 {
33351 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33352 }
33353 {
33354 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33355 }
33356
33357 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33358
33359 {
33360 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33379 }
33380 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33381 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33382 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33383 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33384 {
33385 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33386 }
33387 {
33388 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33389 }
33390 {
33391 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33392 }
33393 {
33394 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33407 }
33408 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33409 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33410 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33411 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33412 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33413 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33414 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33415 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33416 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33417 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33418 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33419 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33420 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33421 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33422 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33423 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33424 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33425 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33426 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33427 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33428 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33429 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33430 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33431 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33432 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33433 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33434 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33435 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33436 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33437 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33438 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33439 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33440 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33441 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33442 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33443 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33444 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33445 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33446 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33447 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33448 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33449 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33450 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33451 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33452 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33453
33454 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33455
33456 {
33457 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33482 }
33483 SWIG_addvarlink(SWIG_globals,(char*)"DateFormatStr",_wrap_DateFormatStr_get, _wrap_DateFormatStr_set);
33484 SWIG_addvarlink(SWIG_globals,(char*)"TimeSpanFormatStr",_wrap_TimeSpanFormatStr_get, _wrap_TimeSpanFormatStr_set);
33485 {
33486 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33856 }
33857 {
33858 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33859 }
33860 {
33861 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33862 }
33863 {
33864 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33865 }
33866 {
33867 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33868 }
33869 {
33870 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33877 }
33878 {
33879 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33880 }
33881 {
33882 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
33883 }
33884 {
33885 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
33886 }
33887 {
33888 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
33892 }
33893 {
33894 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
33895 }
33896 {
33897 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
33898 }
33899 {
33900 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
33901 }
33902 {
33903 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
33904 }
33905 {
33906 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
33907 }
33908 {
33909 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
33910 }
33911 {
33912 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
33913 }
33914 {
33915 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
33916 }
33917 {
33918 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
33919 }
33920 {
33921 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
33937 }
33938 {
33939 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
33940 }
33941 {
33942 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
33943 }
33944 {
33945 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
33946 }
33947 {
33948 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
33949 }
33950 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
33951 {
33952 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
33974 }
33975 {
33976 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
33977 }
33978 {
33979 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
33980 }
33981 {
33982 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34010 }
34011 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34012 {
34013 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34047 }
34048
34049 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34050 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34051 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34052 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34053
34054 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34055 }
34056
wxWidgets (Impactor)