]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fixed bug in Set() on DST days (patch 1097811)
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1364 #define SWIGTYPE_p_wxIcon swig_types[23]
1365 #define SWIGTYPE_p_wxLogStderr swig_types[24]
1366 #define SWIGTYPE_p_wxLogTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxBusyCursor swig_types[27]
1369 #define SWIGTYPE_p_wxBitmapDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxTextDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyTextDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxFileDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxURLDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxMetafileDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxSound swig_types[37]
1379 #define SWIGTYPE_p_wxTimerRunner swig_types[38]
1380 #define SWIGTYPE_p_wxLogWindow swig_types[39]
1381 #define SWIGTYPE_p_wxTimeSpan swig_types[40]
1382 #define SWIGTYPE_p_wxArrayString swig_types[41]
1383 #define SWIGTYPE_p_wxWindowDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxToolTip swig_types[44]
1386 #define SWIGTYPE_p_wxDataObjectComposite swig_types[45]
1387 #define SWIGTYPE_p_wxFileConfig swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxVideoMode swig_types[48]
1390 #define SWIGTYPE_p_wxDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxDuplexMode swig_types[51]
1393 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
1394 #define SWIGTYPE_p_wxRect swig_types[53]
1395 #define SWIGTYPE_p_char swig_types[54]
1396 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[55]
1397 #define SWIGTYPE_p_wxStandardPaths swig_types[56]
1398 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
1399 #define SWIGTYPE_p_wxFrame swig_types[58]
1400 #define SWIGTYPE_p_wxTimer swig_types[59]
1401 #define SWIGTYPE_p_wxPaperSize swig_types[60]
1402 #define SWIGTYPE_p_wxMimeTypesManager swig_types[61]
1403 #define SWIGTYPE_p_wxPyArtProvider swig_types[62]
1404 #define SWIGTYPE_p_wxPyTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxJoystick swig_types[65]
1407 #define SWIGTYPE_p_wxSystemOptions swig_types[66]
1408 #define SWIGTYPE_p_wxPoint swig_types[67]
1409 #define SWIGTYPE_p_wxJoystickEvent swig_types[68]
1410 #define SWIGTYPE_p_wxCursor swig_types[69]
1411 #define SWIGTYPE_p_wxObject swig_types[70]
1412 #define SWIGTYPE_p_wxOutputStream swig_types[71]
1413 #define SWIGTYPE_p_wxDateTime swig_types[72]
1414 #define SWIGTYPE_p_wxPyDropSource swig_types[73]
1415 #define SWIGTYPE_p_unsigned_long swig_types[74]
1416 #define SWIGTYPE_p_wxKillError swig_types[75]
1417 #define SWIGTYPE_p_wxWindow swig_types[76]
1418 #define SWIGTYPE_p_wxString swig_types[77]
1419 #define SWIGTYPE_p_wxPyProcess swig_types[78]
1420 #define SWIGTYPE_p_wxBitmap swig_types[79]
1421 #define SWIGTYPE_p_wxConfig swig_types[80]
1422 #define SWIGTYPE_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_char swig_types[83]
1425 #define SWIGTYPE_p_wxChar swig_types[84]
1426 #define SWIGTYPE_p_wxBusyInfo swig_types[85]
1427 #define SWIGTYPE_p_wxPyDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxProcessEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPyLog swig_types[90]
1432 #define SWIGTYPE_p_wxLogNull swig_types[91]
1433 #define SWIGTYPE_p_wxColour swig_types[92]
1434 #define SWIGTYPE_p_wxPyTimer swig_types[93]
1435 #define SWIGTYPE_p_wxConfigPathChanger swig_types[94]
1436 #define SWIGTYPE_p_wxDateSpan swig_types[95]
1437 static swig_type_info *swig_types[97];
1438
1439 /* -------- TYPES TABLE (END) -------- */
1440
1441
1442 /*-----------------------------------------------
1443 @(target):= _misc_.so
1444 ------------------------------------------------*/
1445 #define SWIG_init init_misc_
1446
1447 #define SWIG_name "_misc_"
1448
1449 #include "wx/wxPython/wxPython.h"
1450 #include "wx/wxPython/pyclasses.h"
1451 #include "wx/wxPython/pyistream.h"
1452
1453 static const wxString wxPyEmptyString(wxEmptyString);
1454
1455
1456
1457 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1458 #define SWIG_From_int PyInt_FromLong
1459 /*@@*/
1460
1461
1462 #include <limits.h>
1463
1464
1465 SWIGINTERN int
1466 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1467 const char *errmsg)
1468 {
1469 if (value < min_value) {
1470 if (errmsg) {
1471 PyErr_Format(PyExc_OverflowError,
1472 "value %ld is less than '%s' minimum %ld",
1473 value, errmsg, min_value);
1474 }
1475 return 0;
1476 } else if (value > max_value) {
1477 if (errmsg) {
1478 PyErr_Format(PyExc_OverflowError,
1479 "value %ld is greater than '%s' maximum %ld",
1480 value, errmsg, max_value);
1481 }
1482 return 0;
1483 }
1484 return 1;
1485 }
1486
1487
1488 SWIGINTERN int
1489 SWIG_AsVal_long(PyObject* obj, long* val)
1490 {
1491 if (PyNumber_Check(obj)) {
1492 if (val) *val = PyInt_AsLong(obj);
1493 return 1;
1494 }
1495 else {
1496 SWIG_type_error("number", obj);
1497 }
1498 return 0;
1499 }
1500
1501
1502 #if INT_MAX != LONG_MAX
1503 SWIGINTERN int
1504 SWIG_AsVal_int(PyObject *obj, int *val)
1505 {
1506 const char* errmsg = val ? "int" : (char*)0;
1507 long v;
1508 if (SWIG_AsVal_long(obj, &v)) {
1509 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1510 if (val) *val = (int)(v);
1511 return 1;
1512 } else {
1513 return 0;
1514 }
1515 } else {
1516 PyErr_Clear();
1517 }
1518 if (val) {
1519 SWIG_type_error(errmsg, obj);
1520 }
1521 return 0;
1522 }
1523 #else
1524 SWIGINTERNSHORT int
1525 SWIG_AsVal_int(PyObject *obj, int *val)
1526 {
1527 return SWIG_AsVal_long(obj,(long*)val);
1528 }
1529 #endif
1530
1531
1532 SWIGINTERNSHORT int
1533 SWIG_As_int(PyObject* obj)
1534 {
1535 int v;
1536 if (!SWIG_AsVal_int(obj, &v)) {
1537 /*
1538 this is needed to make valgrind/purify happier.
1539 */
1540 memset((void*)&v, 0, sizeof(int));
1541 }
1542 return v;
1543 }
1544
1545
1546 SWIGINTERNSHORT int
1547 SWIG_Check_int(PyObject* obj)
1548 {
1549 return SWIG_AsVal_int(obj, (int*)0);
1550 }
1551
1552 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1553
1554 #include <wx/stockitem.h>
1555
1556 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1557 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1558 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1559
1560 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1561 #define SWIG_From_long PyInt_FromLong
1562 /*@@*/
1563
1564
1565 SWIGINTERNSHORT long
1566 SWIG_As_long(PyObject* obj)
1567 {
1568 long v;
1569 if (!SWIG_AsVal_long(obj, &v)) {
1570 /*
1571 this is needed to make valgrind/purify happier.
1572 */
1573 memset((void*)&v, 0, sizeof(long));
1574 }
1575 return v;
1576 }
1577
1578
1579 SWIGINTERNSHORT int
1580 SWIG_Check_long(PyObject* obj)
1581 {
1582 return SWIG_AsVal_long(obj, (long*)0);
1583 }
1584
1585
1586 SWIGINTERN int
1587 SWIG_AsVal_bool(PyObject *obj, bool *val)
1588 {
1589 if (obj == Py_True) {
1590 if (val) *val = true;
1591 return 1;
1592 }
1593 if (obj == Py_False) {
1594 if (val) *val = false;
1595 return 1;
1596 }
1597 int res = 0;
1598 if (SWIG_AsVal_int(obj, &res)) {
1599 if (val) *val = res ? true : false;
1600 return 1;
1601 } else {
1602 PyErr_Clear();
1603 }
1604 if (val) {
1605 SWIG_type_error("bool", obj);
1606 }
1607 return 0;
1608 }
1609
1610
1611 SWIGINTERNSHORT bool
1612 SWIG_As_bool(PyObject* obj)
1613 {
1614 bool v;
1615 if (!SWIG_AsVal_bool(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(bool));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_bool(PyObject* obj)
1627 {
1628 return SWIG_AsVal_bool(obj, (bool*)0);
1629 }
1630
1631
1632 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1633 PyObject* o2;
1634 PyObject* o3;
1635
1636 if (!target) {
1637 target = o;
1638 } else if (target == Py_None) {
1639 Py_DECREF(Py_None);
1640 target = o;
1641 } else {
1642 if (!PyTuple_Check(target)) {
1643 o2 = target;
1644 target = PyTuple_New(1);
1645 PyTuple_SetItem(target, 0, o2);
1646 }
1647 o3 = PyTuple_New(1);
1648 PyTuple_SetItem(o3, 0, o);
1649
1650 o2 = target;
1651 target = PySequence_Concat(o2, o3);
1652 Py_DECREF(o2);
1653 Py_DECREF(o3);
1654 }
1655 return target;
1656 }
1657
1658
1659
1660 SWIGINTERN int
1661 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1662 {
1663 long v = 0;
1664 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1665 SWIG_type_error("unsigned number", obj);
1666 }
1667 else if (val)
1668 *val = (unsigned long)v;
1669 return 1;
1670 }
1671
1672
1673 SWIGINTERNSHORT unsigned long
1674 SWIG_As_unsigned_SS_long(PyObject* obj)
1675 {
1676 unsigned long v;
1677 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1678 /*
1679 this is needed to make valgrind/purify happier.
1680 */
1681 memset((void*)&v, 0, sizeof(unsigned long));
1682 }
1683 return v;
1684 }
1685
1686
1687 SWIGINTERNSHORT int
1688 SWIG_Check_unsigned_SS_long(PyObject* obj)
1689 {
1690 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1691 }
1692
1693
1694 SWIGINTERNSHORT PyObject*
1695 SWIG_From_unsigned_SS_long(unsigned long value)
1696 {
1697 return (value > LONG_MAX) ?
1698 PyLong_FromUnsignedLong(value)
1699 : PyInt_FromLong((long)(value));
1700 }
1701
1702
1703 bool wxThread_IsMain() {
1704 #ifdef WXP_WITH_THREAD
1705 return wxThread::IsMain();
1706 #else
1707 return true;
1708 #endif
1709 }
1710
1711
1712 int wxCaret_GetBlinkTime() {
1713 return wxCaret::GetBlinkTime();
1714 }
1715
1716 void wxCaret_SetBlinkTime(int milliseconds) {
1717 wxCaret::SetBlinkTime(milliseconds);
1718 }
1719
1720
1721 #include <wx/snglinst.h>
1722
1723
1724 #include <wx/tipdlg.h>
1725
1726
1727 class wxPyTipProvider : public wxTipProvider {
1728 public:
1729 wxPyTipProvider(size_t currentTip)
1730 : wxTipProvider(currentTip) {}
1731
1732 DEC_PYCALLBACK_STRING__pure(GetTip);
1733 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1734 PYPRIVATE;
1735 };
1736
1737 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1738 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1739
1740
1741 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1742
1743 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1744
1745 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1746 : wxTimer(owner, id)
1747 {
1748 if (owner == NULL) SetOwner(this);
1749 }
1750
1751
1752 void wxPyTimer::Notify() {
1753 bool found;
1754 bool blocked = wxPyBeginBlockThreads();
1755 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1756 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1757 wxPyEndBlockThreads(blocked);
1758 if (! found)
1759 wxTimer::Notify();
1760 }
1761 void wxPyTimer::base_Notify() {
1762 wxTimer::Notify();
1763 }
1764
1765
1766
1767 SWIGINTERN PyObject *
1768 SWIG_FromCharPtr(const char* cptr)
1769 {
1770 if (cptr) {
1771 size_t size = strlen(cptr);
1772 if (size > INT_MAX) {
1773 return SWIG_NewPointerObj((char*)(cptr),
1774 SWIG_TypeQuery("char *"), 0);
1775 } else {
1776 if (size != 0) {
1777 return PyString_FromStringAndSize(cptr, size);
1778 } else {
1779 return PyString_FromString(cptr);
1780 }
1781 }
1782 }
1783 Py_INCREF(Py_None);
1784 return Py_None;
1785 }
1786
1787
1788 SWIGINTERNSHORT int
1789 SWIG_CheckUnsignedLongInRange(unsigned long value,
1790 unsigned long max_value,
1791 const char *errmsg)
1792 {
1793 if (value > max_value) {
1794 if (errmsg) {
1795 PyErr_Format(PyExc_OverflowError,
1796 "value %lu is greater than '%s' minimum %lu",
1797 value, errmsg, max_value);
1798 }
1799 return 0;
1800 }
1801 return 1;
1802 }
1803
1804
1805 #if UINT_MAX != ULONG_MAX
1806 SWIGINTERN int
1807 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1808 {
1809 const char* errmsg = val ? "unsigned int" : (char*)0;
1810 unsigned long v;
1811 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1812 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1813 if (val) *val = (unsigned int)(v);
1814 return 1;
1815 }
1816 } else {
1817 PyErr_Clear();
1818 }
1819 if (val) {
1820 SWIG_type_error(errmsg, obj);
1821 }
1822 return 0;
1823 }
1824 #else
1825 SWIGINTERNSHORT unsigned int
1826 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1827 {
1828 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1829 }
1830 #endif
1831
1832
1833 SWIGINTERNSHORT unsigned int
1834 SWIG_As_unsigned_SS_int(PyObject* obj)
1835 {
1836 unsigned int v;
1837 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1838 /*
1839 this is needed to make valgrind/purify happier.
1840 */
1841 memset((void*)&v, 0, sizeof(unsigned int));
1842 }
1843 return v;
1844 }
1845
1846
1847 SWIGINTERNSHORT int
1848 SWIG_Check_unsigned_SS_int(PyObject* obj)
1849 {
1850 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1851 }
1852
1853 static wxString Log_TimeStamp(){
1854 wxString msg;
1855 wxLog::TimeStamp(&msg);
1856 return msg;
1857 }
1858 static void wxLog_Destroy(wxLog *self){ delete self; }
1859 // Make somce wrappers that double any % signs so they are 'escaped'
1860 void wxPyLogFatalError(const wxString& msg)
1861 {
1862 wxString m(msg);
1863 m.Replace(wxT("%"), wxT("%%"));
1864 wxLogFatalError(m);
1865 }
1866
1867 void wxPyLogError(const wxString& msg)
1868 {
1869 wxString m(msg);
1870 m.Replace(wxT("%"), wxT("%%"));
1871 wxLogError(m);
1872 }
1873
1874 void wxPyLogWarning(const wxString& msg)
1875 {
1876 wxString m(msg);
1877 m.Replace(wxT("%"), wxT("%%"));
1878 wxLogWarning(m);
1879 }
1880
1881 void wxPyLogMessage(const wxString& msg)
1882 {
1883 wxString m(msg);
1884 m.Replace(wxT("%"), wxT("%%"));
1885 wxLogMessage(m);
1886 }
1887
1888 void wxPyLogInfo(const wxString& msg)
1889 {
1890 wxString m(msg);
1891 m.Replace(wxT("%"), wxT("%%"));
1892 wxLogInfo(m);
1893 }
1894
1895 void wxPyLogDebug(const wxString& msg)
1896 {
1897 wxString m(msg);
1898 m.Replace(wxT("%"), wxT("%%"));
1899 wxLogDebug(m);
1900 }
1901
1902 void wxPyLogVerbose(const wxString& msg)
1903 {
1904 wxString m(msg);
1905 m.Replace(wxT("%"), wxT("%%"));
1906 wxLogVerbose(m);
1907 }
1908
1909 void wxPyLogStatus(const wxString& msg)
1910 {
1911 wxString m(msg);
1912 m.Replace(wxT("%"), wxT("%%"));
1913 wxLogStatus(m);
1914 }
1915
1916 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1917 {
1918 wxString m(msg);
1919 m.Replace(wxT("%"), wxT("%%"));
1920 wxLogStatus(pFrame, m);
1921 }
1922
1923 void wxPyLogSysError(const wxString& msg)
1924 {
1925 wxString m(msg);
1926 m.Replace(wxT("%"), wxT("%%"));
1927 wxLogSysError(m);
1928 }
1929
1930 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1931 {
1932 wxString m(msg);
1933 m.Replace(wxT("%"), wxT("%%"));
1934 wxLogGeneric(level, m);
1935 }
1936
1937 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1938 {
1939 wxString m(msg);
1940 m.Replace(wxT("%"), wxT("%%"));
1941 wxLogTrace(mask, m);
1942 }
1943
1944 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1945 {
1946 wxString m(msg);
1947 m.Replace(wxT("%"), wxT("%%"));
1948 wxLogTrace(mask, m);
1949 }
1950
1951
1952
1953 // A wxLog class that can be derived from in wxPython
1954 class wxPyLog : public wxLog {
1955 public:
1956 wxPyLog() : wxLog() {}
1957
1958 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1959 bool found;
1960 bool blocked = wxPyBeginBlockThreads();
1961 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1962 PyObject* s = wx2PyString(szString);
1963 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1964 Py_DECREF(s);
1965 }
1966 wxPyEndBlockThreads(blocked);
1967 if (! found)
1968 wxLog::DoLog(level, szString, t);
1969 }
1970
1971 virtual void DoLogString(const wxChar *szString, time_t t) {
1972 bool found;
1973 bool blocked = wxPyBeginBlockThreads();
1974 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1975 PyObject* s = wx2PyString(szString);
1976 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1977 Py_DECREF(s);
1978 }
1979 wxPyEndBlockThreads(blocked);
1980 if (! found)
1981 wxLog::DoLogString(szString, t);
1982 }
1983
1984 PYPRIVATE;
1985 };
1986
1987
1988
1989
1990 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1991
1992
1993 #include <wx/joystick.h>
1994
1995
1996 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
1997 // A C++ stub class for wxJoystick for platforms that don't have it.
1998 class wxJoystick : public wxObject {
1999 public:
2000 wxJoystick(int joystick = wxJOYSTICK1) {
2001 bool blocked = wxPyBeginBlockThreads();
2002 PyErr_SetString(PyExc_NotImplementedError,
2003 "wxJoystick is not available on this platform.");
2004 wxPyEndBlockThreads(blocked);
2005 }
2006 wxPoint GetPosition() { return wxPoint(-1,-1); }
2007 int GetZPosition() { return -1; }
2008 int GetButtonState() { return -1; }
2009 int GetPOVPosition() { return -1; }
2010 int GetPOVCTSPosition() { return -1; }
2011 int GetRudderPosition() { return -1; }
2012 int GetUPosition() { return -1; }
2013 int GetVPosition() { return -1; }
2014 int GetMovementThreshold() { return -1; }
2015 void SetMovementThreshold(int threshold) {}
2016
2017 bool IsOk(void) { return false; }
2018 int GetNumberJoysticks() { return -1; }
2019 int GetManufacturerId() { return -1; }
2020 int GetProductId() { return -1; }
2021 wxString GetProductName() { return wxEmptyString; }
2022 int GetXMin() { return -1; }
2023 int GetYMin() { return -1; }
2024 int GetZMin() { return -1; }
2025 int GetXMax() { return -1; }
2026 int GetYMax() { return -1; }
2027 int GetZMax() { return -1; }
2028 int GetNumberButtons() { return -1; }
2029 int GetNumberAxes() { return -1; }
2030 int GetMaxButtons() { return -1; }
2031 int GetMaxAxes() { return -1; }
2032 int GetPollingMin() { return -1; }
2033 int GetPollingMax() { return -1; }
2034 int GetRudderMin() { return -1; }
2035 int GetRudderMax() { return -1; }
2036 int GetUMin() { return -1; }
2037 int GetUMax() { return -1; }
2038 int GetVMin() { return -1; }
2039 int GetVMax() { return -1; }
2040
2041 bool HasRudder() { return false; }
2042 bool HasZ() { return false; }
2043 bool HasU() { return false; }
2044 bool HasV() { return false; }
2045 bool HasPOV() { return false; }
2046 bool HasPOV4Dir() { return false; }
2047 bool HasPOVCTS() { return false; }
2048
2049 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2050 bool ReleaseCapture() { return false; }
2051 };
2052 #endif
2053
2054
2055 #include <wx/sound.h>
2056
2057
2058 #if !wxUSE_SOUND
2059 // A C++ stub class for wxWave for platforms that don't have it.
2060 class wxSound : public wxObject
2061 {
2062 public:
2063 wxSound() {
2064 bool blocked = wxPyBeginBlockThreads();
2065 PyErr_SetString(PyExc_NotImplementedError,
2066 "wxSound is not available on this platform.");
2067 wxPyEndBlockThreads(blocked);
2068 }
2069 wxSound(const wxString&/*, bool*/) {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075 wxSound(int, const wxByte*) {
2076 bool blocked = wxPyBeginBlockThreads();
2077 PyErr_SetString(PyExc_NotImplementedError,
2078 "wxSound is not available on this platform.");
2079 wxPyEndBlockThreads(blocked);
2080 }
2081
2082 ~wxSound() {};
2083
2084 bool Create(const wxString&/*, bool*/) { return false; }
2085 bool Create(int, const wxByte*) { return false; };
2086 bool IsOk() { return false; };
2087 bool Play(unsigned) const { return false; }
2088 static bool Play(const wxString&, unsigned) { return false; }
2089 static void Stop() {}
2090 };
2091
2092 #endif
2093
2094 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2095 if (fileName.Length() == 0)
2096 return new wxSound;
2097 else
2098 return new wxSound(fileName);
2099 }
2100 static wxSound *new_wxSound(PyObject *data){
2101 unsigned char* buffer; int size;
2102 wxSound *sound = NULL;
2103
2104 bool blocked = wxPyBeginBlockThreads();
2105 if (!PyArg_Parse(data, "t#", &buffer, &size))
2106 goto done;
2107 sound = new wxSound(size, buffer);
2108 done:
2109 wxPyEndBlockThreads(blocked);
2110 return sound;
2111 }
2112 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2113 #ifndef __WXMAC__
2114 unsigned char* buffer;
2115 int size;
2116 bool rv = false;
2117
2118 bool blocked = wxPyBeginBlockThreads();
2119 if (!PyArg_Parse(data, "t#", &buffer, &size))
2120 goto done;
2121 rv = self->Create(size, buffer);
2122 done:
2123 wxPyEndBlockThreads(blocked);
2124 return rv;
2125 #else
2126 bool blocked = wxPyBeginBlockThreads();
2127 PyErr_SetString(PyExc_NotImplementedError,
2128 "Create from data is not available on this platform.");
2129 wxPyEndBlockThreads(blocked);
2130 return false;
2131 #endif
2132 }
2133 static void Sound_Stop(){ wxPyRaiseNotImplemented(); }
2134
2135 #include <wx/mimetype.h>
2136
2137 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2138 wxString str;
2139 if (self->GetMimeType(&str))
2140 return wx2PyString(str);
2141 else
2142 RETURN_NONE();
2143 }
2144 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2145 wxArrayString arr;
2146 if (self->GetMimeTypes(arr))
2147 return wxArrayString2PyList_helper(arr);
2148 else
2149 RETURN_NONE();
2150 }
2151 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2152 wxArrayString arr;
2153 if (self->GetExtensions(arr))
2154 return wxArrayString2PyList_helper(arr);
2155 else
2156 RETURN_NONE();
2157 }
2158 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2159 wxIconLocation loc;
2160 if (self->GetIcon(&loc))
2161 return new wxIcon(loc);
2162 else
2163 return NULL;
2164 }
2165 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2166 wxIconLocation loc;
2167 if (self->GetIcon(&loc)) {
2168 wxString iconFile = loc.GetFileName();
2169 int iconIndex = -1;
2170
2171
2172
2173 // Make a tuple and put the values in it
2174 bool blocked = wxPyBeginBlockThreads();
2175 PyObject* tuple = PyTuple_New(3);
2176 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2177 wxT("wxIcon"), true));
2178 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2179 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2180 wxPyEndBlockThreads(blocked);
2181 return tuple;
2182 }
2183 else
2184 RETURN_NONE();
2185 }
2186 static PyObject *wxFileType_GetDescription(wxFileType *self){
2187 wxString str;
2188 if (self->GetDescription(&str))
2189 return wx2PyString(str);
2190 else
2191 RETURN_NONE();
2192 }
2193 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2194 wxString str;
2195 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2196 return wx2PyString(str);
2197 else
2198 RETURN_NONE();
2199 }
2200 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2201 wxString str;
2202 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2203 return wx2PyString(str);
2204 else
2205 RETURN_NONE();
2206 }
2207 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2208 wxArrayString verbs;
2209 wxArrayString commands;
2210 if (self->GetAllCommands(&verbs, &commands,
2211 wxFileType::MessageParameters(filename, mimetype))) {
2212 bool blocked = wxPyBeginBlockThreads();
2213 PyObject* tuple = PyTuple_New(2);
2214 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2215 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2216 wxPyEndBlockThreads(blocked);
2217 return tuple;
2218 }
2219 else
2220 RETURN_NONE();
2221 }
2222 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2223 return wxFileType::ExpandCommand(command,
2224 wxFileType::MessageParameters(filename, mimetype));
2225 }
2226 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2227 wxArrayString arr;
2228 self->EnumAllFileTypes(arr);
2229 return wxArrayString2PyList_helper(arr);
2230 }
2231
2232 #include <wx/artprov.h>
2233
2234 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2235 static const wxString wxPyART_MENU(wxART_MENU);
2236 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2237 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2238 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2239 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2240 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2241 static const wxString wxPyART_OTHER(wxART_OTHER);
2242 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2243 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2244 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2245 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2246 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2247 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2248 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2249 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2250 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2251 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2252 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2253 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2254 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2255 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2256 static const wxString wxPyART_PRINT(wxART_PRINT);
2257 static const wxString wxPyART_HELP(wxART_HELP);
2258 static const wxString wxPyART_TIP(wxART_TIP);
2259 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2260 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2261 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2262 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2263 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2264 static const wxString wxPyART_CDROM(wxART_CDROM);
2265 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2266 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2267 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2268 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2269 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2270 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2271 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2272 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2273 static const wxString wxPyART_ERROR(wxART_ERROR);
2274 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2275 static const wxString wxPyART_WARNING(wxART_WARNING);
2276 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2277 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2278 // Python aware wxArtProvider
2279 class wxPyArtProvider : public wxArtProvider {
2280 public:
2281
2282 virtual wxBitmap CreateBitmap(const wxArtID& id,
2283 const wxArtClient& client,
2284 const wxSize& size) {
2285 wxBitmap rval = wxNullBitmap;
2286 bool blocked = wxPyBeginBlockThreads();
2287 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2288 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2289 PyObject* ro;
2290 wxBitmap* ptr;
2291 PyObject* s1, *s2;
2292 s1 = wx2PyString(id);
2293 s2 = wx2PyString(client);
2294 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2295 Py_DECREF(so);
2296 Py_DECREF(s1);
2297 Py_DECREF(s2);
2298 if (ro) {
2299 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2300 rval = *ptr;
2301 Py_DECREF(ro);
2302 }
2303 }
2304 wxPyEndBlockThreads(blocked);
2305 return rval;
2306 }
2307
2308 PYPRIVATE;
2309 };
2310
2311 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2312
2313
2314
2315 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2316 PyObject* ret = PyTuple_New(3);
2317 if (ret) {
2318 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2319 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2320 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2321 }
2322 return ret;
2323 }
2324
2325 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2326 bool cont;
2327 long index = 0;
2328 wxString value;
2329
2330 cont = self->GetFirstGroup(value, index);
2331 return __EnumerationHelper(cont, value, index);
2332 }
2333 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2334 bool cont;
2335 wxString value;
2336
2337 cont = self->GetNextGroup(value, index);
2338 return __EnumerationHelper(cont, value, index);
2339 }
2340 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2341 bool cont;
2342 long index = 0;
2343 wxString value;
2344
2345 cont = self->GetFirstEntry(value, index);
2346 return __EnumerationHelper(cont, value, index);
2347 }
2348 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2349 bool cont;
2350 wxString value;
2351
2352 cont = self->GetNextEntry(value, index);
2353 return __EnumerationHelper(cont, value, index);
2354 }
2355 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2356 long rv;
2357 self->Read(key, &rv, defaultVal);
2358 return rv;
2359 }
2360
2361 SWIGINTERN int
2362 SWIG_AsVal_double(PyObject *obj, double* val)
2363 {
2364 if (PyNumber_Check(obj)) {
2365 if (val) *val = PyFloat_AsDouble(obj);
2366 return 1;
2367 }
2368 else {
2369 SWIG_type_error("number", obj);
2370 }
2371 return 0;
2372 }
2373
2374
2375 SWIGINTERNSHORT double
2376 SWIG_As_double(PyObject* obj)
2377 {
2378 double v;
2379 if (!SWIG_AsVal_double(obj, &v)) {
2380 /*
2381 this is needed to make valgrind/purify happier.
2382 */
2383 memset((void*)&v, 0, sizeof(double));
2384 }
2385 return v;
2386 }
2387
2388
2389 SWIGINTERNSHORT int
2390 SWIG_Check_double(PyObject* obj)
2391 {
2392 return SWIG_AsVal_double(obj, (double*)0);
2393 }
2394
2395 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2396 double rv;
2397 self->Read(key, &rv, defaultVal);
2398 return rv;
2399 }
2400
2401 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2402 #define SWIG_From_double PyFloat_FromDouble
2403 /*@@*/
2404
2405 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2406 bool rv;
2407 self->Read(key, &rv, defaultVal);
2408 return rv;
2409 }
2410
2411 #include <wx/datetime.h>
2412
2413
2414 static const wxString wxPyDateFormatStr(wxT("%c"));
2415 static const wxString wxPyTimeSpanFormatStr(wxT("%H:%M:%S"));
2416
2417 #define LOCAL_TZ wxDateTime::Local
2418
2419
2420 #if UINT_MAX < LONG_MAX
2421 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2422 #define SWIG_From_unsigned_SS_int SWIG_From_long
2423 /*@@*/
2424 #else
2425 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2426 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2427 /*@@*/
2428 #endif
2429
2430 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2431 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2432 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2433 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2434 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2435 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2436 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2437 return (*self < *other);
2438 }
2439 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2440 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2441 return (*self <= *other);
2442 }
2443 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2444 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2445 return (*self > *other);
2446 }
2447 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2448 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2449 return (*self >= *other);
2450 }
2451 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2452 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2453 return (*self == *other);
2454 }
2455 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2456 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2457 return (*self != *other);
2458 }
2459 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2460 const wxChar* rv;
2461 const wxChar* _date = date;
2462 rv = self->ParseRfc822Date(_date);
2463 if (rv == NULL) return -1;
2464 return rv - _date;
2465 }
2466 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDateFormatStr,wxDateTime const &dateDef=wxDefaultDateTime){
2467 const wxChar* rv;
2468 const wxChar* _date = date;
2469 rv = self->ParseFormat(_date, format, dateDef);
2470 if (rv == NULL) return -1;
2471 return rv - _date;
2472 }
2473 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2474 const wxChar* rv;
2475 const wxChar* _datetime = datetime;
2476 rv = self->ParseDateTime(_datetime);
2477 if (rv == NULL) return -1;
2478 return rv - _datetime;
2479 }
2480 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2481 const wxChar* rv;
2482 const wxChar* _date = date;
2483 rv = self->ParseDate(_date);
2484 if (rv == NULL) return -1;
2485 return rv - _date;
2486 }
2487 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2488 const wxChar* rv;
2489 const wxChar* _time = time;
2490 rv = self->ParseTime(_time);
2491 if (rv == NULL) return -1;
2492 return rv - _time;
2493 }
2494 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2495 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2496 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2497 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2498 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2499 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2500 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2501 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2502 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2503 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2504 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2505 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2506 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2507 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2508 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2509 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2510
2511 #include <wx/dataobj.h>
2512
2513 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2514 size_t count = self->GetFormatCount(dir);
2515 wxDataFormat* formats = new wxDataFormat[count];
2516 self->GetAllFormats(formats, dir);
2517
2518 bool blocked = wxPyBeginBlockThreads();
2519 PyObject* list = PyList_New(count);
2520 for (size_t i=0; i<count; i++) {
2521 wxDataFormat* format = new wxDataFormat(formats[i]);
2522 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2523 PyList_Append(list, obj);
2524 Py_DECREF(obj);
2525 }
2526 wxPyEndBlockThreads(blocked);
2527 delete [] formats;
2528 return list;
2529 }
2530 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2531 PyObject* rval = NULL;
2532 size_t size = self->GetDataSize(format);
2533 bool blocked = wxPyBeginBlockThreads();
2534 if (size) {
2535 char* buf = new char[size];
2536 if (self->GetDataHere(format, buf))
2537 rval = PyString_FromStringAndSize(buf, size);
2538 delete [] buf;
2539 }
2540 if (! rval) {
2541 rval = Py_None;
2542 Py_INCREF(rval);
2543 }
2544 wxPyEndBlockThreads(blocked);
2545 return rval;
2546 }
2547 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2548 bool rval;
2549 bool blocked = wxPyBeginBlockThreads();
2550 if (PyString_Check(data)) {
2551 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2552 }
2553 else {
2554 // raise a TypeError if not a string
2555 PyErr_SetString(PyExc_TypeError, "String expected.");
2556 rval = false;
2557 }
2558 wxPyEndBlockThreads(blocked);
2559 return rval;
2560 }
2561 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2562 PyObject* rval = NULL;
2563 size_t size = self->GetDataSize();
2564 bool blocked = wxPyBeginBlockThreads();
2565 if (size) {
2566 char* buf = new char[size];
2567 if (self->GetDataHere(buf))
2568 rval = PyString_FromStringAndSize(buf, size);
2569 delete [] buf;
2570 }
2571 if (! rval) {
2572 rval = Py_None;
2573 Py_INCREF(rval);
2574 }
2575 wxPyEndBlockThreads(blocked);
2576 return rval;
2577 }
2578 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2579 bool rval;
2580 bool blocked = wxPyBeginBlockThreads();
2581 if (PyString_Check(data)) {
2582 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2583 }
2584 else {
2585 // raise a TypeError if not a string
2586 PyErr_SetString(PyExc_TypeError, "String expected.");
2587 rval = false;
2588 }
2589 wxPyEndBlockThreads(blocked);
2590 return rval;
2591 }
2592 // Create a new class for wxPython to use
2593 class wxPyDataObjectSimple : public wxDataObjectSimple {
2594 public:
2595 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2596 : wxDataObjectSimple(format) {}
2597
2598 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2599 bool GetDataHere(void *buf) const;
2600 bool SetData(size_t len, const void *buf) const;
2601 PYPRIVATE;
2602 };
2603
2604 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2605
2606 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2607 // We need to get the data for this object and write it to buf. I think
2608 // the best way to do this for wxPython is to have the Python method
2609 // return either a string or None and then act appropriately with the
2610 // C++ version.
2611
2612 bool rval = false;
2613 bool blocked = wxPyBeginBlockThreads();
2614 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2615 PyObject* ro;
2616 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2617 if (ro) {
2618 rval = (ro != Py_None && PyString_Check(ro));
2619 if (rval)
2620 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2621 Py_DECREF(ro);
2622 }
2623 }
2624 wxPyEndBlockThreads(blocked);
2625 return rval;
2626 }
2627
2628 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2629 // For this one we simply need to make a string from buf and len
2630 // and send it to the Python method.
2631 bool rval = false;
2632 bool blocked = wxPyBeginBlockThreads();
2633 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2634 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2635 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2636 Py_DECREF(data);
2637 }
2638 wxPyEndBlockThreads(blocked);
2639 return rval;
2640 }
2641
2642 // Create a new class for wxPython to use
2643 class wxPyTextDataObject : public wxTextDataObject {
2644 public:
2645 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2646 : wxTextDataObject(text) {}
2647
2648 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2649 DEC_PYCALLBACK_STRING__const(GetText);
2650 DEC_PYCALLBACK__STRING(SetText);
2651 PYPRIVATE;
2652 };
2653
2654 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2655 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2656 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2657
2658
2659 // Create a new class for wxPython to use
2660 class wxPyBitmapDataObject : public wxBitmapDataObject {
2661 public:
2662 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2663 : wxBitmapDataObject(bitmap) {}
2664
2665 wxBitmap GetBitmap() const;
2666 void SetBitmap(const wxBitmap& bitmap);
2667 PYPRIVATE;
2668 };
2669
2670 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2671 wxBitmap* rval = &wxNullBitmap;
2672 bool blocked = wxPyBeginBlockThreads();
2673 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2674 PyObject* ro;
2675 wxBitmap* ptr;
2676 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2677 if (ro) {
2678 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2679 rval = ptr;
2680 Py_DECREF(ro);
2681 }
2682 }
2683 wxPyEndBlockThreads(blocked);
2684 return *rval;
2685 }
2686
2687 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2688 bool blocked = wxPyBeginBlockThreads();
2689 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2690 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2691 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2692 Py_DECREF(bo);
2693 }
2694 wxPyEndBlockThreads(blocked);
2695 }
2696
2697 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2698 bool rval;
2699 bool blocked = wxPyBeginBlockThreads();
2700 if (PyString_Check(data)) {
2701 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2702 }
2703 else {
2704 // raise a TypeError if not a string
2705 PyErr_SetString(PyExc_TypeError, "String expected.");
2706 rval = false;
2707 }
2708 wxPyEndBlockThreads(blocked);
2709 return rval;
2710 }
2711 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2712 PyObject* obj;
2713 bool blocked = wxPyBeginBlockThreads();
2714 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2715 wxPyEndBlockThreads(blocked);
2716 return obj;
2717 }
2718
2719 #include <wx/metafile.h>
2720
2721
2722 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2723
2724
2725 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2726 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2727 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2728 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2729 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2730
2731
2732 class wxPyTextDropTarget : public wxTextDropTarget {
2733 public:
2734 wxPyTextDropTarget() {}
2735
2736 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2737
2738 DEC_PYCALLBACK__(OnLeave);
2739 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2740 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2741 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2742 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2743
2744 PYPRIVATE;
2745 };
2746
2747 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2748 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2749 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2750 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2751 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2752 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2753
2754
2755
2756 class wxPyFileDropTarget : public wxFileDropTarget {
2757 public:
2758 wxPyFileDropTarget() {}
2759
2760 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2761
2762 DEC_PYCALLBACK__(OnLeave);
2763 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2764 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2765 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2766 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2767
2768 PYPRIVATE;
2769 };
2770
2771 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2772 const wxArrayString& filenames) {
2773 bool rval = false;
2774 bool blocked = wxPyBeginBlockThreads();
2775 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2776 PyObject* list = wxArrayString2PyList_helper(filenames);
2777 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2778 Py_DECREF(list);
2779 }
2780 wxPyEndBlockThreads(blocked);
2781 return rval;
2782 }
2783
2784
2785
2786 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2787 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2788 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2789 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2790 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2791
2792
2793
2794
2795 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2796
2797 #include <wx/display.h>
2798
2799 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2800 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2801
2802 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2803 #if !wxUSE_DISPLAY
2804 #include <wx/dynarray.h>
2805 #include <wx/vidmode.h>
2806
2807 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2808 #include "wx/arrimpl.cpp"
2809 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2810 const wxVideoMode wxDefaultVideoMode;
2811
2812 class wxDisplay
2813 {
2814 public:
2815 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2816 ~wxDisplay() {}
2817
2818 static size_t GetCount()
2819 { wxPyRaiseNotImplemented(); return 0; }
2820
2821 static int GetFromPoint(const wxPoint& pt)
2822 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2823 static int GetFromWindow(wxWindow *window)
2824 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2825
2826 virtual bool IsOk() const { return false; }
2827 virtual wxRect GetGeometry() const { wxRect r; return r; }
2828 virtual wxString GetName() const { return wxEmptyString; }
2829 bool IsPrimary() const { return false; }
2830
2831 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2832 { wxArrayVideoModes a; return a; }
2833
2834 virtual wxVideoMode GetCurrentMode() const
2835 { return wxDefaultVideoMode; }
2836
2837 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2838 { return false; }
2839
2840 void ResetMode() {}
2841 };
2842 #endif
2843
2844 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2845 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2846 PyObject* pyList = NULL;
2847 wxArrayVideoModes arr = self->GetModes(mode);
2848 bool blocked = wxPyBeginBlockThreads();
2849 pyList = PyList_New(0);
2850 for (int i=0; i < arr.GetCount(); i++) {
2851 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2852 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2853 PyList_Append(pyList, pyObj);
2854 Py_DECREF(pyObj);
2855 }
2856 wxPyEndBlockThreads(blocked);
2857 return pyList;
2858 }
2859
2860 #include <wx/stdpaths.h>
2861
2862 static wxStandardPaths *StandardPaths_Get(){
2863 return (wxStandardPaths*) &wxStandardPaths::Get();
2864 }
2865 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2866 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2867 #ifdef __cplusplus
2868 extern "C" {
2869 #endif
2870 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2871 PyObject *resultobj;
2872 wxSystemColour arg1 ;
2873 wxColour result;
2874 PyObject * obj0 = 0 ;
2875 char *kwnames[] = {
2876 (char *) "index", NULL
2877 };
2878
2879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2880 {
2881 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2882 if (SWIG_arg_fail(1)) SWIG_fail;
2883 }
2884 {
2885 if (!wxPyCheckForApp()) SWIG_fail;
2886 PyThreadState* __tstate = wxPyBeginAllowThreads();
2887 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2888
2889 wxPyEndAllowThreads(__tstate);
2890 if (PyErr_Occurred()) SWIG_fail;
2891 }
2892 {
2893 wxColour * resultptr;
2894 resultptr = new wxColour((wxColour &)(result));
2895 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2896 }
2897 return resultobj;
2898 fail:
2899 return NULL;
2900 }
2901
2902
2903 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2904 PyObject *resultobj;
2905 wxSystemFont arg1 ;
2906 wxFont result;
2907 PyObject * obj0 = 0 ;
2908 char *kwnames[] = {
2909 (char *) "index", NULL
2910 };
2911
2912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2913 {
2914 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2915 if (SWIG_arg_fail(1)) SWIG_fail;
2916 }
2917 {
2918 if (!wxPyCheckForApp()) SWIG_fail;
2919 PyThreadState* __tstate = wxPyBeginAllowThreads();
2920 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2921
2922 wxPyEndAllowThreads(__tstate);
2923 if (PyErr_Occurred()) SWIG_fail;
2924 }
2925 {
2926 wxFont * resultptr;
2927 resultptr = new wxFont((wxFont &)(result));
2928 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2929 }
2930 return resultobj;
2931 fail:
2932 return NULL;
2933 }
2934
2935
2936 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2937 PyObject *resultobj;
2938 wxSystemMetric arg1 ;
2939 int result;
2940 PyObject * obj0 = 0 ;
2941 char *kwnames[] = {
2942 (char *) "index", NULL
2943 };
2944
2945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2946 {
2947 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2948 if (SWIG_arg_fail(1)) SWIG_fail;
2949 }
2950 {
2951 if (!wxPyCheckForApp()) SWIG_fail;
2952 PyThreadState* __tstate = wxPyBeginAllowThreads();
2953 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2954
2955 wxPyEndAllowThreads(__tstate);
2956 if (PyErr_Occurred()) SWIG_fail;
2957 }
2958 {
2959 resultobj = SWIG_From_int((int)(result));
2960 }
2961 return resultobj;
2962 fail:
2963 return NULL;
2964 }
2965
2966
2967 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2968 PyObject *resultobj;
2969 wxSystemFeature arg1 ;
2970 bool result;
2971 PyObject * obj0 = 0 ;
2972 char *kwnames[] = {
2973 (char *) "index", NULL
2974 };
2975
2976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2977 {
2978 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2979 if (SWIG_arg_fail(1)) SWIG_fail;
2980 }
2981 {
2982 if (!wxPyCheckForApp()) SWIG_fail;
2983 PyThreadState* __tstate = wxPyBeginAllowThreads();
2984 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2985
2986 wxPyEndAllowThreads(__tstate);
2987 if (PyErr_Occurred()) SWIG_fail;
2988 }
2989 {
2990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2991 }
2992 return resultobj;
2993 fail:
2994 return NULL;
2995 }
2996
2997
2998 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
2999 PyObject *resultobj;
3000 wxSystemScreenType result;
3001 char *kwnames[] = {
3002 NULL
3003 };
3004
3005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3006 {
3007 if (!wxPyCheckForApp()) SWIG_fail;
3008 PyThreadState* __tstate = wxPyBeginAllowThreads();
3009 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3010
3011 wxPyEndAllowThreads(__tstate);
3012 if (PyErr_Occurred()) SWIG_fail;
3013 }
3014 resultobj = SWIG_From_int((result));
3015 return resultobj;
3016 fail:
3017 return NULL;
3018 }
3019
3020
3021 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3022 PyObject *resultobj;
3023 wxSystemScreenType arg1 ;
3024 PyObject * obj0 = 0 ;
3025 char *kwnames[] = {
3026 (char *) "screen", NULL
3027 };
3028
3029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3030 {
3031 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3032 if (SWIG_arg_fail(1)) SWIG_fail;
3033 }
3034 {
3035 if (!wxPyCheckForApp()) SWIG_fail;
3036 PyThreadState* __tstate = wxPyBeginAllowThreads();
3037 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3038
3039 wxPyEndAllowThreads(__tstate);
3040 if (PyErr_Occurred()) SWIG_fail;
3041 }
3042 Py_INCREF(Py_None); resultobj = Py_None;
3043 return resultobj;
3044 fail:
3045 return NULL;
3046 }
3047
3048
3049 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3050 PyObject *obj;
3051 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3052 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3053 Py_INCREF(obj);
3054 return Py_BuildValue((char *)"");
3055 }
3056 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3057 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3058 return 1;
3059 }
3060
3061
3062 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3063 PyObject *pyobj;
3064
3065 {
3066 #if wxUSE_UNICODE
3067 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3068 #else
3069 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3070 #endif
3071 }
3072 return pyobj;
3073 }
3074
3075
3076 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3077 PyObject *resultobj;
3078 wxSystemOptions *result;
3079 char *kwnames[] = {
3080 NULL
3081 };
3082
3083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3084 {
3085 PyThreadState* __tstate = wxPyBeginAllowThreads();
3086 result = (wxSystemOptions *)new wxSystemOptions();
3087
3088 wxPyEndAllowThreads(__tstate);
3089 if (PyErr_Occurred()) SWIG_fail;
3090 }
3091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3092 return resultobj;
3093 fail:
3094 return NULL;
3095 }
3096
3097
3098 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3099 PyObject *resultobj;
3100 wxString *arg1 = 0 ;
3101 wxString *arg2 = 0 ;
3102 bool temp1 = false ;
3103 bool temp2 = false ;
3104 PyObject * obj0 = 0 ;
3105 PyObject * obj1 = 0 ;
3106 char *kwnames[] = {
3107 (char *) "name",(char *) "value", NULL
3108 };
3109
3110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3111 {
3112 arg1 = wxString_in_helper(obj0);
3113 if (arg1 == NULL) SWIG_fail;
3114 temp1 = true;
3115 }
3116 {
3117 arg2 = wxString_in_helper(obj1);
3118 if (arg2 == NULL) SWIG_fail;
3119 temp2 = true;
3120 }
3121 {
3122 PyThreadState* __tstate = wxPyBeginAllowThreads();
3123 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3124
3125 wxPyEndAllowThreads(__tstate);
3126 if (PyErr_Occurred()) SWIG_fail;
3127 }
3128 Py_INCREF(Py_None); resultobj = Py_None;
3129 {
3130 if (temp1)
3131 delete arg1;
3132 }
3133 {
3134 if (temp2)
3135 delete arg2;
3136 }
3137 return resultobj;
3138 fail:
3139 {
3140 if (temp1)
3141 delete arg1;
3142 }
3143 {
3144 if (temp2)
3145 delete arg2;
3146 }
3147 return NULL;
3148 }
3149
3150
3151 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3152 PyObject *resultobj;
3153 wxString *arg1 = 0 ;
3154 int arg2 ;
3155 bool temp1 = false ;
3156 PyObject * obj0 = 0 ;
3157 PyObject * obj1 = 0 ;
3158 char *kwnames[] = {
3159 (char *) "name",(char *) "value", NULL
3160 };
3161
3162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3163 {
3164 arg1 = wxString_in_helper(obj0);
3165 if (arg1 == NULL) SWIG_fail;
3166 temp1 = true;
3167 }
3168 {
3169 arg2 = (int)(SWIG_As_int(obj1));
3170 if (SWIG_arg_fail(2)) SWIG_fail;
3171 }
3172 {
3173 PyThreadState* __tstate = wxPyBeginAllowThreads();
3174 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3175
3176 wxPyEndAllowThreads(__tstate);
3177 if (PyErr_Occurred()) SWIG_fail;
3178 }
3179 Py_INCREF(Py_None); resultobj = Py_None;
3180 {
3181 if (temp1)
3182 delete arg1;
3183 }
3184 return resultobj;
3185 fail:
3186 {
3187 if (temp1)
3188 delete arg1;
3189 }
3190 return NULL;
3191 }
3192
3193
3194 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3195 PyObject *resultobj;
3196 wxString *arg1 = 0 ;
3197 wxString result;
3198 bool temp1 = false ;
3199 PyObject * obj0 = 0 ;
3200 char *kwnames[] = {
3201 (char *) "name", NULL
3202 };
3203
3204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3205 {
3206 arg1 = wxString_in_helper(obj0);
3207 if (arg1 == NULL) SWIG_fail;
3208 temp1 = true;
3209 }
3210 {
3211 PyThreadState* __tstate = wxPyBeginAllowThreads();
3212 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3213
3214 wxPyEndAllowThreads(__tstate);
3215 if (PyErr_Occurred()) SWIG_fail;
3216 }
3217 {
3218 #if wxUSE_UNICODE
3219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3220 #else
3221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3222 #endif
3223 }
3224 {
3225 if (temp1)
3226 delete arg1;
3227 }
3228 return resultobj;
3229 fail:
3230 {
3231 if (temp1)
3232 delete arg1;
3233 }
3234 return NULL;
3235 }
3236
3237
3238 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3239 PyObject *resultobj;
3240 wxString *arg1 = 0 ;
3241 int result;
3242 bool temp1 = false ;
3243 PyObject * obj0 = 0 ;
3244 char *kwnames[] = {
3245 (char *) "name", NULL
3246 };
3247
3248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3249 {
3250 arg1 = wxString_in_helper(obj0);
3251 if (arg1 == NULL) SWIG_fail;
3252 temp1 = true;
3253 }
3254 {
3255 PyThreadState* __tstate = wxPyBeginAllowThreads();
3256 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3257
3258 wxPyEndAllowThreads(__tstate);
3259 if (PyErr_Occurred()) SWIG_fail;
3260 }
3261 {
3262 resultobj = SWIG_From_int((int)(result));
3263 }
3264 {
3265 if (temp1)
3266 delete arg1;
3267 }
3268 return resultobj;
3269 fail:
3270 {
3271 if (temp1)
3272 delete arg1;
3273 }
3274 return NULL;
3275 }
3276
3277
3278 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3279 PyObject *resultobj;
3280 wxString *arg1 = 0 ;
3281 bool result;
3282 bool temp1 = false ;
3283 PyObject * obj0 = 0 ;
3284 char *kwnames[] = {
3285 (char *) "name", NULL
3286 };
3287
3288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3289 {
3290 arg1 = wxString_in_helper(obj0);
3291 if (arg1 == NULL) SWIG_fail;
3292 temp1 = true;
3293 }
3294 {
3295 PyThreadState* __tstate = wxPyBeginAllowThreads();
3296 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3297
3298 wxPyEndAllowThreads(__tstate);
3299 if (PyErr_Occurred()) SWIG_fail;
3300 }
3301 {
3302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3303 }
3304 {
3305 if (temp1)
3306 delete arg1;
3307 }
3308 return resultobj;
3309 fail:
3310 {
3311 if (temp1)
3312 delete arg1;
3313 }
3314 return NULL;
3315 }
3316
3317
3318 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3319 PyObject *obj;
3320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3321 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3322 Py_INCREF(obj);
3323 return Py_BuildValue((char *)"");
3324 }
3325 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3326 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3327 return 1;
3328 }
3329
3330
3331 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3332 PyObject *pyobj;
3333
3334 {
3335 #if wxUSE_UNICODE
3336 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3337 #else
3338 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3339 #endif
3340 }
3341 return pyobj;
3342 }
3343
3344
3345 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3346 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3347 return 1;
3348 }
3349
3350
3351 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3352 PyObject *pyobj;
3353
3354 {
3355 #if wxUSE_UNICODE
3356 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3357 #else
3358 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3359 #endif
3360 }
3361 return pyobj;
3362 }
3363
3364
3365 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3366 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3367 return 1;
3368 }
3369
3370
3371 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3372 PyObject *pyobj;
3373
3374 {
3375 #if wxUSE_UNICODE
3376 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3377 #else
3378 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3379 #endif
3380 }
3381 return pyobj;
3382 }
3383
3384
3385 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3386 PyObject *resultobj;
3387 long result;
3388 char *kwnames[] = {
3389 NULL
3390 };
3391
3392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3393 {
3394 PyThreadState* __tstate = wxPyBeginAllowThreads();
3395 result = (long)wxNewId();
3396
3397 wxPyEndAllowThreads(__tstate);
3398 if (PyErr_Occurred()) SWIG_fail;
3399 }
3400 {
3401 resultobj = SWIG_From_long((long)(result));
3402 }
3403 return resultobj;
3404 fail:
3405 return NULL;
3406 }
3407
3408
3409 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3410 PyObject *resultobj;
3411 long arg1 ;
3412 PyObject * obj0 = 0 ;
3413 char *kwnames[] = {
3414 (char *) "id", NULL
3415 };
3416
3417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3418 {
3419 arg1 = (long)(SWIG_As_long(obj0));
3420 if (SWIG_arg_fail(1)) SWIG_fail;
3421 }
3422 {
3423 PyThreadState* __tstate = wxPyBeginAllowThreads();
3424 wxRegisterId(arg1);
3425
3426 wxPyEndAllowThreads(__tstate);
3427 if (PyErr_Occurred()) SWIG_fail;
3428 }
3429 Py_INCREF(Py_None); resultobj = Py_None;
3430 return resultobj;
3431 fail:
3432 return NULL;
3433 }
3434
3435
3436 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3437 PyObject *resultobj;
3438 long result;
3439 char *kwnames[] = {
3440 NULL
3441 };
3442
3443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3444 {
3445 PyThreadState* __tstate = wxPyBeginAllowThreads();
3446 result = (long)wxGetCurrentId();
3447
3448 wxPyEndAllowThreads(__tstate);
3449 if (PyErr_Occurred()) SWIG_fail;
3450 }
3451 {
3452 resultobj = SWIG_From_long((long)(result));
3453 }
3454 return resultobj;
3455 fail:
3456 return NULL;
3457 }
3458
3459
3460 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3461 PyObject *resultobj;
3462 int arg1 ;
3463 bool result;
3464 PyObject * obj0 = 0 ;
3465 char *kwnames[] = {
3466 (char *) "id", NULL
3467 };
3468
3469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3470 {
3471 arg1 = (int)(SWIG_As_int(obj0));
3472 if (SWIG_arg_fail(1)) SWIG_fail;
3473 }
3474 {
3475 PyThreadState* __tstate = wxPyBeginAllowThreads();
3476 result = (bool)wxIsStockID(arg1);
3477
3478 wxPyEndAllowThreads(__tstate);
3479 if (PyErr_Occurred()) SWIG_fail;
3480 }
3481 {
3482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3483 }
3484 return resultobj;
3485 fail:
3486 return NULL;
3487 }
3488
3489
3490 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3491 PyObject *resultobj;
3492 int arg1 ;
3493 wxString *arg2 = 0 ;
3494 bool result;
3495 bool temp2 = false ;
3496 PyObject * obj0 = 0 ;
3497 PyObject * obj1 = 0 ;
3498 char *kwnames[] = {
3499 (char *) "id",(char *) "label", NULL
3500 };
3501
3502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3503 {
3504 arg1 = (int)(SWIG_As_int(obj0));
3505 if (SWIG_arg_fail(1)) SWIG_fail;
3506 }
3507 {
3508 arg2 = wxString_in_helper(obj1);
3509 if (arg2 == NULL) SWIG_fail;
3510 temp2 = true;
3511 }
3512 {
3513 PyThreadState* __tstate = wxPyBeginAllowThreads();
3514 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3515
3516 wxPyEndAllowThreads(__tstate);
3517 if (PyErr_Occurred()) SWIG_fail;
3518 }
3519 {
3520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3521 }
3522 {
3523 if (temp2)
3524 delete arg2;
3525 }
3526 return resultobj;
3527 fail:
3528 {
3529 if (temp2)
3530 delete arg2;
3531 }
3532 return NULL;
3533 }
3534
3535
3536 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3537 PyObject *resultobj;
3538 int arg1 ;
3539 wxString result;
3540 PyObject * obj0 = 0 ;
3541 char *kwnames[] = {
3542 (char *) "id", NULL
3543 };
3544
3545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetStockLabel",kwnames,&obj0)) goto fail;
3546 {
3547 arg1 = (int)(SWIG_As_int(obj0));
3548 if (SWIG_arg_fail(1)) SWIG_fail;
3549 }
3550 {
3551 PyThreadState* __tstate = wxPyBeginAllowThreads();
3552 result = wxGetStockLabel(arg1);
3553
3554 wxPyEndAllowThreads(__tstate);
3555 if (PyErr_Occurred()) SWIG_fail;
3556 }
3557 {
3558 #if wxUSE_UNICODE
3559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3560 #else
3561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3562 #endif
3563 }
3564 return resultobj;
3565 fail:
3566 return NULL;
3567 }
3568
3569
3570 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3571 PyObject *resultobj;
3572 char *kwnames[] = {
3573 NULL
3574 };
3575
3576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3577 {
3578 if (!wxPyCheckForApp()) SWIG_fail;
3579 PyThreadState* __tstate = wxPyBeginAllowThreads();
3580 wxBell();
3581
3582 wxPyEndAllowThreads(__tstate);
3583 if (PyErr_Occurred()) SWIG_fail;
3584 }
3585 Py_INCREF(Py_None); resultobj = Py_None;
3586 return resultobj;
3587 fail:
3588 return NULL;
3589 }
3590
3591
3592 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3593 PyObject *resultobj;
3594 char *kwnames[] = {
3595 NULL
3596 };
3597
3598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3599 {
3600 if (!wxPyCheckForApp()) SWIG_fail;
3601 PyThreadState* __tstate = wxPyBeginAllowThreads();
3602 wxEndBusyCursor();
3603
3604 wxPyEndAllowThreads(__tstate);
3605 if (PyErr_Occurred()) SWIG_fail;
3606 }
3607 Py_INCREF(Py_None); resultobj = Py_None;
3608 return resultobj;
3609 fail:
3610 return NULL;
3611 }
3612
3613
3614 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3615 PyObject *resultobj;
3616 bool arg1 = (bool) true ;
3617 long result;
3618 PyObject * obj0 = 0 ;
3619 char *kwnames[] = {
3620 (char *) "resetTimer", NULL
3621 };
3622
3623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3624 if (obj0) {
3625 {
3626 arg1 = (bool)(SWIG_As_bool(obj0));
3627 if (SWIG_arg_fail(1)) SWIG_fail;
3628 }
3629 }
3630 {
3631 PyThreadState* __tstate = wxPyBeginAllowThreads();
3632 result = (long)wxGetElapsedTime(arg1);
3633
3634 wxPyEndAllowThreads(__tstate);
3635 if (PyErr_Occurred()) SWIG_fail;
3636 }
3637 {
3638 resultobj = SWIG_From_long((long)(result));
3639 }
3640 return resultobj;
3641 fail:
3642 return NULL;
3643 }
3644
3645
3646 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3647 PyObject *resultobj;
3648 int *arg1 = (int *) 0 ;
3649 int *arg2 = (int *) 0 ;
3650 int temp1 ;
3651 int res1 = 0 ;
3652 int temp2 ;
3653 int res2 = 0 ;
3654 char *kwnames[] = {
3655 NULL
3656 };
3657
3658 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3659 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3661 {
3662 if (!wxPyCheckForApp()) SWIG_fail;
3663 PyThreadState* __tstate = wxPyBeginAllowThreads();
3664 wxGetMousePosition(arg1,arg2);
3665
3666 wxPyEndAllowThreads(__tstate);
3667 if (PyErr_Occurred()) SWIG_fail;
3668 }
3669 Py_INCREF(Py_None); resultobj = Py_None;
3670 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3671 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3672 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3673 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3674 return resultobj;
3675 fail:
3676 return NULL;
3677 }
3678
3679
3680 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3681 PyObject *resultobj;
3682 bool result;
3683 char *kwnames[] = {
3684 NULL
3685 };
3686
3687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3688 {
3689 PyThreadState* __tstate = wxPyBeginAllowThreads();
3690 result = (bool)wxIsBusy();
3691
3692 wxPyEndAllowThreads(__tstate);
3693 if (PyErr_Occurred()) SWIG_fail;
3694 }
3695 {
3696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3697 }
3698 return resultobj;
3699 fail:
3700 return NULL;
3701 }
3702
3703
3704 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3705 PyObject *resultobj;
3706 wxString result;
3707 char *kwnames[] = {
3708 NULL
3709 };
3710
3711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3712 {
3713 PyThreadState* __tstate = wxPyBeginAllowThreads();
3714 result = wxNow();
3715
3716 wxPyEndAllowThreads(__tstate);
3717 if (PyErr_Occurred()) SWIG_fail;
3718 }
3719 {
3720 #if wxUSE_UNICODE
3721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3722 #else
3723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3724 #endif
3725 }
3726 return resultobj;
3727 fail:
3728 return NULL;
3729 }
3730
3731
3732 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3733 PyObject *resultobj;
3734 wxString const &arg1_defvalue = wxPyEmptyString ;
3735 wxString *arg1 = (wxString *) &arg1_defvalue ;
3736 bool result;
3737 bool temp1 = false ;
3738 PyObject * obj0 = 0 ;
3739 char *kwnames[] = {
3740 (char *) "command", NULL
3741 };
3742
3743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3744 if (obj0) {
3745 {
3746 arg1 = wxString_in_helper(obj0);
3747 if (arg1 == NULL) SWIG_fail;
3748 temp1 = true;
3749 }
3750 }
3751 {
3752 PyThreadState* __tstate = wxPyBeginAllowThreads();
3753 result = (bool)wxShell((wxString const &)*arg1);
3754
3755 wxPyEndAllowThreads(__tstate);
3756 if (PyErr_Occurred()) SWIG_fail;
3757 }
3758 {
3759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3760 }
3761 {
3762 if (temp1)
3763 delete arg1;
3764 }
3765 return resultobj;
3766 fail:
3767 {
3768 if (temp1)
3769 delete arg1;
3770 }
3771 return NULL;
3772 }
3773
3774
3775 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3776 PyObject *resultobj;
3777 char *kwnames[] = {
3778 NULL
3779 };
3780
3781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3782 {
3783 PyThreadState* __tstate = wxPyBeginAllowThreads();
3784 wxStartTimer();
3785
3786 wxPyEndAllowThreads(__tstate);
3787 if (PyErr_Occurred()) SWIG_fail;
3788 }
3789 Py_INCREF(Py_None); resultobj = Py_None;
3790 return resultobj;
3791 fail:
3792 return NULL;
3793 }
3794
3795
3796 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3797 PyObject *resultobj;
3798 int *arg1 = (int *) 0 ;
3799 int *arg2 = (int *) 0 ;
3800 int result;
3801 int temp1 ;
3802 int res1 = 0 ;
3803 int temp2 ;
3804 int res2 = 0 ;
3805 char *kwnames[] = {
3806 NULL
3807 };
3808
3809 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3810 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3812 {
3813 PyThreadState* __tstate = wxPyBeginAllowThreads();
3814 result = (int)wxGetOsVersion(arg1,arg2);
3815
3816 wxPyEndAllowThreads(__tstate);
3817 if (PyErr_Occurred()) SWIG_fail;
3818 }
3819 {
3820 resultobj = SWIG_From_int((int)(result));
3821 }
3822 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3823 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3824 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3825 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3826 return resultobj;
3827 fail:
3828 return NULL;
3829 }
3830
3831
3832 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3833 PyObject *resultobj;
3834 wxString result;
3835 char *kwnames[] = {
3836 NULL
3837 };
3838
3839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3840 {
3841 PyThreadState* __tstate = wxPyBeginAllowThreads();
3842 result = wxGetOsDescription();
3843
3844 wxPyEndAllowThreads(__tstate);
3845 if (PyErr_Occurred()) SWIG_fail;
3846 }
3847 {
3848 #if wxUSE_UNICODE
3849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3850 #else
3851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3852 #endif
3853 }
3854 return resultobj;
3855 fail:
3856 return NULL;
3857 }
3858
3859
3860 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3861 PyObject *resultobj;
3862 long result;
3863 char *kwnames[] = {
3864 NULL
3865 };
3866
3867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3868 {
3869 PyThreadState* __tstate = wxPyBeginAllowThreads();
3870 result = (long)wxGetFreeMemory();
3871
3872 wxPyEndAllowThreads(__tstate);
3873 if (PyErr_Occurred()) SWIG_fail;
3874 }
3875 {
3876 resultobj = SWIG_From_long((long)(result));
3877 }
3878 return resultobj;
3879 fail:
3880 return NULL;
3881 }
3882
3883
3884 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3885 PyObject *resultobj;
3886 wxShutdownFlags arg1 ;
3887 bool result;
3888 PyObject * obj0 = 0 ;
3889 char *kwnames[] = {
3890 (char *) "wFlags", NULL
3891 };
3892
3893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3894 {
3895 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3896 if (SWIG_arg_fail(1)) SWIG_fail;
3897 }
3898 {
3899 if (!wxPyCheckForApp()) SWIG_fail;
3900 PyThreadState* __tstate = wxPyBeginAllowThreads();
3901 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3902
3903 wxPyEndAllowThreads(__tstate);
3904 if (PyErr_Occurred()) SWIG_fail;
3905 }
3906 {
3907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3908 }
3909 return resultobj;
3910 fail:
3911 return NULL;
3912 }
3913
3914
3915 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3916 PyObject *resultobj;
3917 int arg1 ;
3918 PyObject * obj0 = 0 ;
3919 char *kwnames[] = {
3920 (char *) "secs", NULL
3921 };
3922
3923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3924 {
3925 arg1 = (int)(SWIG_As_int(obj0));
3926 if (SWIG_arg_fail(1)) SWIG_fail;
3927 }
3928 {
3929 PyThreadState* __tstate = wxPyBeginAllowThreads();
3930 wxSleep(arg1);
3931
3932 wxPyEndAllowThreads(__tstate);
3933 if (PyErr_Occurred()) SWIG_fail;
3934 }
3935 Py_INCREF(Py_None); resultobj = Py_None;
3936 return resultobj;
3937 fail:
3938 return NULL;
3939 }
3940
3941
3942 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3943 PyObject *resultobj;
3944 unsigned long arg1 ;
3945 PyObject * obj0 = 0 ;
3946 char *kwnames[] = {
3947 (char *) "milliseconds", NULL
3948 };
3949
3950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3951 {
3952 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3953 if (SWIG_arg_fail(1)) SWIG_fail;
3954 }
3955 {
3956 PyThreadState* __tstate = wxPyBeginAllowThreads();
3957 wxMilliSleep(arg1);
3958
3959 wxPyEndAllowThreads(__tstate);
3960 if (PyErr_Occurred()) SWIG_fail;
3961 }
3962 Py_INCREF(Py_None); resultobj = Py_None;
3963 return resultobj;
3964 fail:
3965 return NULL;
3966 }
3967
3968
3969 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3970 PyObject *resultobj;
3971 unsigned long arg1 ;
3972 PyObject * obj0 = 0 ;
3973 char *kwnames[] = {
3974 (char *) "microseconds", NULL
3975 };
3976
3977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
3978 {
3979 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3980 if (SWIG_arg_fail(1)) SWIG_fail;
3981 }
3982 {
3983 PyThreadState* __tstate = wxPyBeginAllowThreads();
3984 wxMicroSleep(arg1);
3985
3986 wxPyEndAllowThreads(__tstate);
3987 if (PyErr_Occurred()) SWIG_fail;
3988 }
3989 Py_INCREF(Py_None); resultobj = Py_None;
3990 return resultobj;
3991 fail:
3992 return NULL;
3993 }
3994
3995
3996 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
3997 PyObject *resultobj;
3998 bool arg1 ;
3999 PyObject * obj0 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "enable", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4005 {
4006 arg1 = (bool)(SWIG_As_bool(obj0));
4007 if (SWIG_arg_fail(1)) SWIG_fail;
4008 }
4009 {
4010 PyThreadState* __tstate = wxPyBeginAllowThreads();
4011 wxEnableTopLevelWindows(arg1);
4012
4013 wxPyEndAllowThreads(__tstate);
4014 if (PyErr_Occurred()) SWIG_fail;
4015 }
4016 Py_INCREF(Py_None); resultobj = Py_None;
4017 return resultobj;
4018 fail:
4019 return NULL;
4020 }
4021
4022
4023 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4024 PyObject *resultobj;
4025 wxString *arg1 = 0 ;
4026 wxString result;
4027 bool temp1 = false ;
4028 PyObject * obj0 = 0 ;
4029 char *kwnames[] = {
4030 (char *) "in", NULL
4031 };
4032
4033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4034 {
4035 arg1 = wxString_in_helper(obj0);
4036 if (arg1 == NULL) SWIG_fail;
4037 temp1 = true;
4038 }
4039 {
4040 PyThreadState* __tstate = wxPyBeginAllowThreads();
4041 result = wxStripMenuCodes((wxString const &)*arg1);
4042
4043 wxPyEndAllowThreads(__tstate);
4044 if (PyErr_Occurred()) SWIG_fail;
4045 }
4046 {
4047 #if wxUSE_UNICODE
4048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4049 #else
4050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4051 #endif
4052 }
4053 {
4054 if (temp1)
4055 delete arg1;
4056 }
4057 return resultobj;
4058 fail:
4059 {
4060 if (temp1)
4061 delete arg1;
4062 }
4063 return NULL;
4064 }
4065
4066
4067 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4068 PyObject *resultobj;
4069 wxString result;
4070 char *kwnames[] = {
4071 NULL
4072 };
4073
4074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4075 {
4076 PyThreadState* __tstate = wxPyBeginAllowThreads();
4077 result = wxGetEmailAddress();
4078
4079 wxPyEndAllowThreads(__tstate);
4080 if (PyErr_Occurred()) SWIG_fail;
4081 }
4082 {
4083 #if wxUSE_UNICODE
4084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4085 #else
4086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4087 #endif
4088 }
4089 return resultobj;
4090 fail:
4091 return NULL;
4092 }
4093
4094
4095 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4096 PyObject *resultobj;
4097 wxString result;
4098 char *kwnames[] = {
4099 NULL
4100 };
4101
4102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4103 {
4104 PyThreadState* __tstate = wxPyBeginAllowThreads();
4105 result = wxGetHostName();
4106
4107 wxPyEndAllowThreads(__tstate);
4108 if (PyErr_Occurred()) SWIG_fail;
4109 }
4110 {
4111 #if wxUSE_UNICODE
4112 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4113 #else
4114 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4115 #endif
4116 }
4117 return resultobj;
4118 fail:
4119 return NULL;
4120 }
4121
4122
4123 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4124 PyObject *resultobj;
4125 wxString result;
4126 char *kwnames[] = {
4127 NULL
4128 };
4129
4130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4131 {
4132 PyThreadState* __tstate = wxPyBeginAllowThreads();
4133 result = wxGetFullHostName();
4134
4135 wxPyEndAllowThreads(__tstate);
4136 if (PyErr_Occurred()) SWIG_fail;
4137 }
4138 {
4139 #if wxUSE_UNICODE
4140 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4141 #else
4142 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4143 #endif
4144 }
4145 return resultobj;
4146 fail:
4147 return NULL;
4148 }
4149
4150
4151 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4152 PyObject *resultobj;
4153 wxString result;
4154 char *kwnames[] = {
4155 NULL
4156 };
4157
4158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4159 {
4160 PyThreadState* __tstate = wxPyBeginAllowThreads();
4161 result = wxGetUserId();
4162
4163 wxPyEndAllowThreads(__tstate);
4164 if (PyErr_Occurred()) SWIG_fail;
4165 }
4166 {
4167 #if wxUSE_UNICODE
4168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4169 #else
4170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4171 #endif
4172 }
4173 return resultobj;
4174 fail:
4175 return NULL;
4176 }
4177
4178
4179 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4180 PyObject *resultobj;
4181 wxString result;
4182 char *kwnames[] = {
4183 NULL
4184 };
4185
4186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4187 {
4188 PyThreadState* __tstate = wxPyBeginAllowThreads();
4189 result = wxGetUserName();
4190
4191 wxPyEndAllowThreads(__tstate);
4192 if (PyErr_Occurred()) SWIG_fail;
4193 }
4194 {
4195 #if wxUSE_UNICODE
4196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4197 #else
4198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4199 #endif
4200 }
4201 return resultobj;
4202 fail:
4203 return NULL;
4204 }
4205
4206
4207 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4208 PyObject *resultobj;
4209 wxString result;
4210 char *kwnames[] = {
4211 NULL
4212 };
4213
4214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4215 {
4216 PyThreadState* __tstate = wxPyBeginAllowThreads();
4217 result = wxGetHomeDir();
4218
4219 wxPyEndAllowThreads(__tstate);
4220 if (PyErr_Occurred()) SWIG_fail;
4221 }
4222 {
4223 #if wxUSE_UNICODE
4224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4225 #else
4226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4227 #endif
4228 }
4229 return resultobj;
4230 fail:
4231 return NULL;
4232 }
4233
4234
4235 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4236 PyObject *resultobj;
4237 wxString const &arg1_defvalue = wxPyEmptyString ;
4238 wxString *arg1 = (wxString *) &arg1_defvalue ;
4239 wxString result;
4240 bool temp1 = false ;
4241 PyObject * obj0 = 0 ;
4242 char *kwnames[] = {
4243 (char *) "user", NULL
4244 };
4245
4246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4247 if (obj0) {
4248 {
4249 arg1 = wxString_in_helper(obj0);
4250 if (arg1 == NULL) SWIG_fail;
4251 temp1 = true;
4252 }
4253 }
4254 {
4255 PyThreadState* __tstate = wxPyBeginAllowThreads();
4256 result = wxGetUserHome((wxString const &)*arg1);
4257
4258 wxPyEndAllowThreads(__tstate);
4259 if (PyErr_Occurred()) SWIG_fail;
4260 }
4261 {
4262 #if wxUSE_UNICODE
4263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4264 #else
4265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4266 #endif
4267 }
4268 {
4269 if (temp1)
4270 delete arg1;
4271 }
4272 return resultobj;
4273 fail:
4274 {
4275 if (temp1)
4276 delete arg1;
4277 }
4278 return NULL;
4279 }
4280
4281
4282 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4283 PyObject *resultobj;
4284 unsigned long result;
4285 char *kwnames[] = {
4286 NULL
4287 };
4288
4289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4290 {
4291 PyThreadState* __tstate = wxPyBeginAllowThreads();
4292 result = (unsigned long)wxGetProcessId();
4293
4294 wxPyEndAllowThreads(__tstate);
4295 if (PyErr_Occurred()) SWIG_fail;
4296 }
4297 {
4298 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4299 }
4300 return resultobj;
4301 fail:
4302 return NULL;
4303 }
4304
4305
4306 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4307 PyObject *resultobj;
4308 char *kwnames[] = {
4309 NULL
4310 };
4311
4312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4313 {
4314 PyThreadState* __tstate = wxPyBeginAllowThreads();
4315 wxTrap();
4316
4317 wxPyEndAllowThreads(__tstate);
4318 if (PyErr_Occurred()) SWIG_fail;
4319 }
4320 Py_INCREF(Py_None); resultobj = Py_None;
4321 return resultobj;
4322 fail:
4323 return NULL;
4324 }
4325
4326
4327 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4328 PyObject *resultobj;
4329 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4330 wxString *arg1 = (wxString *) &arg1_defvalue ;
4331 wxString const &arg2_defvalue = wxPyEmptyString ;
4332 wxString *arg2 = (wxString *) &arg2_defvalue ;
4333 wxString const &arg3_defvalue = wxPyEmptyString ;
4334 wxString *arg3 = (wxString *) &arg3_defvalue ;
4335 wxString const &arg4_defvalue = wxPyEmptyString ;
4336 wxString *arg4 = (wxString *) &arg4_defvalue ;
4337 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4338 wxString *arg5 = (wxString *) &arg5_defvalue ;
4339 int arg6 = (int) 0 ;
4340 wxWindow *arg7 = (wxWindow *) NULL ;
4341 int arg8 = (int) -1 ;
4342 int arg9 = (int) -1 ;
4343 wxString result;
4344 bool temp1 = false ;
4345 bool temp2 = false ;
4346 bool temp3 = false ;
4347 bool temp4 = false ;
4348 bool temp5 = false ;
4349 PyObject * obj0 = 0 ;
4350 PyObject * obj1 = 0 ;
4351 PyObject * obj2 = 0 ;
4352 PyObject * obj3 = 0 ;
4353 PyObject * obj4 = 0 ;
4354 PyObject * obj5 = 0 ;
4355 PyObject * obj6 = 0 ;
4356 PyObject * obj7 = 0 ;
4357 PyObject * obj8 = 0 ;
4358 char *kwnames[] = {
4359 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4360 };
4361
4362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4363 if (obj0) {
4364 {
4365 arg1 = wxString_in_helper(obj0);
4366 if (arg1 == NULL) SWIG_fail;
4367 temp1 = true;
4368 }
4369 }
4370 if (obj1) {
4371 {
4372 arg2 = wxString_in_helper(obj1);
4373 if (arg2 == NULL) SWIG_fail;
4374 temp2 = true;
4375 }
4376 }
4377 if (obj2) {
4378 {
4379 arg3 = wxString_in_helper(obj2);
4380 if (arg3 == NULL) SWIG_fail;
4381 temp3 = true;
4382 }
4383 }
4384 if (obj3) {
4385 {
4386 arg4 = wxString_in_helper(obj3);
4387 if (arg4 == NULL) SWIG_fail;
4388 temp4 = true;
4389 }
4390 }
4391 if (obj4) {
4392 {
4393 arg5 = wxString_in_helper(obj4);
4394 if (arg5 == NULL) SWIG_fail;
4395 temp5 = true;
4396 }
4397 }
4398 if (obj5) {
4399 {
4400 arg6 = (int)(SWIG_As_int(obj5));
4401 if (SWIG_arg_fail(6)) SWIG_fail;
4402 }
4403 }
4404 if (obj6) {
4405 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4406 if (SWIG_arg_fail(7)) SWIG_fail;
4407 }
4408 if (obj7) {
4409 {
4410 arg8 = (int)(SWIG_As_int(obj7));
4411 if (SWIG_arg_fail(8)) SWIG_fail;
4412 }
4413 }
4414 if (obj8) {
4415 {
4416 arg9 = (int)(SWIG_As_int(obj8));
4417 if (SWIG_arg_fail(9)) SWIG_fail;
4418 }
4419 }
4420 {
4421 if (!wxPyCheckForApp()) SWIG_fail;
4422 PyThreadState* __tstate = wxPyBeginAllowThreads();
4423 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4424
4425 wxPyEndAllowThreads(__tstate);
4426 if (PyErr_Occurred()) SWIG_fail;
4427 }
4428 {
4429 #if wxUSE_UNICODE
4430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4431 #else
4432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4433 #endif
4434 }
4435 {
4436 if (temp1)
4437 delete arg1;
4438 }
4439 {
4440 if (temp2)
4441 delete arg2;
4442 }
4443 {
4444 if (temp3)
4445 delete arg3;
4446 }
4447 {
4448 if (temp4)
4449 delete arg4;
4450 }
4451 {
4452 if (temp5)
4453 delete arg5;
4454 }
4455 return resultobj;
4456 fail:
4457 {
4458 if (temp1)
4459 delete arg1;
4460 }
4461 {
4462 if (temp2)
4463 delete arg2;
4464 }
4465 {
4466 if (temp3)
4467 delete arg3;
4468 }
4469 {
4470 if (temp4)
4471 delete arg4;
4472 }
4473 {
4474 if (temp5)
4475 delete arg5;
4476 }
4477 return NULL;
4478 }
4479
4480
4481 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4482 PyObject *resultobj;
4483 wxString *arg1 = 0 ;
4484 wxString *arg2 = 0 ;
4485 wxString const &arg3_defvalue = wxPyEmptyString ;
4486 wxString *arg3 = (wxString *) &arg3_defvalue ;
4487 wxWindow *arg4 = (wxWindow *) NULL ;
4488 wxString result;
4489 bool temp1 = false ;
4490 bool temp2 = false ;
4491 bool temp3 = false ;
4492 PyObject * obj0 = 0 ;
4493 PyObject * obj1 = 0 ;
4494 PyObject * obj2 = 0 ;
4495 PyObject * obj3 = 0 ;
4496 char *kwnames[] = {
4497 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4498 };
4499
4500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4501 {
4502 arg1 = wxString_in_helper(obj0);
4503 if (arg1 == NULL) SWIG_fail;
4504 temp1 = true;
4505 }
4506 {
4507 arg2 = wxString_in_helper(obj1);
4508 if (arg2 == NULL) SWIG_fail;
4509 temp2 = true;
4510 }
4511 if (obj2) {
4512 {
4513 arg3 = wxString_in_helper(obj2);
4514 if (arg3 == NULL) SWIG_fail;
4515 temp3 = true;
4516 }
4517 }
4518 if (obj3) {
4519 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4520 if (SWIG_arg_fail(4)) SWIG_fail;
4521 }
4522 {
4523 if (!wxPyCheckForApp()) SWIG_fail;
4524 PyThreadState* __tstate = wxPyBeginAllowThreads();
4525 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4526
4527 wxPyEndAllowThreads(__tstate);
4528 if (PyErr_Occurred()) SWIG_fail;
4529 }
4530 {
4531 #if wxUSE_UNICODE
4532 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4533 #else
4534 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4535 #endif
4536 }
4537 {
4538 if (temp1)
4539 delete arg1;
4540 }
4541 {
4542 if (temp2)
4543 delete arg2;
4544 }
4545 {
4546 if (temp3)
4547 delete arg3;
4548 }
4549 return resultobj;
4550 fail:
4551 {
4552 if (temp1)
4553 delete arg1;
4554 }
4555 {
4556 if (temp2)
4557 delete arg2;
4558 }
4559 {
4560 if (temp3)
4561 delete arg3;
4562 }
4563 return NULL;
4564 }
4565
4566
4567 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4568 PyObject *resultobj;
4569 wxString *arg1 = 0 ;
4570 wxString *arg2 = 0 ;
4571 wxString const &arg3_defvalue = wxPyEmptyString ;
4572 wxString *arg3 = (wxString *) &arg3_defvalue ;
4573 wxWindow *arg4 = (wxWindow *) NULL ;
4574 wxString result;
4575 bool temp1 = false ;
4576 bool temp2 = false ;
4577 bool temp3 = false ;
4578 PyObject * obj0 = 0 ;
4579 PyObject * obj1 = 0 ;
4580 PyObject * obj2 = 0 ;
4581 PyObject * obj3 = 0 ;
4582 char *kwnames[] = {
4583 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4584 };
4585
4586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4587 {
4588 arg1 = wxString_in_helper(obj0);
4589 if (arg1 == NULL) SWIG_fail;
4590 temp1 = true;
4591 }
4592 {
4593 arg2 = wxString_in_helper(obj1);
4594 if (arg2 == NULL) SWIG_fail;
4595 temp2 = true;
4596 }
4597 if (obj2) {
4598 {
4599 arg3 = wxString_in_helper(obj2);
4600 if (arg3 == NULL) SWIG_fail;
4601 temp3 = true;
4602 }
4603 }
4604 if (obj3) {
4605 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4606 if (SWIG_arg_fail(4)) SWIG_fail;
4607 }
4608 {
4609 if (!wxPyCheckForApp()) SWIG_fail;
4610 PyThreadState* __tstate = wxPyBeginAllowThreads();
4611 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4612
4613 wxPyEndAllowThreads(__tstate);
4614 if (PyErr_Occurred()) SWIG_fail;
4615 }
4616 {
4617 #if wxUSE_UNICODE
4618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4619 #else
4620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4621 #endif
4622 }
4623 {
4624 if (temp1)
4625 delete arg1;
4626 }
4627 {
4628 if (temp2)
4629 delete arg2;
4630 }
4631 {
4632 if (temp3)
4633 delete arg3;
4634 }
4635 return resultobj;
4636 fail:
4637 {
4638 if (temp1)
4639 delete arg1;
4640 }
4641 {
4642 if (temp2)
4643 delete arg2;
4644 }
4645 {
4646 if (temp3)
4647 delete arg3;
4648 }
4649 return NULL;
4650 }
4651
4652
4653 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4654 PyObject *resultobj;
4655 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4656 wxString *arg1 = (wxString *) &arg1_defvalue ;
4657 wxString const &arg2_defvalue = wxPyEmptyString ;
4658 wxString *arg2 = (wxString *) &arg2_defvalue ;
4659 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4660 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4661 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4662 wxWindow *arg5 = (wxWindow *) NULL ;
4663 wxString result;
4664 bool temp1 = false ;
4665 bool temp2 = false ;
4666 wxPoint temp4 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 PyObject * obj2 = 0 ;
4670 PyObject * obj3 = 0 ;
4671 PyObject * obj4 = 0 ;
4672 char *kwnames[] = {
4673 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4674 };
4675
4676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4677 if (obj0) {
4678 {
4679 arg1 = wxString_in_helper(obj0);
4680 if (arg1 == NULL) SWIG_fail;
4681 temp1 = true;
4682 }
4683 }
4684 if (obj1) {
4685 {
4686 arg2 = wxString_in_helper(obj1);
4687 if (arg2 == NULL) SWIG_fail;
4688 temp2 = true;
4689 }
4690 }
4691 if (obj2) {
4692 {
4693 arg3 = (long)(SWIG_As_long(obj2));
4694 if (SWIG_arg_fail(3)) SWIG_fail;
4695 }
4696 }
4697 if (obj3) {
4698 {
4699 arg4 = &temp4;
4700 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4701 }
4702 }
4703 if (obj4) {
4704 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4705 if (SWIG_arg_fail(5)) SWIG_fail;
4706 }
4707 {
4708 if (!wxPyCheckForApp()) SWIG_fail;
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4711
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 #if wxUSE_UNICODE
4717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4718 #else
4719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4720 #endif
4721 }
4722 {
4723 if (temp1)
4724 delete arg1;
4725 }
4726 {
4727 if (temp2)
4728 delete arg2;
4729 }
4730 return resultobj;
4731 fail:
4732 {
4733 if (temp1)
4734 delete arg1;
4735 }
4736 {
4737 if (temp2)
4738 delete arg2;
4739 }
4740 return NULL;
4741 }
4742
4743
4744 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4745 PyObject *resultobj;
4746 wxString *arg1 = 0 ;
4747 wxString const &arg2_defvalue = wxPyEmptyString ;
4748 wxString *arg2 = (wxString *) &arg2_defvalue ;
4749 wxString const &arg3_defvalue = wxPyEmptyString ;
4750 wxString *arg3 = (wxString *) &arg3_defvalue ;
4751 wxWindow *arg4 = (wxWindow *) NULL ;
4752 int arg5 = (int) -1 ;
4753 int arg6 = (int) -1 ;
4754 bool arg7 = (bool) true ;
4755 wxString result;
4756 bool temp1 = false ;
4757 bool temp2 = false ;
4758 bool temp3 = false ;
4759 PyObject * obj0 = 0 ;
4760 PyObject * obj1 = 0 ;
4761 PyObject * obj2 = 0 ;
4762 PyObject * obj3 = 0 ;
4763 PyObject * obj4 = 0 ;
4764 PyObject * obj5 = 0 ;
4765 PyObject * obj6 = 0 ;
4766 char *kwnames[] = {
4767 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4768 };
4769
4770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4771 {
4772 arg1 = wxString_in_helper(obj0);
4773 if (arg1 == NULL) SWIG_fail;
4774 temp1 = true;
4775 }
4776 if (obj1) {
4777 {
4778 arg2 = wxString_in_helper(obj1);
4779 if (arg2 == NULL) SWIG_fail;
4780 temp2 = true;
4781 }
4782 }
4783 if (obj2) {
4784 {
4785 arg3 = wxString_in_helper(obj2);
4786 if (arg3 == NULL) SWIG_fail;
4787 temp3 = true;
4788 }
4789 }
4790 if (obj3) {
4791 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4792 if (SWIG_arg_fail(4)) SWIG_fail;
4793 }
4794 if (obj4) {
4795 {
4796 arg5 = (int)(SWIG_As_int(obj4));
4797 if (SWIG_arg_fail(5)) SWIG_fail;
4798 }
4799 }
4800 if (obj5) {
4801 {
4802 arg6 = (int)(SWIG_As_int(obj5));
4803 if (SWIG_arg_fail(6)) SWIG_fail;
4804 }
4805 }
4806 if (obj6) {
4807 {
4808 arg7 = (bool)(SWIG_As_bool(obj6));
4809 if (SWIG_arg_fail(7)) SWIG_fail;
4810 }
4811 }
4812 {
4813 if (!wxPyCheckForApp()) SWIG_fail;
4814 PyThreadState* __tstate = wxPyBeginAllowThreads();
4815 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4816
4817 wxPyEndAllowThreads(__tstate);
4818 if (PyErr_Occurred()) SWIG_fail;
4819 }
4820 {
4821 #if wxUSE_UNICODE
4822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4823 #else
4824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4825 #endif
4826 }
4827 {
4828 if (temp1)
4829 delete arg1;
4830 }
4831 {
4832 if (temp2)
4833 delete arg2;
4834 }
4835 {
4836 if (temp3)
4837 delete arg3;
4838 }
4839 return resultobj;
4840 fail:
4841 {
4842 if (temp1)
4843 delete arg1;
4844 }
4845 {
4846 if (temp2)
4847 delete arg2;
4848 }
4849 {
4850 if (temp3)
4851 delete arg3;
4852 }
4853 return NULL;
4854 }
4855
4856
4857 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4858 PyObject *resultobj;
4859 wxString *arg1 = 0 ;
4860 wxString const &arg2_defvalue = wxPyEmptyString ;
4861 wxString *arg2 = (wxString *) &arg2_defvalue ;
4862 wxString const &arg3_defvalue = wxPyEmptyString ;
4863 wxString *arg3 = (wxString *) &arg3_defvalue ;
4864 wxWindow *arg4 = (wxWindow *) NULL ;
4865 wxString result;
4866 bool temp1 = false ;
4867 bool temp2 = false ;
4868 bool temp3 = false ;
4869 PyObject * obj0 = 0 ;
4870 PyObject * obj1 = 0 ;
4871 PyObject * obj2 = 0 ;
4872 PyObject * obj3 = 0 ;
4873 char *kwnames[] = {
4874 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4875 };
4876
4877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4878 {
4879 arg1 = wxString_in_helper(obj0);
4880 if (arg1 == NULL) SWIG_fail;
4881 temp1 = true;
4882 }
4883 if (obj1) {
4884 {
4885 arg2 = wxString_in_helper(obj1);
4886 if (arg2 == NULL) SWIG_fail;
4887 temp2 = true;
4888 }
4889 }
4890 if (obj2) {
4891 {
4892 arg3 = wxString_in_helper(obj2);
4893 if (arg3 == NULL) SWIG_fail;
4894 temp3 = true;
4895 }
4896 }
4897 if (obj3) {
4898 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4899 if (SWIG_arg_fail(4)) SWIG_fail;
4900 }
4901 {
4902 if (!wxPyCheckForApp()) SWIG_fail;
4903 PyThreadState* __tstate = wxPyBeginAllowThreads();
4904 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4905
4906 wxPyEndAllowThreads(__tstate);
4907 if (PyErr_Occurred()) SWIG_fail;
4908 }
4909 {
4910 #if wxUSE_UNICODE
4911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4912 #else
4913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4914 #endif
4915 }
4916 {
4917 if (temp1)
4918 delete arg1;
4919 }
4920 {
4921 if (temp2)
4922 delete arg2;
4923 }
4924 {
4925 if (temp3)
4926 delete arg3;
4927 }
4928 return resultobj;
4929 fail:
4930 {
4931 if (temp1)
4932 delete arg1;
4933 }
4934 {
4935 if (temp2)
4936 delete arg2;
4937 }
4938 {
4939 if (temp3)
4940 delete arg3;
4941 }
4942 return NULL;
4943 }
4944
4945
4946 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4947 PyObject *resultobj;
4948 wxString *arg1 = 0 ;
4949 wxString *arg2 = 0 ;
4950 int arg3 ;
4951 wxString *arg4 = (wxString *) 0 ;
4952 wxWindow *arg5 = (wxWindow *) NULL ;
4953 int arg6 = (int) -1 ;
4954 int arg7 = (int) -1 ;
4955 bool arg8 = (bool) true ;
4956 int arg9 = (int) 150 ;
4957 int arg10 = (int) 200 ;
4958 wxString result;
4959 bool temp1 = false ;
4960 bool temp2 = false ;
4961 PyObject * obj0 = 0 ;
4962 PyObject * obj1 = 0 ;
4963 PyObject * obj2 = 0 ;
4964 PyObject * obj3 = 0 ;
4965 PyObject * obj4 = 0 ;
4966 PyObject * obj5 = 0 ;
4967 PyObject * obj6 = 0 ;
4968 PyObject * obj7 = 0 ;
4969 PyObject * obj8 = 0 ;
4970 char *kwnames[] = {
4971 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
4972 };
4973
4974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4975 {
4976 arg1 = wxString_in_helper(obj0);
4977 if (arg1 == NULL) SWIG_fail;
4978 temp1 = true;
4979 }
4980 {
4981 arg2 = wxString_in_helper(obj1);
4982 if (arg2 == NULL) SWIG_fail;
4983 temp2 = true;
4984 }
4985 {
4986 arg3 = PyList_Size(obj2);
4987 arg4 = wxString_LIST_helper(obj2);
4988 if (arg4 == NULL) SWIG_fail;
4989 }
4990 if (obj3) {
4991 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4992 if (SWIG_arg_fail(5)) SWIG_fail;
4993 }
4994 if (obj4) {
4995 {
4996 arg6 = (int)(SWIG_As_int(obj4));
4997 if (SWIG_arg_fail(6)) SWIG_fail;
4998 }
4999 }
5000 if (obj5) {
5001 {
5002 arg7 = (int)(SWIG_As_int(obj5));
5003 if (SWIG_arg_fail(7)) SWIG_fail;
5004 }
5005 }
5006 if (obj6) {
5007 {
5008 arg8 = (bool)(SWIG_As_bool(obj6));
5009 if (SWIG_arg_fail(8)) SWIG_fail;
5010 }
5011 }
5012 if (obj7) {
5013 {
5014 arg9 = (int)(SWIG_As_int(obj7));
5015 if (SWIG_arg_fail(9)) SWIG_fail;
5016 }
5017 }
5018 if (obj8) {
5019 {
5020 arg10 = (int)(SWIG_As_int(obj8));
5021 if (SWIG_arg_fail(10)) SWIG_fail;
5022 }
5023 }
5024 {
5025 if (!wxPyCheckForApp()) SWIG_fail;
5026 PyThreadState* __tstate = wxPyBeginAllowThreads();
5027 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5028
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 {
5033 #if wxUSE_UNICODE
5034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5035 #else
5036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5037 #endif
5038 }
5039 {
5040 if (temp1)
5041 delete arg1;
5042 }
5043 {
5044 if (temp2)
5045 delete arg2;
5046 }
5047 {
5048 if (arg4) delete [] arg4;
5049 }
5050 return resultobj;
5051 fail:
5052 {
5053 if (temp1)
5054 delete arg1;
5055 }
5056 {
5057 if (temp2)
5058 delete arg2;
5059 }
5060 {
5061 if (arg4) delete [] arg4;
5062 }
5063 return NULL;
5064 }
5065
5066
5067 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5068 PyObject *resultobj;
5069 wxString *arg1 = 0 ;
5070 wxString *arg2 = 0 ;
5071 int arg3 ;
5072 wxString *arg4 = (wxString *) 0 ;
5073 wxWindow *arg5 = (wxWindow *) NULL ;
5074 int arg6 = (int) -1 ;
5075 int arg7 = (int) -1 ;
5076 bool arg8 = (bool) true ;
5077 int arg9 = (int) 150 ;
5078 int arg10 = (int) 200 ;
5079 int result;
5080 bool temp1 = false ;
5081 bool temp2 = false ;
5082 PyObject * obj0 = 0 ;
5083 PyObject * obj1 = 0 ;
5084 PyObject * obj2 = 0 ;
5085 PyObject * obj3 = 0 ;
5086 PyObject * obj4 = 0 ;
5087 PyObject * obj5 = 0 ;
5088 PyObject * obj6 = 0 ;
5089 PyObject * obj7 = 0 ;
5090 PyObject * obj8 = 0 ;
5091 char *kwnames[] = {
5092 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5093 };
5094
5095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5096 {
5097 arg1 = wxString_in_helper(obj0);
5098 if (arg1 == NULL) SWIG_fail;
5099 temp1 = true;
5100 }
5101 {
5102 arg2 = wxString_in_helper(obj1);
5103 if (arg2 == NULL) SWIG_fail;
5104 temp2 = true;
5105 }
5106 {
5107 arg3 = PyList_Size(obj2);
5108 arg4 = wxString_LIST_helper(obj2);
5109 if (arg4 == NULL) SWIG_fail;
5110 }
5111 if (obj3) {
5112 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5113 if (SWIG_arg_fail(5)) SWIG_fail;
5114 }
5115 if (obj4) {
5116 {
5117 arg6 = (int)(SWIG_As_int(obj4));
5118 if (SWIG_arg_fail(6)) SWIG_fail;
5119 }
5120 }
5121 if (obj5) {
5122 {
5123 arg7 = (int)(SWIG_As_int(obj5));
5124 if (SWIG_arg_fail(7)) SWIG_fail;
5125 }
5126 }
5127 if (obj6) {
5128 {
5129 arg8 = (bool)(SWIG_As_bool(obj6));
5130 if (SWIG_arg_fail(8)) SWIG_fail;
5131 }
5132 }
5133 if (obj7) {
5134 {
5135 arg9 = (int)(SWIG_As_int(obj7));
5136 if (SWIG_arg_fail(9)) SWIG_fail;
5137 }
5138 }
5139 if (obj8) {
5140 {
5141 arg10 = (int)(SWIG_As_int(obj8));
5142 if (SWIG_arg_fail(10)) SWIG_fail;
5143 }
5144 }
5145 {
5146 if (!wxPyCheckForApp()) SWIG_fail;
5147 PyThreadState* __tstate = wxPyBeginAllowThreads();
5148 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5149
5150 wxPyEndAllowThreads(__tstate);
5151 if (PyErr_Occurred()) SWIG_fail;
5152 }
5153 {
5154 resultobj = SWIG_From_int((int)(result));
5155 }
5156 {
5157 if (temp1)
5158 delete arg1;
5159 }
5160 {
5161 if (temp2)
5162 delete arg2;
5163 }
5164 {
5165 if (arg4) delete [] arg4;
5166 }
5167 return resultobj;
5168 fail:
5169 {
5170 if (temp1)
5171 delete arg1;
5172 }
5173 {
5174 if (temp2)
5175 delete arg2;
5176 }
5177 {
5178 if (arg4) delete [] arg4;
5179 }
5180 return NULL;
5181 }
5182
5183
5184 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5185 PyObject *resultobj;
5186 wxString *arg1 = 0 ;
5187 wxString const &arg2_defvalue = wxPyEmptyString ;
5188 wxString *arg2 = (wxString *) &arg2_defvalue ;
5189 int arg3 = (int) wxOK|wxCENTRE ;
5190 wxWindow *arg4 = (wxWindow *) NULL ;
5191 int arg5 = (int) -1 ;
5192 int arg6 = (int) -1 ;
5193 int result;
5194 bool temp1 = false ;
5195 bool temp2 = false ;
5196 PyObject * obj0 = 0 ;
5197 PyObject * obj1 = 0 ;
5198 PyObject * obj2 = 0 ;
5199 PyObject * obj3 = 0 ;
5200 PyObject * obj4 = 0 ;
5201 PyObject * obj5 = 0 ;
5202 char *kwnames[] = {
5203 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5204 };
5205
5206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5207 {
5208 arg1 = wxString_in_helper(obj0);
5209 if (arg1 == NULL) SWIG_fail;
5210 temp1 = true;
5211 }
5212 if (obj1) {
5213 {
5214 arg2 = wxString_in_helper(obj1);
5215 if (arg2 == NULL) SWIG_fail;
5216 temp2 = true;
5217 }
5218 }
5219 if (obj2) {
5220 {
5221 arg3 = (int)(SWIG_As_int(obj2));
5222 if (SWIG_arg_fail(3)) SWIG_fail;
5223 }
5224 }
5225 if (obj3) {
5226 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5227 if (SWIG_arg_fail(4)) SWIG_fail;
5228 }
5229 if (obj4) {
5230 {
5231 arg5 = (int)(SWIG_As_int(obj4));
5232 if (SWIG_arg_fail(5)) SWIG_fail;
5233 }
5234 }
5235 if (obj5) {
5236 {
5237 arg6 = (int)(SWIG_As_int(obj5));
5238 if (SWIG_arg_fail(6)) SWIG_fail;
5239 }
5240 }
5241 {
5242 if (!wxPyCheckForApp()) SWIG_fail;
5243 PyThreadState* __tstate = wxPyBeginAllowThreads();
5244 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5245
5246 wxPyEndAllowThreads(__tstate);
5247 if (PyErr_Occurred()) SWIG_fail;
5248 }
5249 {
5250 resultobj = SWIG_From_int((int)(result));
5251 }
5252 {
5253 if (temp1)
5254 delete arg1;
5255 }
5256 {
5257 if (temp2)
5258 delete arg2;
5259 }
5260 return resultobj;
5261 fail:
5262 {
5263 if (temp1)
5264 delete arg1;
5265 }
5266 {
5267 if (temp2)
5268 delete arg2;
5269 }
5270 return NULL;
5271 }
5272
5273
5274 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5275 PyObject *resultobj;
5276 wxString *arg1 = 0 ;
5277 wxString *arg2 = 0 ;
5278 wxString *arg3 = 0 ;
5279 long arg4 ;
5280 long arg5 = (long) 0 ;
5281 long arg6 = (long) 100 ;
5282 wxWindow *arg7 = (wxWindow *) NULL ;
5283 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5284 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5285 long result;
5286 bool temp1 = false ;
5287 bool temp2 = false ;
5288 bool temp3 = false ;
5289 wxPoint temp8 ;
5290 PyObject * obj0 = 0 ;
5291 PyObject * obj1 = 0 ;
5292 PyObject * obj2 = 0 ;
5293 PyObject * obj3 = 0 ;
5294 PyObject * obj4 = 0 ;
5295 PyObject * obj5 = 0 ;
5296 PyObject * obj6 = 0 ;
5297 PyObject * obj7 = 0 ;
5298 char *kwnames[] = {
5299 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5300 };
5301
5302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5303 {
5304 arg1 = wxString_in_helper(obj0);
5305 if (arg1 == NULL) SWIG_fail;
5306 temp1 = true;
5307 }
5308 {
5309 arg2 = wxString_in_helper(obj1);
5310 if (arg2 == NULL) SWIG_fail;
5311 temp2 = true;
5312 }
5313 {
5314 arg3 = wxString_in_helper(obj2);
5315 if (arg3 == NULL) SWIG_fail;
5316 temp3 = true;
5317 }
5318 {
5319 arg4 = (long)(SWIG_As_long(obj3));
5320 if (SWIG_arg_fail(4)) SWIG_fail;
5321 }
5322 if (obj4) {
5323 {
5324 arg5 = (long)(SWIG_As_long(obj4));
5325 if (SWIG_arg_fail(5)) SWIG_fail;
5326 }
5327 }
5328 if (obj5) {
5329 {
5330 arg6 = (long)(SWIG_As_long(obj5));
5331 if (SWIG_arg_fail(6)) SWIG_fail;
5332 }
5333 }
5334 if (obj6) {
5335 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5336 if (SWIG_arg_fail(7)) SWIG_fail;
5337 }
5338 if (obj7) {
5339 {
5340 arg8 = &temp8;
5341 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5342 }
5343 }
5344 {
5345 if (!wxPyCheckForApp()) SWIG_fail;
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5348
5349 wxPyEndAllowThreads(__tstate);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 {
5353 resultobj = SWIG_From_long((long)(result));
5354 }
5355 {
5356 if (temp1)
5357 delete arg1;
5358 }
5359 {
5360 if (temp2)
5361 delete arg2;
5362 }
5363 {
5364 if (temp3)
5365 delete arg3;
5366 }
5367 return resultobj;
5368 fail:
5369 {
5370 if (temp1)
5371 delete arg1;
5372 }
5373 {
5374 if (temp2)
5375 delete arg2;
5376 }
5377 {
5378 if (temp3)
5379 delete arg3;
5380 }
5381 return NULL;
5382 }
5383
5384
5385 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5386 PyObject *resultobj;
5387 bool result;
5388 char *kwnames[] = {
5389 NULL
5390 };
5391
5392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5393 {
5394 if (!wxPyCheckForApp()) SWIG_fail;
5395 PyThreadState* __tstate = wxPyBeginAllowThreads();
5396 result = (bool)wxColourDisplay();
5397
5398 wxPyEndAllowThreads(__tstate);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 {
5402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5403 }
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj;
5412 int result;
5413 char *kwnames[] = {
5414 NULL
5415 };
5416
5417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5418 {
5419 if (!wxPyCheckForApp()) SWIG_fail;
5420 PyThreadState* __tstate = wxPyBeginAllowThreads();
5421 result = (int)wxDisplayDepth();
5422
5423 wxPyEndAllowThreads(__tstate);
5424 if (PyErr_Occurred()) SWIG_fail;
5425 }
5426 {
5427 resultobj = SWIG_From_int((int)(result));
5428 }
5429 return resultobj;
5430 fail:
5431 return NULL;
5432 }
5433
5434
5435 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5436 PyObject *resultobj;
5437 int result;
5438 char *kwnames[] = {
5439 NULL
5440 };
5441
5442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5443 {
5444 if (!wxPyCheckForApp()) SWIG_fail;
5445 PyThreadState* __tstate = wxPyBeginAllowThreads();
5446 result = (int)wxGetDisplayDepth();
5447
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 {
5452 resultobj = SWIG_From_int((int)(result));
5453 }
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5461 PyObject *resultobj;
5462 int *arg1 = (int *) 0 ;
5463 int *arg2 = (int *) 0 ;
5464 int temp1 ;
5465 int res1 = 0 ;
5466 int temp2 ;
5467 int res2 = 0 ;
5468 char *kwnames[] = {
5469 NULL
5470 };
5471
5472 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5473 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5475 {
5476 if (!wxPyCheckForApp()) SWIG_fail;
5477 PyThreadState* __tstate = wxPyBeginAllowThreads();
5478 wxDisplaySize(arg1,arg2);
5479
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 Py_INCREF(Py_None); resultobj = Py_None;
5484 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5485 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5486 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5487 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5488 return resultobj;
5489 fail:
5490 return NULL;
5491 }
5492
5493
5494 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5495 PyObject *resultobj;
5496 wxSize result;
5497 char *kwnames[] = {
5498 NULL
5499 };
5500
5501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5502 {
5503 if (!wxPyCheckForApp()) SWIG_fail;
5504 PyThreadState* __tstate = wxPyBeginAllowThreads();
5505 result = wxGetDisplaySize();
5506
5507 wxPyEndAllowThreads(__tstate);
5508 if (PyErr_Occurred()) SWIG_fail;
5509 }
5510 {
5511 wxSize * resultptr;
5512 resultptr = new wxSize((wxSize &)(result));
5513 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5514 }
5515 return resultobj;
5516 fail:
5517 return NULL;
5518 }
5519
5520
5521 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5522 PyObject *resultobj;
5523 int *arg1 = (int *) 0 ;
5524 int *arg2 = (int *) 0 ;
5525 int temp1 ;
5526 int res1 = 0 ;
5527 int temp2 ;
5528 int res2 = 0 ;
5529 char *kwnames[] = {
5530 NULL
5531 };
5532
5533 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5534 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5536 {
5537 if (!wxPyCheckForApp()) SWIG_fail;
5538 PyThreadState* __tstate = wxPyBeginAllowThreads();
5539 wxDisplaySizeMM(arg1,arg2);
5540
5541 wxPyEndAllowThreads(__tstate);
5542 if (PyErr_Occurred()) SWIG_fail;
5543 }
5544 Py_INCREF(Py_None); resultobj = Py_None;
5545 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5546 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5547 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5548 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5556 PyObject *resultobj;
5557 wxSize result;
5558 char *kwnames[] = {
5559 NULL
5560 };
5561
5562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5563 {
5564 if (!wxPyCheckForApp()) SWIG_fail;
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = wxGetDisplaySizeMM();
5567
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 {
5572 wxSize * resultptr;
5573 resultptr = new wxSize((wxSize &)(result));
5574 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5575 }
5576 return resultobj;
5577 fail:
5578 return NULL;
5579 }
5580
5581
5582 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5583 PyObject *resultobj;
5584 int *arg1 = (int *) 0 ;
5585 int *arg2 = (int *) 0 ;
5586 int *arg3 = (int *) 0 ;
5587 int *arg4 = (int *) 0 ;
5588 int temp1 ;
5589 int res1 = 0 ;
5590 int temp2 ;
5591 int res2 = 0 ;
5592 int temp3 ;
5593 int res3 = 0 ;
5594 int temp4 ;
5595 int res4 = 0 ;
5596 char *kwnames[] = {
5597 NULL
5598 };
5599
5600 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5601 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5602 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5603 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5605 {
5606 if (!wxPyCheckForApp()) SWIG_fail;
5607 PyThreadState* __tstate = wxPyBeginAllowThreads();
5608 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5609
5610 wxPyEndAllowThreads(__tstate);
5611 if (PyErr_Occurred()) SWIG_fail;
5612 }
5613 Py_INCREF(Py_None); resultobj = Py_None;
5614 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5615 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5616 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5617 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5618 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5619 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5620 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5621 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5622 return resultobj;
5623 fail:
5624 return NULL;
5625 }
5626
5627
5628 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5629 PyObject *resultobj;
5630 wxRect result;
5631 char *kwnames[] = {
5632 NULL
5633 };
5634
5635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5636 {
5637 if (!wxPyCheckForApp()) SWIG_fail;
5638 PyThreadState* __tstate = wxPyBeginAllowThreads();
5639 result = wxGetClientDisplayRect();
5640
5641 wxPyEndAllowThreads(__tstate);
5642 if (PyErr_Occurred()) SWIG_fail;
5643 }
5644 {
5645 wxRect * resultptr;
5646 resultptr = new wxRect((wxRect &)(result));
5647 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5648 }
5649 return resultobj;
5650 fail:
5651 return NULL;
5652 }
5653
5654
5655 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5656 PyObject *resultobj;
5657 wxCursor *arg1 = 0 ;
5658 PyObject * obj0 = 0 ;
5659 char *kwnames[] = {
5660 (char *) "cursor", NULL
5661 };
5662
5663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5664 {
5665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5666 if (SWIG_arg_fail(1)) SWIG_fail;
5667 if (arg1 == NULL) {
5668 SWIG_null_ref("wxCursor");
5669 }
5670 if (SWIG_arg_fail(1)) SWIG_fail;
5671 }
5672 {
5673 if (!wxPyCheckForApp()) SWIG_fail;
5674 PyThreadState* __tstate = wxPyBeginAllowThreads();
5675 wxSetCursor(*arg1);
5676
5677 wxPyEndAllowThreads(__tstate);
5678 if (PyErr_Occurred()) SWIG_fail;
5679 }
5680 Py_INCREF(Py_None); resultobj = Py_None;
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5688 PyObject *resultobj;
5689 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5690 PyObject * obj0 = 0 ;
5691 char *kwnames[] = {
5692 (char *) "cursor", NULL
5693 };
5694
5695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5696 if (obj0) {
5697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5698 if (SWIG_arg_fail(1)) SWIG_fail;
5699 }
5700 {
5701 if (!wxPyCheckForApp()) SWIG_fail;
5702 PyThreadState* __tstate = wxPyBeginAllowThreads();
5703 wxBeginBusyCursor(arg1);
5704
5705 wxPyEndAllowThreads(__tstate);
5706 if (PyErr_Occurred()) SWIG_fail;
5707 }
5708 Py_INCREF(Py_None); resultobj = Py_None;
5709 return resultobj;
5710 fail:
5711 return NULL;
5712 }
5713
5714
5715 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj;
5717 wxWindow *result;
5718 char *kwnames[] = {
5719 NULL
5720 };
5721
5722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5723 {
5724 if (!wxPyCheckForApp()) SWIG_fail;
5725 PyThreadState* __tstate = wxPyBeginAllowThreads();
5726 result = (wxWindow *)wxGetActiveWindow();
5727
5728 wxPyEndAllowThreads(__tstate);
5729 if (PyErr_Occurred()) SWIG_fail;
5730 }
5731 {
5732 resultobj = wxPyMake_wxObject(result, 0);
5733 }
5734 return resultobj;
5735 fail:
5736 return NULL;
5737 }
5738
5739
5740 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5741 PyObject *resultobj;
5742 wxPoint *arg1 = 0 ;
5743 wxWindow *result;
5744 wxPoint temp1 ;
5745 PyObject * obj0 = 0 ;
5746 char *kwnames[] = {
5747 (char *) "pt", NULL
5748 };
5749
5750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5751 {
5752 arg1 = &temp1;
5753 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5754 }
5755 {
5756 if (!wxPyCheckForApp()) SWIG_fail;
5757 PyThreadState* __tstate = wxPyBeginAllowThreads();
5758 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5759
5760 wxPyEndAllowThreads(__tstate);
5761 if (PyErr_Occurred()) SWIG_fail;
5762 }
5763 {
5764 resultobj = wxPyMake_wxObject(result, 0);
5765 }
5766 return resultobj;
5767 fail:
5768 return NULL;
5769 }
5770
5771
5772 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj;
5774 wxPoint *arg1 = 0 ;
5775 wxWindow *result;
5776 wxPoint temp1 ;
5777 PyObject * obj0 = 0 ;
5778 char *kwnames[] = {
5779 (char *) "pt", NULL
5780 };
5781
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5783 {
5784 arg1 = &temp1;
5785 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5786 }
5787 {
5788 if (!wxPyCheckForApp()) SWIG_fail;
5789 PyThreadState* __tstate = wxPyBeginAllowThreads();
5790 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5791
5792 wxPyEndAllowThreads(__tstate);
5793 if (PyErr_Occurred()) SWIG_fail;
5794 }
5795 {
5796 resultobj = wxPyMake_wxObject(result, 0);
5797 }
5798 return resultobj;
5799 fail:
5800 return NULL;
5801 }
5802
5803
5804 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5805 PyObject *resultobj;
5806 wxWindow *arg1 = (wxWindow *) 0 ;
5807 wxWindow *result;
5808 PyObject * obj0 = 0 ;
5809 char *kwnames[] = {
5810 (char *) "win", NULL
5811 };
5812
5813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5815 if (SWIG_arg_fail(1)) SWIG_fail;
5816 {
5817 if (!wxPyCheckForApp()) SWIG_fail;
5818 PyThreadState* __tstate = wxPyBeginAllowThreads();
5819 result = (wxWindow *)wxGetTopLevelParent(arg1);
5820
5821 wxPyEndAllowThreads(__tstate);
5822 if (PyErr_Occurred()) SWIG_fail;
5823 }
5824 {
5825 resultobj = wxPyMake_wxObject(result, 0);
5826 }
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5834 PyObject *resultobj;
5835 wxKeyCode arg1 ;
5836 bool result;
5837 PyObject * obj0 = 0 ;
5838 char *kwnames[] = {
5839 (char *) "key", NULL
5840 };
5841
5842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5843 {
5844 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5845 if (SWIG_arg_fail(1)) SWIG_fail;
5846 }
5847 {
5848 if (!wxPyCheckForApp()) SWIG_fail;
5849 PyThreadState* __tstate = wxPyBeginAllowThreads();
5850 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5851
5852 wxPyEndAllowThreads(__tstate);
5853 if (PyErr_Occurred()) SWIG_fail;
5854 }
5855 {
5856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5857 }
5858 return resultobj;
5859 fail:
5860 return NULL;
5861 }
5862
5863
5864 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5865 PyObject *resultobj;
5866 char *kwnames[] = {
5867 NULL
5868 };
5869
5870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5871 {
5872 if (!wxPyCheckForApp()) SWIG_fail;
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 wxWakeUpMainThread();
5875
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 Py_INCREF(Py_None); resultobj = Py_None;
5880 return resultobj;
5881 fail:
5882 return NULL;
5883 }
5884
5885
5886 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5887 PyObject *resultobj;
5888 char *kwnames[] = {
5889 NULL
5890 };
5891
5892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5893 {
5894 if (!wxPyCheckForApp()) SWIG_fail;
5895 PyThreadState* __tstate = wxPyBeginAllowThreads();
5896 wxMutexGuiEnter();
5897
5898 wxPyEndAllowThreads(__tstate);
5899 if (PyErr_Occurred()) SWIG_fail;
5900 }
5901 Py_INCREF(Py_None); resultobj = Py_None;
5902 return resultobj;
5903 fail:
5904 return NULL;
5905 }
5906
5907
5908 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5909 PyObject *resultobj;
5910 char *kwnames[] = {
5911 NULL
5912 };
5913
5914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5915 {
5916 if (!wxPyCheckForApp()) SWIG_fail;
5917 PyThreadState* __tstate = wxPyBeginAllowThreads();
5918 wxMutexGuiLeave();
5919
5920 wxPyEndAllowThreads(__tstate);
5921 if (PyErr_Occurred()) SWIG_fail;
5922 }
5923 Py_INCREF(Py_None); resultobj = Py_None;
5924 return resultobj;
5925 fail:
5926 return NULL;
5927 }
5928
5929
5930 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5931 PyObject *resultobj;
5932 wxMutexGuiLocker *result;
5933 char *kwnames[] = {
5934 NULL
5935 };
5936
5937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5938 {
5939 if (!wxPyCheckForApp()) SWIG_fail;
5940 PyThreadState* __tstate = wxPyBeginAllowThreads();
5941 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5942
5943 wxPyEndAllowThreads(__tstate);
5944 if (PyErr_Occurred()) SWIG_fail;
5945 }
5946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5947 return resultobj;
5948 fail:
5949 return NULL;
5950 }
5951
5952
5953 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5954 PyObject *resultobj;
5955 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5956 PyObject * obj0 = 0 ;
5957 char *kwnames[] = {
5958 (char *) "self", NULL
5959 };
5960
5961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5963 if (SWIG_arg_fail(1)) SWIG_fail;
5964 {
5965 PyThreadState* __tstate = wxPyBeginAllowThreads();
5966 delete arg1;
5967
5968 wxPyEndAllowThreads(__tstate);
5969 if (PyErr_Occurred()) SWIG_fail;
5970 }
5971 Py_INCREF(Py_None); resultobj = Py_None;
5972 return resultobj;
5973 fail:
5974 return NULL;
5975 }
5976
5977
5978 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
5979 PyObject *obj;
5980 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5981 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
5982 Py_INCREF(obj);
5983 return Py_BuildValue((char *)"");
5984 }
5985 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
5986 PyObject *resultobj;
5987 bool result;
5988 char *kwnames[] = {
5989 NULL
5990 };
5991
5992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
5993 {
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 result = (bool)wxThread_IsMain();
5996
5997 wxPyEndAllowThreads(__tstate);
5998 if (PyErr_Occurred()) SWIG_fail;
5999 }
6000 {
6001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6002 }
6003 return resultobj;
6004 fail:
6005 return NULL;
6006 }
6007
6008
6009 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj;
6011 wxString *arg1 = 0 ;
6012 wxToolTip *result;
6013 bool temp1 = false ;
6014 PyObject * obj0 = 0 ;
6015 char *kwnames[] = {
6016 (char *) "tip", NULL
6017 };
6018
6019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6020 {
6021 arg1 = wxString_in_helper(obj0);
6022 if (arg1 == NULL) SWIG_fail;
6023 temp1 = true;
6024 }
6025 {
6026 if (!wxPyCheckForApp()) SWIG_fail;
6027 PyThreadState* __tstate = wxPyBeginAllowThreads();
6028 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6029
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 {
6034 resultobj = wxPyMake_wxObject(result, 1);
6035 }
6036 {
6037 if (temp1)
6038 delete arg1;
6039 }
6040 return resultobj;
6041 fail:
6042 {
6043 if (temp1)
6044 delete arg1;
6045 }
6046 return NULL;
6047 }
6048
6049
6050 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj;
6052 wxToolTip *arg1 = (wxToolTip *) 0 ;
6053 wxString *arg2 = 0 ;
6054 bool temp2 = false ;
6055 PyObject * obj0 = 0 ;
6056 PyObject * obj1 = 0 ;
6057 char *kwnames[] = {
6058 (char *) "self",(char *) "tip", NULL
6059 };
6060
6061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6063 if (SWIG_arg_fail(1)) SWIG_fail;
6064 {
6065 arg2 = wxString_in_helper(obj1);
6066 if (arg2 == NULL) SWIG_fail;
6067 temp2 = true;
6068 }
6069 {
6070 PyThreadState* __tstate = wxPyBeginAllowThreads();
6071 (arg1)->SetTip((wxString const &)*arg2);
6072
6073 wxPyEndAllowThreads(__tstate);
6074 if (PyErr_Occurred()) SWIG_fail;
6075 }
6076 Py_INCREF(Py_None); resultobj = Py_None;
6077 {
6078 if (temp2)
6079 delete arg2;
6080 }
6081 return resultobj;
6082 fail:
6083 {
6084 if (temp2)
6085 delete arg2;
6086 }
6087 return NULL;
6088 }
6089
6090
6091 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6092 PyObject *resultobj;
6093 wxToolTip *arg1 = (wxToolTip *) 0 ;
6094 wxString result;
6095 PyObject * obj0 = 0 ;
6096 char *kwnames[] = {
6097 (char *) "self", NULL
6098 };
6099
6100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6102 if (SWIG_arg_fail(1)) SWIG_fail;
6103 {
6104 PyThreadState* __tstate = wxPyBeginAllowThreads();
6105 result = (arg1)->GetTip();
6106
6107 wxPyEndAllowThreads(__tstate);
6108 if (PyErr_Occurred()) SWIG_fail;
6109 }
6110 {
6111 #if wxUSE_UNICODE
6112 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6113 #else
6114 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6115 #endif
6116 }
6117 return resultobj;
6118 fail:
6119 return NULL;
6120 }
6121
6122
6123 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6124 PyObject *resultobj;
6125 wxToolTip *arg1 = (wxToolTip *) 0 ;
6126 wxWindow *result;
6127 PyObject * obj0 = 0 ;
6128 char *kwnames[] = {
6129 (char *) "self", NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6134 if (SWIG_arg_fail(1)) SWIG_fail;
6135 {
6136 PyThreadState* __tstate = wxPyBeginAllowThreads();
6137 result = (wxWindow *)(arg1)->GetWindow();
6138
6139 wxPyEndAllowThreads(__tstate);
6140 if (PyErr_Occurred()) SWIG_fail;
6141 }
6142 {
6143 resultobj = wxPyMake_wxObject(result, 0);
6144 }
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj;
6153 bool arg1 ;
6154 PyObject * obj0 = 0 ;
6155 char *kwnames[] = {
6156 (char *) "flag", NULL
6157 };
6158
6159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6160 {
6161 arg1 = (bool)(SWIG_As_bool(obj0));
6162 if (SWIG_arg_fail(1)) SWIG_fail;
6163 }
6164 {
6165 PyThreadState* __tstate = wxPyBeginAllowThreads();
6166 wxToolTip::Enable(arg1);
6167
6168 wxPyEndAllowThreads(__tstate);
6169 if (PyErr_Occurred()) SWIG_fail;
6170 }
6171 Py_INCREF(Py_None); resultobj = Py_None;
6172 return resultobj;
6173 fail:
6174 return NULL;
6175 }
6176
6177
6178 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6179 PyObject *resultobj;
6180 long arg1 ;
6181 PyObject * obj0 = 0 ;
6182 char *kwnames[] = {
6183 (char *) "milliseconds", NULL
6184 };
6185
6186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6187 {
6188 arg1 = (long)(SWIG_As_long(obj0));
6189 if (SWIG_arg_fail(1)) SWIG_fail;
6190 }
6191 {
6192 PyThreadState* __tstate = wxPyBeginAllowThreads();
6193 wxToolTip::SetDelay(arg1);
6194
6195 wxPyEndAllowThreads(__tstate);
6196 if (PyErr_Occurred()) SWIG_fail;
6197 }
6198 Py_INCREF(Py_None); resultobj = Py_None;
6199 return resultobj;
6200 fail:
6201 return NULL;
6202 }
6203
6204
6205 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6206 PyObject *obj;
6207 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6208 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6209 Py_INCREF(obj);
6210 return Py_BuildValue((char *)"");
6211 }
6212 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6213 PyObject *resultobj;
6214 wxWindow *arg1 = (wxWindow *) 0 ;
6215 wxSize *arg2 = 0 ;
6216 wxCaret *result;
6217 wxSize temp2 ;
6218 PyObject * obj0 = 0 ;
6219 PyObject * obj1 = 0 ;
6220 char *kwnames[] = {
6221 (char *) "window",(char *) "size", NULL
6222 };
6223
6224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6226 if (SWIG_arg_fail(1)) SWIG_fail;
6227 {
6228 arg2 = &temp2;
6229 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6230 }
6231 {
6232 if (!wxPyCheckForApp()) SWIG_fail;
6233 PyThreadState* __tstate = wxPyBeginAllowThreads();
6234 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6235
6236 wxPyEndAllowThreads(__tstate);
6237 if (PyErr_Occurred()) SWIG_fail;
6238 }
6239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6240 return resultobj;
6241 fail:
6242 return NULL;
6243 }
6244
6245
6246 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6247 PyObject *resultobj;
6248 wxCaret *arg1 = (wxCaret *) 0 ;
6249 PyObject * obj0 = 0 ;
6250 char *kwnames[] = {
6251 (char *) "self", NULL
6252 };
6253
6254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
6255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6256 if (SWIG_arg_fail(1)) SWIG_fail;
6257 {
6258 PyThreadState* __tstate = wxPyBeginAllowThreads();
6259 delete arg1;
6260
6261 wxPyEndAllowThreads(__tstate);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 Py_INCREF(Py_None); resultobj = Py_None;
6265 return resultobj;
6266 fail:
6267 return NULL;
6268 }
6269
6270
6271 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj;
6273 wxCaret *arg1 = (wxCaret *) 0 ;
6274 bool result;
6275 PyObject * obj0 = 0 ;
6276 char *kwnames[] = {
6277 (char *) "self", NULL
6278 };
6279
6280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6282 if (SWIG_arg_fail(1)) SWIG_fail;
6283 {
6284 PyThreadState* __tstate = wxPyBeginAllowThreads();
6285 result = (bool)(arg1)->IsOk();
6286
6287 wxPyEndAllowThreads(__tstate);
6288 if (PyErr_Occurred()) SWIG_fail;
6289 }
6290 {
6291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6292 }
6293 return resultobj;
6294 fail:
6295 return NULL;
6296 }
6297
6298
6299 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6300 PyObject *resultobj;
6301 wxCaret *arg1 = (wxCaret *) 0 ;
6302 bool result;
6303 PyObject * obj0 = 0 ;
6304 char *kwnames[] = {
6305 (char *) "self", NULL
6306 };
6307
6308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6310 if (SWIG_arg_fail(1)) SWIG_fail;
6311 {
6312 PyThreadState* __tstate = wxPyBeginAllowThreads();
6313 result = (bool)(arg1)->IsVisible();
6314
6315 wxPyEndAllowThreads(__tstate);
6316 if (PyErr_Occurred()) SWIG_fail;
6317 }
6318 {
6319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6320 }
6321 return resultobj;
6322 fail:
6323 return NULL;
6324 }
6325
6326
6327 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6328 PyObject *resultobj;
6329 wxCaret *arg1 = (wxCaret *) 0 ;
6330 wxPoint result;
6331 PyObject * obj0 = 0 ;
6332 char *kwnames[] = {
6333 (char *) "self", NULL
6334 };
6335
6336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6338 if (SWIG_arg_fail(1)) SWIG_fail;
6339 {
6340 PyThreadState* __tstate = wxPyBeginAllowThreads();
6341 result = (arg1)->GetPosition();
6342
6343 wxPyEndAllowThreads(__tstate);
6344 if (PyErr_Occurred()) SWIG_fail;
6345 }
6346 {
6347 wxPoint * resultptr;
6348 resultptr = new wxPoint((wxPoint &)(result));
6349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6350 }
6351 return resultobj;
6352 fail:
6353 return NULL;
6354 }
6355
6356
6357 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6358 PyObject *resultobj;
6359 wxCaret *arg1 = (wxCaret *) 0 ;
6360 int *arg2 = (int *) 0 ;
6361 int *arg3 = (int *) 0 ;
6362 int temp2 ;
6363 int res2 = 0 ;
6364 int temp3 ;
6365 int res3 = 0 ;
6366 PyObject * obj0 = 0 ;
6367 char *kwnames[] = {
6368 (char *) "self", NULL
6369 };
6370
6371 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6372 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6375 if (SWIG_arg_fail(1)) SWIG_fail;
6376 {
6377 PyThreadState* __tstate = wxPyBeginAllowThreads();
6378 (arg1)->GetPosition(arg2,arg3);
6379
6380 wxPyEndAllowThreads(__tstate);
6381 if (PyErr_Occurred()) SWIG_fail;
6382 }
6383 Py_INCREF(Py_None); resultobj = Py_None;
6384 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6385 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6386 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6387 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6395 PyObject *resultobj;
6396 wxCaret *arg1 = (wxCaret *) 0 ;
6397 wxSize result;
6398 PyObject * obj0 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "self", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(1)) SWIG_fail;
6406 {
6407 PyThreadState* __tstate = wxPyBeginAllowThreads();
6408 result = (arg1)->GetSize();
6409
6410 wxPyEndAllowThreads(__tstate);
6411 if (PyErr_Occurred()) SWIG_fail;
6412 }
6413 {
6414 wxSize * resultptr;
6415 resultptr = new wxSize((wxSize &)(result));
6416 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6417 }
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6425 PyObject *resultobj;
6426 wxCaret *arg1 = (wxCaret *) 0 ;
6427 int *arg2 = (int *) 0 ;
6428 int *arg3 = (int *) 0 ;
6429 int temp2 ;
6430 int res2 = 0 ;
6431 int temp3 ;
6432 int res3 = 0 ;
6433 PyObject * obj0 = 0 ;
6434 char *kwnames[] = {
6435 (char *) "self", NULL
6436 };
6437
6438 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6439 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6442 if (SWIG_arg_fail(1)) SWIG_fail;
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 (arg1)->GetSize(arg2,arg3);
6446
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 Py_INCREF(Py_None); resultobj = Py_None;
6451 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6452 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6453 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6454 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6462 PyObject *resultobj;
6463 wxCaret *arg1 = (wxCaret *) 0 ;
6464 wxWindow *result;
6465 PyObject * obj0 = 0 ;
6466 char *kwnames[] = {
6467 (char *) "self", NULL
6468 };
6469
6470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6472 if (SWIG_arg_fail(1)) SWIG_fail;
6473 {
6474 PyThreadState* __tstate = wxPyBeginAllowThreads();
6475 result = (wxWindow *)(arg1)->GetWindow();
6476
6477 wxPyEndAllowThreads(__tstate);
6478 if (PyErr_Occurred()) SWIG_fail;
6479 }
6480 {
6481 resultobj = wxPyMake_wxObject(result, 0);
6482 }
6483 return resultobj;
6484 fail:
6485 return NULL;
6486 }
6487
6488
6489 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6490 PyObject *resultobj;
6491 wxCaret *arg1 = (wxCaret *) 0 ;
6492 int arg2 ;
6493 int arg3 ;
6494 PyObject * obj0 = 0 ;
6495 PyObject * obj1 = 0 ;
6496 PyObject * obj2 = 0 ;
6497 char *kwnames[] = {
6498 (char *) "self",(char *) "x",(char *) "y", NULL
6499 };
6500
6501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6503 if (SWIG_arg_fail(1)) SWIG_fail;
6504 {
6505 arg2 = (int)(SWIG_As_int(obj1));
6506 if (SWIG_arg_fail(2)) SWIG_fail;
6507 }
6508 {
6509 arg3 = (int)(SWIG_As_int(obj2));
6510 if (SWIG_arg_fail(3)) SWIG_fail;
6511 }
6512 {
6513 PyThreadState* __tstate = wxPyBeginAllowThreads();
6514 (arg1)->Move(arg2,arg3);
6515
6516 wxPyEndAllowThreads(__tstate);
6517 if (PyErr_Occurred()) SWIG_fail;
6518 }
6519 Py_INCREF(Py_None); resultobj = Py_None;
6520 return resultobj;
6521 fail:
6522 return NULL;
6523 }
6524
6525
6526 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6527 PyObject *resultobj;
6528 wxCaret *arg1 = (wxCaret *) 0 ;
6529 wxPoint *arg2 = 0 ;
6530 wxPoint temp2 ;
6531 PyObject * obj0 = 0 ;
6532 PyObject * obj1 = 0 ;
6533 char *kwnames[] = {
6534 (char *) "self",(char *) "pt", NULL
6535 };
6536
6537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6539 if (SWIG_arg_fail(1)) SWIG_fail;
6540 {
6541 arg2 = &temp2;
6542 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6543 }
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 (arg1)->Move((wxPoint const &)*arg2);
6547
6548 wxPyEndAllowThreads(__tstate);
6549 if (PyErr_Occurred()) SWIG_fail;
6550 }
6551 Py_INCREF(Py_None); resultobj = Py_None;
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6559 PyObject *resultobj;
6560 wxCaret *arg1 = (wxCaret *) 0 ;
6561 int arg2 ;
6562 int arg3 ;
6563 PyObject * obj0 = 0 ;
6564 PyObject * obj1 = 0 ;
6565 PyObject * obj2 = 0 ;
6566 char *kwnames[] = {
6567 (char *) "self",(char *) "width",(char *) "height", NULL
6568 };
6569
6570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6572 if (SWIG_arg_fail(1)) SWIG_fail;
6573 {
6574 arg2 = (int)(SWIG_As_int(obj1));
6575 if (SWIG_arg_fail(2)) SWIG_fail;
6576 }
6577 {
6578 arg3 = (int)(SWIG_As_int(obj2));
6579 if (SWIG_arg_fail(3)) SWIG_fail;
6580 }
6581 {
6582 PyThreadState* __tstate = wxPyBeginAllowThreads();
6583 (arg1)->SetSize(arg2,arg3);
6584
6585 wxPyEndAllowThreads(__tstate);
6586 if (PyErr_Occurred()) SWIG_fail;
6587 }
6588 Py_INCREF(Py_None); resultobj = Py_None;
6589 return resultobj;
6590 fail:
6591 return NULL;
6592 }
6593
6594
6595 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6596 PyObject *resultobj;
6597 wxCaret *arg1 = (wxCaret *) 0 ;
6598 wxSize *arg2 = 0 ;
6599 wxSize temp2 ;
6600 PyObject * obj0 = 0 ;
6601 PyObject * obj1 = 0 ;
6602 char *kwnames[] = {
6603 (char *) "self",(char *) "size", NULL
6604 };
6605
6606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6608 if (SWIG_arg_fail(1)) SWIG_fail;
6609 {
6610 arg2 = &temp2;
6611 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6612 }
6613 {
6614 PyThreadState* __tstate = wxPyBeginAllowThreads();
6615 (arg1)->SetSize((wxSize const &)*arg2);
6616
6617 wxPyEndAllowThreads(__tstate);
6618 if (PyErr_Occurred()) SWIG_fail;
6619 }
6620 Py_INCREF(Py_None); resultobj = Py_None;
6621 return resultobj;
6622 fail:
6623 return NULL;
6624 }
6625
6626
6627 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6628 PyObject *resultobj;
6629 wxCaret *arg1 = (wxCaret *) 0 ;
6630 int arg2 = (int) true ;
6631 PyObject * obj0 = 0 ;
6632 PyObject * obj1 = 0 ;
6633 char *kwnames[] = {
6634 (char *) "self",(char *) "show", NULL
6635 };
6636
6637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6639 if (SWIG_arg_fail(1)) SWIG_fail;
6640 if (obj1) {
6641 {
6642 arg2 = (int)(SWIG_As_int(obj1));
6643 if (SWIG_arg_fail(2)) SWIG_fail;
6644 }
6645 }
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 (arg1)->Show(arg2);
6649
6650 wxPyEndAllowThreads(__tstate);
6651 if (PyErr_Occurred()) SWIG_fail;
6652 }
6653 Py_INCREF(Py_None); resultobj = Py_None;
6654 return resultobj;
6655 fail:
6656 return NULL;
6657 }
6658
6659
6660 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6661 PyObject *resultobj;
6662 wxCaret *arg1 = (wxCaret *) 0 ;
6663 PyObject * obj0 = 0 ;
6664 char *kwnames[] = {
6665 (char *) "self", NULL
6666 };
6667
6668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6670 if (SWIG_arg_fail(1)) SWIG_fail;
6671 {
6672 PyThreadState* __tstate = wxPyBeginAllowThreads();
6673 (arg1)->Hide();
6674
6675 wxPyEndAllowThreads(__tstate);
6676 if (PyErr_Occurred()) SWIG_fail;
6677 }
6678 Py_INCREF(Py_None); resultobj = Py_None;
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6686 PyObject *obj;
6687 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6688 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6689 Py_INCREF(obj);
6690 return Py_BuildValue((char *)"");
6691 }
6692 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6693 PyObject *resultobj;
6694 int result;
6695 char *kwnames[] = {
6696 NULL
6697 };
6698
6699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 result = (int)wxCaret_GetBlinkTime();
6703
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 {
6708 resultobj = SWIG_From_int((int)(result));
6709 }
6710 return resultobj;
6711 fail:
6712 return NULL;
6713 }
6714
6715
6716 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6717 PyObject *resultobj;
6718 int arg1 ;
6719 PyObject * obj0 = 0 ;
6720 char *kwnames[] = {
6721 (char *) "milliseconds", NULL
6722 };
6723
6724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6725 {
6726 arg1 = (int)(SWIG_As_int(obj0));
6727 if (SWIG_arg_fail(1)) SWIG_fail;
6728 }
6729 {
6730 PyThreadState* __tstate = wxPyBeginAllowThreads();
6731 wxCaret_SetBlinkTime(arg1);
6732
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 Py_INCREF(Py_None); resultobj = Py_None;
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6744 PyObject *resultobj;
6745 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6746 wxBusyCursor *result;
6747 PyObject * obj0 = 0 ;
6748 char *kwnames[] = {
6749 (char *) "cursor", NULL
6750 };
6751
6752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6753 if (obj0) {
6754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6755 if (SWIG_arg_fail(1)) SWIG_fail;
6756 }
6757 {
6758 if (!wxPyCheckForApp()) SWIG_fail;
6759 PyThreadState* __tstate = wxPyBeginAllowThreads();
6760 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6761
6762 wxPyEndAllowThreads(__tstate);
6763 if (PyErr_Occurred()) SWIG_fail;
6764 }
6765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6766 return resultobj;
6767 fail:
6768 return NULL;
6769 }
6770
6771
6772 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6773 PyObject *resultobj;
6774 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6775 PyObject * obj0 = 0 ;
6776 char *kwnames[] = {
6777 (char *) "self", NULL
6778 };
6779
6780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6782 if (SWIG_arg_fail(1)) SWIG_fail;
6783 {
6784 PyThreadState* __tstate = wxPyBeginAllowThreads();
6785 delete arg1;
6786
6787 wxPyEndAllowThreads(__tstate);
6788 if (PyErr_Occurred()) SWIG_fail;
6789 }
6790 Py_INCREF(Py_None); resultobj = Py_None;
6791 return resultobj;
6792 fail:
6793 return NULL;
6794 }
6795
6796
6797 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6798 PyObject *obj;
6799 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6800 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6801 Py_INCREF(obj);
6802 return Py_BuildValue((char *)"");
6803 }
6804 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6805 PyObject *resultobj;
6806 wxWindow *arg1 = (wxWindow *) NULL ;
6807 wxWindowDisabler *result;
6808 PyObject * obj0 = 0 ;
6809 char *kwnames[] = {
6810 (char *) "winToSkip", NULL
6811 };
6812
6813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6814 if (obj0) {
6815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6816 if (SWIG_arg_fail(1)) SWIG_fail;
6817 }
6818 {
6819 if (!wxPyCheckForApp()) SWIG_fail;
6820 PyThreadState* __tstate = wxPyBeginAllowThreads();
6821 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6822
6823 wxPyEndAllowThreads(__tstate);
6824 if (PyErr_Occurred()) SWIG_fail;
6825 }
6826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6827 return resultobj;
6828 fail:
6829 return NULL;
6830 }
6831
6832
6833 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6834 PyObject *resultobj;
6835 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6836 PyObject * obj0 = 0 ;
6837 char *kwnames[] = {
6838 (char *) "self", NULL
6839 };
6840
6841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6843 if (SWIG_arg_fail(1)) SWIG_fail;
6844 {
6845 PyThreadState* __tstate = wxPyBeginAllowThreads();
6846 delete arg1;
6847
6848 wxPyEndAllowThreads(__tstate);
6849 if (PyErr_Occurred()) SWIG_fail;
6850 }
6851 Py_INCREF(Py_None); resultobj = Py_None;
6852 return resultobj;
6853 fail:
6854 return NULL;
6855 }
6856
6857
6858 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6859 PyObject *obj;
6860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6861 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6862 Py_INCREF(obj);
6863 return Py_BuildValue((char *)"");
6864 }
6865 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6866 PyObject *resultobj;
6867 wxString *arg1 = 0 ;
6868 wxBusyInfo *result;
6869 bool temp1 = false ;
6870 PyObject * obj0 = 0 ;
6871 char *kwnames[] = {
6872 (char *) "message", NULL
6873 };
6874
6875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6876 {
6877 arg1 = wxString_in_helper(obj0);
6878 if (arg1 == NULL) SWIG_fail;
6879 temp1 = true;
6880 }
6881 {
6882 if (!wxPyCheckForApp()) SWIG_fail;
6883 PyThreadState* __tstate = wxPyBeginAllowThreads();
6884 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6885
6886 wxPyEndAllowThreads(__tstate);
6887 if (PyErr_Occurred()) SWIG_fail;
6888 }
6889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6890 {
6891 if (temp1)
6892 delete arg1;
6893 }
6894 return resultobj;
6895 fail:
6896 {
6897 if (temp1)
6898 delete arg1;
6899 }
6900 return NULL;
6901 }
6902
6903
6904 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6905 PyObject *resultobj;
6906 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6907 PyObject * obj0 = 0 ;
6908 char *kwnames[] = {
6909 (char *) "self", NULL
6910 };
6911
6912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6914 if (SWIG_arg_fail(1)) SWIG_fail;
6915 {
6916 PyThreadState* __tstate = wxPyBeginAllowThreads();
6917 delete arg1;
6918
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 Py_INCREF(Py_None); resultobj = Py_None;
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6930 PyObject *obj;
6931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6932 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6933 Py_INCREF(obj);
6934 return Py_BuildValue((char *)"");
6935 }
6936 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6937 PyObject *resultobj;
6938 wxStopWatch *result;
6939 char *kwnames[] = {
6940 NULL
6941 };
6942
6943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6944 {
6945 PyThreadState* __tstate = wxPyBeginAllowThreads();
6946 result = (wxStopWatch *)new wxStopWatch();
6947
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6952 return resultobj;
6953 fail:
6954 return NULL;
6955 }
6956
6957
6958 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6959 PyObject *resultobj;
6960 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6961 long arg2 = (long) 0 ;
6962 PyObject * obj0 = 0 ;
6963 PyObject * obj1 = 0 ;
6964 char *kwnames[] = {
6965 (char *) "self",(char *) "t0", NULL
6966 };
6967
6968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
6969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6970 if (SWIG_arg_fail(1)) SWIG_fail;
6971 if (obj1) {
6972 {
6973 arg2 = (long)(SWIG_As_long(obj1));
6974 if (SWIG_arg_fail(2)) SWIG_fail;
6975 }
6976 }
6977 {
6978 PyThreadState* __tstate = wxPyBeginAllowThreads();
6979 (arg1)->Start(arg2);
6980
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 Py_INCREF(Py_None); resultobj = Py_None;
6985 return resultobj;
6986 fail:
6987 return NULL;
6988 }
6989
6990
6991 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
6992 PyObject *resultobj;
6993 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6994 PyObject * obj0 = 0 ;
6995 char *kwnames[] = {
6996 (char *) "self", NULL
6997 };
6998
6999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7001 if (SWIG_arg_fail(1)) SWIG_fail;
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 (arg1)->Pause();
7005
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 Py_INCREF(Py_None); resultobj = Py_None;
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj;
7018 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7019 PyObject * obj0 = 0 ;
7020 char *kwnames[] = {
7021 (char *) "self", NULL
7022 };
7023
7024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7026 if (SWIG_arg_fail(1)) SWIG_fail;
7027 {
7028 PyThreadState* __tstate = wxPyBeginAllowThreads();
7029 (arg1)->Resume();
7030
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 Py_INCREF(Py_None); resultobj = Py_None;
7035 return resultobj;
7036 fail:
7037 return NULL;
7038 }
7039
7040
7041 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7042 PyObject *resultobj;
7043 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7044 long result;
7045 PyObject * obj0 = 0 ;
7046 char *kwnames[] = {
7047 (char *) "self", NULL
7048 };
7049
7050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7052 if (SWIG_arg_fail(1)) SWIG_fail;
7053 {
7054 PyThreadState* __tstate = wxPyBeginAllowThreads();
7055 result = (long)((wxStopWatch const *)arg1)->Time();
7056
7057 wxPyEndAllowThreads(__tstate);
7058 if (PyErr_Occurred()) SWIG_fail;
7059 }
7060 {
7061 resultobj = SWIG_From_long((long)(result));
7062 }
7063 return resultobj;
7064 fail:
7065 return NULL;
7066 }
7067
7068
7069 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7070 PyObject *obj;
7071 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7072 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7073 Py_INCREF(obj);
7074 return Py_BuildValue((char *)"");
7075 }
7076 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7077 PyObject *resultobj;
7078 int arg1 = (int) 9 ;
7079 int arg2 = (int) wxID_FILE1 ;
7080 wxFileHistory *result;
7081 PyObject * obj0 = 0 ;
7082 PyObject * obj1 = 0 ;
7083 char *kwnames[] = {
7084 (char *) "maxFiles",(char *) "idBase", NULL
7085 };
7086
7087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7088 if (obj0) {
7089 {
7090 arg1 = (int)(SWIG_As_int(obj0));
7091 if (SWIG_arg_fail(1)) SWIG_fail;
7092 }
7093 }
7094 if (obj1) {
7095 {
7096 arg2 = (int)(SWIG_As_int(obj1));
7097 if (SWIG_arg_fail(2)) SWIG_fail;
7098 }
7099 }
7100 {
7101 PyThreadState* __tstate = wxPyBeginAllowThreads();
7102 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7103
7104 wxPyEndAllowThreads(__tstate);
7105 if (PyErr_Occurred()) SWIG_fail;
7106 }
7107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7108 return resultobj;
7109 fail:
7110 return NULL;
7111 }
7112
7113
7114 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7115 PyObject *resultobj;
7116 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7117 PyObject * obj0 = 0 ;
7118 char *kwnames[] = {
7119 (char *) "self", NULL
7120 };
7121
7122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7124 if (SWIG_arg_fail(1)) SWIG_fail;
7125 {
7126 PyThreadState* __tstate = wxPyBeginAllowThreads();
7127 delete arg1;
7128
7129 wxPyEndAllowThreads(__tstate);
7130 if (PyErr_Occurred()) SWIG_fail;
7131 }
7132 Py_INCREF(Py_None); resultobj = Py_None;
7133 return resultobj;
7134 fail:
7135 return NULL;
7136 }
7137
7138
7139 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7140 PyObject *resultobj;
7141 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7142 wxString *arg2 = 0 ;
7143 bool temp2 = false ;
7144 PyObject * obj0 = 0 ;
7145 PyObject * obj1 = 0 ;
7146 char *kwnames[] = {
7147 (char *) "self",(char *) "file", NULL
7148 };
7149
7150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7152 if (SWIG_arg_fail(1)) SWIG_fail;
7153 {
7154 arg2 = wxString_in_helper(obj1);
7155 if (arg2 == NULL) SWIG_fail;
7156 temp2 = true;
7157 }
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 (arg1)->AddFileToHistory((wxString const &)*arg2);
7161
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 Py_INCREF(Py_None); resultobj = Py_None;
7166 {
7167 if (temp2)
7168 delete arg2;
7169 }
7170 return resultobj;
7171 fail:
7172 {
7173 if (temp2)
7174 delete arg2;
7175 }
7176 return NULL;
7177 }
7178
7179
7180 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj;
7182 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7183 int arg2 ;
7184 PyObject * obj0 = 0 ;
7185 PyObject * obj1 = 0 ;
7186 char *kwnames[] = {
7187 (char *) "self",(char *) "i", NULL
7188 };
7189
7190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7192 if (SWIG_arg_fail(1)) SWIG_fail;
7193 {
7194 arg2 = (int)(SWIG_As_int(obj1));
7195 if (SWIG_arg_fail(2)) SWIG_fail;
7196 }
7197 {
7198 PyThreadState* __tstate = wxPyBeginAllowThreads();
7199 (arg1)->RemoveFileFromHistory(arg2);
7200
7201 wxPyEndAllowThreads(__tstate);
7202 if (PyErr_Occurred()) SWIG_fail;
7203 }
7204 Py_INCREF(Py_None); resultobj = Py_None;
7205 return resultobj;
7206 fail:
7207 return NULL;
7208 }
7209
7210
7211 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7212 PyObject *resultobj;
7213 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7214 int result;
7215 PyObject * obj0 = 0 ;
7216 char *kwnames[] = {
7217 (char *) "self", NULL
7218 };
7219
7220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7222 if (SWIG_arg_fail(1)) SWIG_fail;
7223 {
7224 PyThreadState* __tstate = wxPyBeginAllowThreads();
7225 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7226
7227 wxPyEndAllowThreads(__tstate);
7228 if (PyErr_Occurred()) SWIG_fail;
7229 }
7230 {
7231 resultobj = SWIG_From_int((int)(result));
7232 }
7233 return resultobj;
7234 fail:
7235 return NULL;
7236 }
7237
7238
7239 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7240 PyObject *resultobj;
7241 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7242 wxMenu *arg2 = (wxMenu *) 0 ;
7243 PyObject * obj0 = 0 ;
7244 PyObject * obj1 = 0 ;
7245 char *kwnames[] = {
7246 (char *) "self",(char *) "menu", NULL
7247 };
7248
7249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7251 if (SWIG_arg_fail(1)) SWIG_fail;
7252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7253 if (SWIG_arg_fail(2)) SWIG_fail;
7254 {
7255 PyThreadState* __tstate = wxPyBeginAllowThreads();
7256 (arg1)->UseMenu(arg2);
7257
7258 wxPyEndAllowThreads(__tstate);
7259 if (PyErr_Occurred()) SWIG_fail;
7260 }
7261 Py_INCREF(Py_None); resultobj = Py_None;
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj;
7270 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7271 wxMenu *arg2 = (wxMenu *) 0 ;
7272 PyObject * obj0 = 0 ;
7273 PyObject * obj1 = 0 ;
7274 char *kwnames[] = {
7275 (char *) "self",(char *) "menu", NULL
7276 };
7277
7278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7280 if (SWIG_arg_fail(1)) SWIG_fail;
7281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7282 if (SWIG_arg_fail(2)) SWIG_fail;
7283 {
7284 PyThreadState* __tstate = wxPyBeginAllowThreads();
7285 (arg1)->RemoveMenu(arg2);
7286
7287 wxPyEndAllowThreads(__tstate);
7288 if (PyErr_Occurred()) SWIG_fail;
7289 }
7290 Py_INCREF(Py_None); resultobj = Py_None;
7291 return resultobj;
7292 fail:
7293 return NULL;
7294 }
7295
7296
7297 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7298 PyObject *resultobj;
7299 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7300 wxConfigBase *arg2 = 0 ;
7301 PyObject * obj0 = 0 ;
7302 PyObject * obj1 = 0 ;
7303 char *kwnames[] = {
7304 (char *) "self",(char *) "config", NULL
7305 };
7306
7307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7309 if (SWIG_arg_fail(1)) SWIG_fail;
7310 {
7311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7312 if (SWIG_arg_fail(2)) SWIG_fail;
7313 if (arg2 == NULL) {
7314 SWIG_null_ref("wxConfigBase");
7315 }
7316 if (SWIG_arg_fail(2)) SWIG_fail;
7317 }
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 (arg1)->Load(*arg2);
7321
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 Py_INCREF(Py_None); resultobj = Py_None;
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj;
7334 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7335 wxConfigBase *arg2 = 0 ;
7336 PyObject * obj0 = 0 ;
7337 PyObject * obj1 = 0 ;
7338 char *kwnames[] = {
7339 (char *) "self",(char *) "config", NULL
7340 };
7341
7342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7344 if (SWIG_arg_fail(1)) SWIG_fail;
7345 {
7346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7347 if (SWIG_arg_fail(2)) SWIG_fail;
7348 if (arg2 == NULL) {
7349 SWIG_null_ref("wxConfigBase");
7350 }
7351 if (SWIG_arg_fail(2)) SWIG_fail;
7352 }
7353 {
7354 PyThreadState* __tstate = wxPyBeginAllowThreads();
7355 (arg1)->Save(*arg2);
7356
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 Py_INCREF(Py_None); resultobj = Py_None;
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj;
7369 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7370 PyObject * obj0 = 0 ;
7371 char *kwnames[] = {
7372 (char *) "self", NULL
7373 };
7374
7375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7377 if (SWIG_arg_fail(1)) SWIG_fail;
7378 {
7379 PyThreadState* __tstate = wxPyBeginAllowThreads();
7380 (arg1)->AddFilesToMenu();
7381
7382 wxPyEndAllowThreads(__tstate);
7383 if (PyErr_Occurred()) SWIG_fail;
7384 }
7385 Py_INCREF(Py_None); resultobj = Py_None;
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj;
7394 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7395 wxMenu *arg2 = (wxMenu *) 0 ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char *kwnames[] = {
7399 (char *) "self",(char *) "menu", NULL
7400 };
7401
7402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7404 if (SWIG_arg_fail(1)) SWIG_fail;
7405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7406 if (SWIG_arg_fail(2)) SWIG_fail;
7407 {
7408 PyThreadState* __tstate = wxPyBeginAllowThreads();
7409 (arg1)->AddFilesToMenu(arg2);
7410
7411 wxPyEndAllowThreads(__tstate);
7412 if (PyErr_Occurred()) SWIG_fail;
7413 }
7414 Py_INCREF(Py_None); resultobj = Py_None;
7415 return resultobj;
7416 fail:
7417 return NULL;
7418 }
7419
7420
7421 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7422 PyObject *resultobj;
7423 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7424 int arg2 ;
7425 wxString result;
7426 PyObject * obj0 = 0 ;
7427 PyObject * obj1 = 0 ;
7428 char *kwnames[] = {
7429 (char *) "self",(char *) "i", NULL
7430 };
7431
7432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7434 if (SWIG_arg_fail(1)) SWIG_fail;
7435 {
7436 arg2 = (int)(SWIG_As_int(obj1));
7437 if (SWIG_arg_fail(2)) SWIG_fail;
7438 }
7439 {
7440 PyThreadState* __tstate = wxPyBeginAllowThreads();
7441 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7442
7443 wxPyEndAllowThreads(__tstate);
7444 if (PyErr_Occurred()) SWIG_fail;
7445 }
7446 {
7447 #if wxUSE_UNICODE
7448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7449 #else
7450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7451 #endif
7452 }
7453 return resultobj;
7454 fail:
7455 return NULL;
7456 }
7457
7458
7459 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7460 PyObject *resultobj;
7461 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7462 int result;
7463 PyObject * obj0 = 0 ;
7464 char *kwnames[] = {
7465 (char *) "self", NULL
7466 };
7467
7468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7470 if (SWIG_arg_fail(1)) SWIG_fail;
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 result = (int)((wxFileHistory const *)arg1)->GetCount();
7474
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 {
7479 resultobj = SWIG_From_int((int)(result));
7480 }
7481 return resultobj;
7482 fail:
7483 return NULL;
7484 }
7485
7486
7487 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7488 PyObject *obj;
7489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7490 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7491 Py_INCREF(obj);
7492 return Py_BuildValue((char *)"");
7493 }
7494 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj;
7496 wxString *arg1 = 0 ;
7497 wxString const &arg2_defvalue = wxPyEmptyString ;
7498 wxString *arg2 = (wxString *) &arg2_defvalue ;
7499 wxSingleInstanceChecker *result;
7500 bool temp1 = false ;
7501 bool temp2 = false ;
7502 PyObject * obj0 = 0 ;
7503 PyObject * obj1 = 0 ;
7504 char *kwnames[] = {
7505 (char *) "name",(char *) "path", NULL
7506 };
7507
7508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7509 {
7510 arg1 = wxString_in_helper(obj0);
7511 if (arg1 == NULL) SWIG_fail;
7512 temp1 = true;
7513 }
7514 if (obj1) {
7515 {
7516 arg2 = wxString_in_helper(obj1);
7517 if (arg2 == NULL) SWIG_fail;
7518 temp2 = true;
7519 }
7520 }
7521 {
7522 PyThreadState* __tstate = wxPyBeginAllowThreads();
7523 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7524
7525 wxPyEndAllowThreads(__tstate);
7526 if (PyErr_Occurred()) SWIG_fail;
7527 }
7528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7529 {
7530 if (temp1)
7531 delete arg1;
7532 }
7533 {
7534 if (temp2)
7535 delete arg2;
7536 }
7537 return resultobj;
7538 fail:
7539 {
7540 if (temp1)
7541 delete arg1;
7542 }
7543 {
7544 if (temp2)
7545 delete arg2;
7546 }
7547 return NULL;
7548 }
7549
7550
7551 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7552 PyObject *resultobj;
7553 wxSingleInstanceChecker *result;
7554 char *kwnames[] = {
7555 NULL
7556 };
7557
7558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7559 {
7560 PyThreadState* __tstate = wxPyBeginAllowThreads();
7561 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7562
7563 wxPyEndAllowThreads(__tstate);
7564 if (PyErr_Occurred()) SWIG_fail;
7565 }
7566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7567 return resultobj;
7568 fail:
7569 return NULL;
7570 }
7571
7572
7573 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7574 PyObject *resultobj;
7575 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7576 PyObject * obj0 = 0 ;
7577 char *kwnames[] = {
7578 (char *) "self", NULL
7579 };
7580
7581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7583 if (SWIG_arg_fail(1)) SWIG_fail;
7584 {
7585 PyThreadState* __tstate = wxPyBeginAllowThreads();
7586 delete arg1;
7587
7588 wxPyEndAllowThreads(__tstate);
7589 if (PyErr_Occurred()) SWIG_fail;
7590 }
7591 Py_INCREF(Py_None); resultobj = Py_None;
7592 return resultobj;
7593 fail:
7594 return NULL;
7595 }
7596
7597
7598 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7599 PyObject *resultobj;
7600 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7601 wxString *arg2 = 0 ;
7602 wxString const &arg3_defvalue = wxPyEmptyString ;
7603 wxString *arg3 = (wxString *) &arg3_defvalue ;
7604 bool result;
7605 bool temp2 = false ;
7606 bool temp3 = false ;
7607 PyObject * obj0 = 0 ;
7608 PyObject * obj1 = 0 ;
7609 PyObject * obj2 = 0 ;
7610 char *kwnames[] = {
7611 (char *) "self",(char *) "name",(char *) "path", NULL
7612 };
7613
7614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7616 if (SWIG_arg_fail(1)) SWIG_fail;
7617 {
7618 arg2 = wxString_in_helper(obj1);
7619 if (arg2 == NULL) SWIG_fail;
7620 temp2 = true;
7621 }
7622 if (obj2) {
7623 {
7624 arg3 = wxString_in_helper(obj2);
7625 if (arg3 == NULL) SWIG_fail;
7626 temp3 = true;
7627 }
7628 }
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7632
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 {
7637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7638 }
7639 {
7640 if (temp2)
7641 delete arg2;
7642 }
7643 {
7644 if (temp3)
7645 delete arg3;
7646 }
7647 return resultobj;
7648 fail:
7649 {
7650 if (temp2)
7651 delete arg2;
7652 }
7653 {
7654 if (temp3)
7655 delete arg3;
7656 }
7657 return NULL;
7658 }
7659
7660
7661 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj;
7663 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7664 bool result;
7665 PyObject * obj0 = 0 ;
7666 char *kwnames[] = {
7667 (char *) "self", NULL
7668 };
7669
7670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7672 if (SWIG_arg_fail(1)) SWIG_fail;
7673 {
7674 PyThreadState* __tstate = wxPyBeginAllowThreads();
7675 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7676
7677 wxPyEndAllowThreads(__tstate);
7678 if (PyErr_Occurred()) SWIG_fail;
7679 }
7680 {
7681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7682 }
7683 return resultobj;
7684 fail:
7685 return NULL;
7686 }
7687
7688
7689 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7690 PyObject *obj;
7691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7692 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7693 Py_INCREF(obj);
7694 return Py_BuildValue((char *)"");
7695 }
7696 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7697 PyObject *resultobj;
7698 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7699 PyObject * obj0 = 0 ;
7700 char *kwnames[] = {
7701 (char *) "self", NULL
7702 };
7703
7704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7706 if (SWIG_arg_fail(1)) SWIG_fail;
7707 {
7708 PyThreadState* __tstate = wxPyBeginAllowThreads();
7709 delete arg1;
7710
7711 wxPyEndAllowThreads(__tstate);
7712 if (PyErr_Occurred()) SWIG_fail;
7713 }
7714 Py_INCREF(Py_None); resultobj = Py_None;
7715 return resultobj;
7716 fail:
7717 return NULL;
7718 }
7719
7720
7721 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7722 PyObject *resultobj;
7723 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7724 wxString result;
7725 PyObject * obj0 = 0 ;
7726 char *kwnames[] = {
7727 (char *) "self", NULL
7728 };
7729
7730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7732 if (SWIG_arg_fail(1)) SWIG_fail;
7733 {
7734 PyThreadState* __tstate = wxPyBeginAllowThreads();
7735 result = (arg1)->GetTip();
7736
7737 wxPyEndAllowThreads(__tstate);
7738 if (PyErr_Occurred()) SWIG_fail;
7739 }
7740 {
7741 #if wxUSE_UNICODE
7742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7743 #else
7744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7745 #endif
7746 }
7747 return resultobj;
7748 fail:
7749 return NULL;
7750 }
7751
7752
7753 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7754 PyObject *resultobj;
7755 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7756 size_t result;
7757 PyObject * obj0 = 0 ;
7758 char *kwnames[] = {
7759 (char *) "self", NULL
7760 };
7761
7762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7764 if (SWIG_arg_fail(1)) SWIG_fail;
7765 {
7766 PyThreadState* __tstate = wxPyBeginAllowThreads();
7767 result = (size_t)(arg1)->GetCurrentTip();
7768
7769 wxPyEndAllowThreads(__tstate);
7770 if (PyErr_Occurred()) SWIG_fail;
7771 }
7772 {
7773 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7774 }
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7782 PyObject *resultobj;
7783 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7784 wxString *arg2 = 0 ;
7785 wxString result;
7786 bool temp2 = false ;
7787 PyObject * obj0 = 0 ;
7788 PyObject * obj1 = 0 ;
7789 char *kwnames[] = {
7790 (char *) "self",(char *) "tip", NULL
7791 };
7792
7793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7795 if (SWIG_arg_fail(1)) SWIG_fail;
7796 {
7797 arg2 = wxString_in_helper(obj1);
7798 if (arg2 == NULL) SWIG_fail;
7799 temp2 = true;
7800 }
7801 {
7802 PyThreadState* __tstate = wxPyBeginAllowThreads();
7803 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7804
7805 wxPyEndAllowThreads(__tstate);
7806 if (PyErr_Occurred()) SWIG_fail;
7807 }
7808 {
7809 #if wxUSE_UNICODE
7810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7811 #else
7812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7813 #endif
7814 }
7815 {
7816 if (temp2)
7817 delete arg2;
7818 }
7819 return resultobj;
7820 fail:
7821 {
7822 if (temp2)
7823 delete arg2;
7824 }
7825 return NULL;
7826 }
7827
7828
7829 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7830 PyObject *obj;
7831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7832 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7833 Py_INCREF(obj);
7834 return Py_BuildValue((char *)"");
7835 }
7836 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7837 PyObject *resultobj;
7838 size_t arg1 ;
7839 wxPyTipProvider *result;
7840 PyObject * obj0 = 0 ;
7841 char *kwnames[] = {
7842 (char *) "currentTip", NULL
7843 };
7844
7845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7846 {
7847 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 }
7850 {
7851 PyThreadState* __tstate = wxPyBeginAllowThreads();
7852 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7853
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7858 return resultobj;
7859 fail:
7860 return NULL;
7861 }
7862
7863
7864 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7865 PyObject *resultobj;
7866 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7867 PyObject *arg2 = (PyObject *) 0 ;
7868 PyObject *arg3 = (PyObject *) 0 ;
7869 PyObject * obj0 = 0 ;
7870 PyObject * obj1 = 0 ;
7871 PyObject * obj2 = 0 ;
7872 char *kwnames[] = {
7873 (char *) "self",(char *) "self",(char *) "_class", NULL
7874 };
7875
7876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7878 if (SWIG_arg_fail(1)) SWIG_fail;
7879 arg2 = obj1;
7880 arg3 = obj2;
7881 {
7882 PyThreadState* __tstate = wxPyBeginAllowThreads();
7883 (arg1)->_setCallbackInfo(arg2,arg3);
7884
7885 wxPyEndAllowThreads(__tstate);
7886 if (PyErr_Occurred()) SWIG_fail;
7887 }
7888 Py_INCREF(Py_None); resultobj = Py_None;
7889 return resultobj;
7890 fail:
7891 return NULL;
7892 }
7893
7894
7895 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7896 PyObject *obj;
7897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7898 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7899 Py_INCREF(obj);
7900 return Py_BuildValue((char *)"");
7901 }
7902 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7903 PyObject *resultobj;
7904 wxWindow *arg1 = (wxWindow *) 0 ;
7905 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7906 bool arg3 = (bool) true ;
7907 bool result;
7908 PyObject * obj0 = 0 ;
7909 PyObject * obj1 = 0 ;
7910 PyObject * obj2 = 0 ;
7911 char *kwnames[] = {
7912 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7913 };
7914
7915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7917 if (SWIG_arg_fail(1)) SWIG_fail;
7918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7919 if (SWIG_arg_fail(2)) SWIG_fail;
7920 if (obj2) {
7921 {
7922 arg3 = (bool)(SWIG_As_bool(obj2));
7923 if (SWIG_arg_fail(3)) SWIG_fail;
7924 }
7925 }
7926 {
7927 if (!wxPyCheckForApp()) SWIG_fail;
7928 PyThreadState* __tstate = wxPyBeginAllowThreads();
7929 result = (bool)wxShowTip(arg1,arg2,arg3);
7930
7931 wxPyEndAllowThreads(__tstate);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 {
7935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7936 }
7937 return resultobj;
7938 fail:
7939 return NULL;
7940 }
7941
7942
7943 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7944 PyObject *resultobj;
7945 wxString *arg1 = 0 ;
7946 size_t arg2 ;
7947 wxTipProvider *result;
7948 bool temp1 = false ;
7949 PyObject * obj0 = 0 ;
7950 PyObject * obj1 = 0 ;
7951 char *kwnames[] = {
7952 (char *) "filename",(char *) "currentTip", NULL
7953 };
7954
7955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7956 {
7957 arg1 = wxString_in_helper(obj0);
7958 if (arg1 == NULL) SWIG_fail;
7959 temp1 = true;
7960 }
7961 {
7962 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7963 if (SWIG_arg_fail(2)) SWIG_fail;
7964 }
7965 {
7966 if (!wxPyCheckForApp()) SWIG_fail;
7967 PyThreadState* __tstate = wxPyBeginAllowThreads();
7968 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
7969
7970 wxPyEndAllowThreads(__tstate);
7971 if (PyErr_Occurred()) SWIG_fail;
7972 }
7973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
7974 {
7975 if (temp1)
7976 delete arg1;
7977 }
7978 return resultobj;
7979 fail:
7980 {
7981 if (temp1)
7982 delete arg1;
7983 }
7984 return NULL;
7985 }
7986
7987
7988 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
7989 PyObject *resultobj;
7990 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
7991 int arg2 = (int) -1 ;
7992 wxPyTimer *result;
7993 PyObject * obj0 = 0 ;
7994 PyObject * obj1 = 0 ;
7995 char *kwnames[] = {
7996 (char *) "owner",(char *) "id", NULL
7997 };
7998
7999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8000 if (obj0) {
8001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8002 if (SWIG_arg_fail(1)) SWIG_fail;
8003 }
8004 if (obj1) {
8005 {
8006 arg2 = (int)(SWIG_As_int(obj1));
8007 if (SWIG_arg_fail(2)) SWIG_fail;
8008 }
8009 }
8010 {
8011 if (!wxPyCheckForApp()) SWIG_fail;
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8014
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8019 return resultobj;
8020 fail:
8021 return NULL;
8022 }
8023
8024
8025 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8026 PyObject *resultobj;
8027 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8028 PyObject * obj0 = 0 ;
8029 char *kwnames[] = {
8030 (char *) "self", NULL
8031 };
8032
8033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8035 if (SWIG_arg_fail(1)) SWIG_fail;
8036 {
8037 PyThreadState* __tstate = wxPyBeginAllowThreads();
8038 delete arg1;
8039
8040 wxPyEndAllowThreads(__tstate);
8041 if (PyErr_Occurred()) SWIG_fail;
8042 }
8043 Py_INCREF(Py_None); resultobj = Py_None;
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8051 PyObject *resultobj;
8052 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8053 PyObject *arg2 = (PyObject *) 0 ;
8054 PyObject *arg3 = (PyObject *) 0 ;
8055 int arg4 = (int) 1 ;
8056 PyObject * obj0 = 0 ;
8057 PyObject * obj1 = 0 ;
8058 PyObject * obj2 = 0 ;
8059 PyObject * obj3 = 0 ;
8060 char *kwnames[] = {
8061 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8062 };
8063
8064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8066 if (SWIG_arg_fail(1)) SWIG_fail;
8067 arg2 = obj1;
8068 arg3 = obj2;
8069 if (obj3) {
8070 {
8071 arg4 = (int)(SWIG_As_int(obj3));
8072 if (SWIG_arg_fail(4)) SWIG_fail;
8073 }
8074 }
8075 {
8076 PyThreadState* __tstate = wxPyBeginAllowThreads();
8077 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8078
8079 wxPyEndAllowThreads(__tstate);
8080 if (PyErr_Occurred()) SWIG_fail;
8081 }
8082 Py_INCREF(Py_None); resultobj = Py_None;
8083 return resultobj;
8084 fail:
8085 return NULL;
8086 }
8087
8088
8089 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8090 PyObject *resultobj;
8091 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8092 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8093 int arg3 = (int) -1 ;
8094 PyObject * obj0 = 0 ;
8095 PyObject * obj1 = 0 ;
8096 PyObject * obj2 = 0 ;
8097 char *kwnames[] = {
8098 (char *) "self",(char *) "owner",(char *) "id", NULL
8099 };
8100
8101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8103 if (SWIG_arg_fail(1)) SWIG_fail;
8104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8105 if (SWIG_arg_fail(2)) SWIG_fail;
8106 if (obj2) {
8107 {
8108 arg3 = (int)(SWIG_As_int(obj2));
8109 if (SWIG_arg_fail(3)) SWIG_fail;
8110 }
8111 }
8112 {
8113 PyThreadState* __tstate = wxPyBeginAllowThreads();
8114 (arg1)->SetOwner(arg2,arg3);
8115
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 Py_INCREF(Py_None); resultobj = Py_None;
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj;
8128 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8129 wxEvtHandler *result;
8130 PyObject * obj0 = 0 ;
8131 char *kwnames[] = {
8132 (char *) "self", NULL
8133 };
8134
8135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8137 if (SWIG_arg_fail(1)) SWIG_fail;
8138 {
8139 PyThreadState* __tstate = wxPyBeginAllowThreads();
8140 result = (wxEvtHandler *)(arg1)->GetOwner();
8141
8142 wxPyEndAllowThreads(__tstate);
8143 if (PyErr_Occurred()) SWIG_fail;
8144 }
8145 {
8146 resultobj = wxPyMake_wxObject(result, 0);
8147 }
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8155 PyObject *resultobj;
8156 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8157 int arg2 = (int) -1 ;
8158 bool arg3 = (bool) false ;
8159 bool result;
8160 PyObject * obj0 = 0 ;
8161 PyObject * obj1 = 0 ;
8162 PyObject * obj2 = 0 ;
8163 char *kwnames[] = {
8164 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8165 };
8166
8167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8169 if (SWIG_arg_fail(1)) SWIG_fail;
8170 if (obj1) {
8171 {
8172 arg2 = (int)(SWIG_As_int(obj1));
8173 if (SWIG_arg_fail(2)) SWIG_fail;
8174 }
8175 }
8176 if (obj2) {
8177 {
8178 arg3 = (bool)(SWIG_As_bool(obj2));
8179 if (SWIG_arg_fail(3)) SWIG_fail;
8180 }
8181 }
8182 {
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 result = (bool)(arg1)->Start(arg2,arg3);
8185
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 {
8190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8191 }
8192 return resultobj;
8193 fail:
8194 return NULL;
8195 }
8196
8197
8198 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8199 PyObject *resultobj;
8200 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8201 PyObject * obj0 = 0 ;
8202 char *kwnames[] = {
8203 (char *) "self", NULL
8204 };
8205
8206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8208 if (SWIG_arg_fail(1)) SWIG_fail;
8209 {
8210 PyThreadState* __tstate = wxPyBeginAllowThreads();
8211 (arg1)->Stop();
8212
8213 wxPyEndAllowThreads(__tstate);
8214 if (PyErr_Occurred()) SWIG_fail;
8215 }
8216 Py_INCREF(Py_None); resultobj = Py_None;
8217 return resultobj;
8218 fail:
8219 return NULL;
8220 }
8221
8222
8223 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8224 PyObject *resultobj;
8225 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8226 bool result;
8227 PyObject * obj0 = 0 ;
8228 char *kwnames[] = {
8229 (char *) "self", NULL
8230 };
8231
8232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8234 if (SWIG_arg_fail(1)) SWIG_fail;
8235 {
8236 PyThreadState* __tstate = wxPyBeginAllowThreads();
8237 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8238
8239 wxPyEndAllowThreads(__tstate);
8240 if (PyErr_Occurred()) SWIG_fail;
8241 }
8242 {
8243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8244 }
8245 return resultobj;
8246 fail:
8247 return NULL;
8248 }
8249
8250
8251 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8252 PyObject *resultobj;
8253 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8254 int result;
8255 PyObject * obj0 = 0 ;
8256 char *kwnames[] = {
8257 (char *) "self", NULL
8258 };
8259
8260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8262 if (SWIG_arg_fail(1)) SWIG_fail;
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8266
8267 wxPyEndAllowThreads(__tstate);
8268 if (PyErr_Occurred()) SWIG_fail;
8269 }
8270 {
8271 resultobj = SWIG_From_int((int)(result));
8272 }
8273 return resultobj;
8274 fail:
8275 return NULL;
8276 }
8277
8278
8279 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8280 PyObject *resultobj;
8281 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8282 bool result;
8283 PyObject * obj0 = 0 ;
8284 char *kwnames[] = {
8285 (char *) "self", NULL
8286 };
8287
8288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8290 if (SWIG_arg_fail(1)) SWIG_fail;
8291 {
8292 PyThreadState* __tstate = wxPyBeginAllowThreads();
8293 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8294
8295 wxPyEndAllowThreads(__tstate);
8296 if (PyErr_Occurred()) SWIG_fail;
8297 }
8298 {
8299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8300 }
8301 return resultobj;
8302 fail:
8303 return NULL;
8304 }
8305
8306
8307 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8308 PyObject *resultobj;
8309 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8310 int result;
8311 PyObject * obj0 = 0 ;
8312 char *kwnames[] = {
8313 (char *) "self", NULL
8314 };
8315
8316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8318 if (SWIG_arg_fail(1)) SWIG_fail;
8319 {
8320 PyThreadState* __tstate = wxPyBeginAllowThreads();
8321 result = (int)((wxPyTimer const *)arg1)->GetId();
8322
8323 wxPyEndAllowThreads(__tstate);
8324 if (PyErr_Occurred()) SWIG_fail;
8325 }
8326 {
8327 resultobj = SWIG_From_int((int)(result));
8328 }
8329 return resultobj;
8330 fail:
8331 return NULL;
8332 }
8333
8334
8335 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8336 PyObject *obj;
8337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8338 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8339 Py_INCREF(obj);
8340 return Py_BuildValue((char *)"");
8341 }
8342 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8343 PyObject *resultobj;
8344 int arg1 = (int) 0 ;
8345 int arg2 = (int) 0 ;
8346 wxTimerEvent *result;
8347 PyObject * obj0 = 0 ;
8348 PyObject * obj1 = 0 ;
8349 char *kwnames[] = {
8350 (char *) "timerid",(char *) "interval", NULL
8351 };
8352
8353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8354 if (obj0) {
8355 {
8356 arg1 = (int)(SWIG_As_int(obj0));
8357 if (SWIG_arg_fail(1)) SWIG_fail;
8358 }
8359 }
8360 if (obj1) {
8361 {
8362 arg2 = (int)(SWIG_As_int(obj1));
8363 if (SWIG_arg_fail(2)) SWIG_fail;
8364 }
8365 }
8366 {
8367 PyThreadState* __tstate = wxPyBeginAllowThreads();
8368 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8369
8370 wxPyEndAllowThreads(__tstate);
8371 if (PyErr_Occurred()) SWIG_fail;
8372 }
8373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8374 return resultobj;
8375 fail:
8376 return NULL;
8377 }
8378
8379
8380 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8381 PyObject *resultobj;
8382 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8383 int result;
8384 PyObject * obj0 = 0 ;
8385 char *kwnames[] = {
8386 (char *) "self", NULL
8387 };
8388
8389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8391 if (SWIG_arg_fail(1)) SWIG_fail;
8392 {
8393 PyThreadState* __tstate = wxPyBeginAllowThreads();
8394 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8395
8396 wxPyEndAllowThreads(__tstate);
8397 if (PyErr_Occurred()) SWIG_fail;
8398 }
8399 {
8400 resultobj = SWIG_From_int((int)(result));
8401 }
8402 return resultobj;
8403 fail:
8404 return NULL;
8405 }
8406
8407
8408 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8409 PyObject *obj;
8410 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8411 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8412 Py_INCREF(obj);
8413 return Py_BuildValue((char *)"");
8414 }
8415 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8416 PyObject *resultobj;
8417 wxTimer *arg1 = 0 ;
8418 wxTimerRunner *result;
8419 PyObject * obj0 = 0 ;
8420
8421 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8422 {
8423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8424 if (SWIG_arg_fail(1)) SWIG_fail;
8425 if (arg1 == NULL) {
8426 SWIG_null_ref("wxTimer");
8427 }
8428 if (SWIG_arg_fail(1)) SWIG_fail;
8429 }
8430 {
8431 if (!wxPyCheckForApp()) SWIG_fail;
8432 PyThreadState* __tstate = wxPyBeginAllowThreads();
8433 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8434
8435 wxPyEndAllowThreads(__tstate);
8436 if (PyErr_Occurred()) SWIG_fail;
8437 }
8438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8439 return resultobj;
8440 fail:
8441 return NULL;
8442 }
8443
8444
8445 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8446 PyObject *resultobj;
8447 wxTimer *arg1 = 0 ;
8448 int arg2 ;
8449 bool arg3 = (bool) false ;
8450 wxTimerRunner *result;
8451 PyObject * obj0 = 0 ;
8452 PyObject * obj1 = 0 ;
8453 PyObject * obj2 = 0 ;
8454
8455 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8456 {
8457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8458 if (SWIG_arg_fail(1)) SWIG_fail;
8459 if (arg1 == NULL) {
8460 SWIG_null_ref("wxTimer");
8461 }
8462 if (SWIG_arg_fail(1)) SWIG_fail;
8463 }
8464 {
8465 arg2 = (int)(SWIG_As_int(obj1));
8466 if (SWIG_arg_fail(2)) SWIG_fail;
8467 }
8468 if (obj2) {
8469 {
8470 arg3 = (bool)(SWIG_As_bool(obj2));
8471 if (SWIG_arg_fail(3)) SWIG_fail;
8472 }
8473 }
8474 {
8475 if (!wxPyCheckForApp()) SWIG_fail;
8476 PyThreadState* __tstate = wxPyBeginAllowThreads();
8477 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8478
8479 wxPyEndAllowThreads(__tstate);
8480 if (PyErr_Occurred()) SWIG_fail;
8481 }
8482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8483 return resultobj;
8484 fail:
8485 return NULL;
8486 }
8487
8488
8489 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8490 int argc;
8491 PyObject *argv[4];
8492 int ii;
8493
8494 argc = PyObject_Length(args);
8495 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8496 argv[ii] = PyTuple_GetItem(args,ii);
8497 }
8498 if (argc == 1) {
8499 int _v;
8500 {
8501 void *ptr = 0;
8502 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8503 _v = 0;
8504 PyErr_Clear();
8505 } else {
8506 _v = (ptr != 0);
8507 }
8508 }
8509 if (_v) {
8510 return _wrap_new_TimerRunner__SWIG_0(self,args);
8511 }
8512 }
8513 if ((argc >= 2) && (argc <= 3)) {
8514 int _v;
8515 {
8516 void *ptr = 0;
8517 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8518 _v = 0;
8519 PyErr_Clear();
8520 } else {
8521 _v = (ptr != 0);
8522 }
8523 }
8524 if (_v) {
8525 _v = SWIG_Check_int(argv[1]);
8526 if (_v) {
8527 if (argc <= 2) {
8528 return _wrap_new_TimerRunner__SWIG_1(self,args);
8529 }
8530 _v = SWIG_Check_bool(argv[2]);
8531 if (_v) {
8532 return _wrap_new_TimerRunner__SWIG_1(self,args);
8533 }
8534 }
8535 }
8536 }
8537
8538 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8539 return NULL;
8540 }
8541
8542
8543 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8544 PyObject *resultobj;
8545 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8546 PyObject * obj0 = 0 ;
8547 char *kwnames[] = {
8548 (char *) "self", NULL
8549 };
8550
8551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8553 if (SWIG_arg_fail(1)) SWIG_fail;
8554 {
8555 PyThreadState* __tstate = wxPyBeginAllowThreads();
8556 delete arg1;
8557
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 Py_INCREF(Py_None); resultobj = Py_None;
8562 return resultobj;
8563 fail:
8564 return NULL;
8565 }
8566
8567
8568 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8569 PyObject *resultobj;
8570 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8571 int arg2 ;
8572 bool arg3 = (bool) false ;
8573 PyObject * obj0 = 0 ;
8574 PyObject * obj1 = 0 ;
8575 PyObject * obj2 = 0 ;
8576 char *kwnames[] = {
8577 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8578 };
8579
8580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8582 if (SWIG_arg_fail(1)) SWIG_fail;
8583 {
8584 arg2 = (int)(SWIG_As_int(obj1));
8585 if (SWIG_arg_fail(2)) SWIG_fail;
8586 }
8587 if (obj2) {
8588 {
8589 arg3 = (bool)(SWIG_As_bool(obj2));
8590 if (SWIG_arg_fail(3)) SWIG_fail;
8591 }
8592 }
8593 {
8594 PyThreadState* __tstate = wxPyBeginAllowThreads();
8595 (arg1)->Start(arg2,arg3);
8596
8597 wxPyEndAllowThreads(__tstate);
8598 if (PyErr_Occurred()) SWIG_fail;
8599 }
8600 Py_INCREF(Py_None); resultobj = Py_None;
8601 return resultobj;
8602 fail:
8603 return NULL;
8604 }
8605
8606
8607 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8608 PyObject *obj;
8609 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8610 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8611 Py_INCREF(obj);
8612 return Py_BuildValue((char *)"");
8613 }
8614 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj;
8616 wxLog *result;
8617 char *kwnames[] = {
8618 NULL
8619 };
8620
8621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8622 {
8623 PyThreadState* __tstate = wxPyBeginAllowThreads();
8624 result = (wxLog *)new wxLog();
8625
8626 wxPyEndAllowThreads(__tstate);
8627 if (PyErr_Occurred()) SWIG_fail;
8628 }
8629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8630 return resultobj;
8631 fail:
8632 return NULL;
8633 }
8634
8635
8636 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8637 PyObject *resultobj;
8638 bool result;
8639 char *kwnames[] = {
8640 NULL
8641 };
8642
8643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8644 {
8645 PyThreadState* __tstate = wxPyBeginAllowThreads();
8646 result = (bool)wxLog::IsEnabled();
8647
8648 wxPyEndAllowThreads(__tstate);
8649 if (PyErr_Occurred()) SWIG_fail;
8650 }
8651 {
8652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8653 }
8654 return resultobj;
8655 fail:
8656 return NULL;
8657 }
8658
8659
8660 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8661 PyObject *resultobj;
8662 bool arg1 = (bool) true ;
8663 bool result;
8664 PyObject * obj0 = 0 ;
8665 char *kwnames[] = {
8666 (char *) "doIt", NULL
8667 };
8668
8669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8670 if (obj0) {
8671 {
8672 arg1 = (bool)(SWIG_As_bool(obj0));
8673 if (SWIG_arg_fail(1)) SWIG_fail;
8674 }
8675 }
8676 {
8677 PyThreadState* __tstate = wxPyBeginAllowThreads();
8678 result = (bool)wxLog::EnableLogging(arg1);
8679
8680 wxPyEndAllowThreads(__tstate);
8681 if (PyErr_Occurred()) SWIG_fail;
8682 }
8683 {
8684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8685 }
8686 return resultobj;
8687 fail:
8688 return NULL;
8689 }
8690
8691
8692 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8693 PyObject *resultobj;
8694 wxLogLevel arg1 ;
8695 wxChar *arg2 = (wxChar *) 0 ;
8696 time_t arg3 ;
8697 PyObject * obj0 = 0 ;
8698 PyObject * obj1 = 0 ;
8699 PyObject * obj2 = 0 ;
8700 char *kwnames[] = {
8701 (char *) "level",(char *) "szString",(char *) "t", NULL
8702 };
8703
8704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8705 {
8706 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8707 if (SWIG_arg_fail(1)) SWIG_fail;
8708 }
8709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8710 if (SWIG_arg_fail(2)) SWIG_fail;
8711 {
8712 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8713 if (SWIG_arg_fail(3)) SWIG_fail;
8714 }
8715 {
8716 PyThreadState* __tstate = wxPyBeginAllowThreads();
8717 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8718
8719 wxPyEndAllowThreads(__tstate);
8720 if (PyErr_Occurred()) SWIG_fail;
8721 }
8722 Py_INCREF(Py_None); resultobj = Py_None;
8723 return resultobj;
8724 fail:
8725 return NULL;
8726 }
8727
8728
8729 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8730 PyObject *resultobj;
8731 wxLog *arg1 = (wxLog *) 0 ;
8732 PyObject * obj0 = 0 ;
8733 char *kwnames[] = {
8734 (char *) "self", NULL
8735 };
8736
8737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8739 if (SWIG_arg_fail(1)) SWIG_fail;
8740 {
8741 PyThreadState* __tstate = wxPyBeginAllowThreads();
8742 (arg1)->Flush();
8743
8744 wxPyEndAllowThreads(__tstate);
8745 if (PyErr_Occurred()) SWIG_fail;
8746 }
8747 Py_INCREF(Py_None); resultobj = Py_None;
8748 return resultobj;
8749 fail:
8750 return NULL;
8751 }
8752
8753
8754 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8755 PyObject *resultobj;
8756 char *kwnames[] = {
8757 NULL
8758 };
8759
8760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8761 {
8762 PyThreadState* __tstate = wxPyBeginAllowThreads();
8763 wxLog::FlushActive();
8764
8765 wxPyEndAllowThreads(__tstate);
8766 if (PyErr_Occurred()) SWIG_fail;
8767 }
8768 Py_INCREF(Py_None); resultobj = Py_None;
8769 return resultobj;
8770 fail:
8771 return NULL;
8772 }
8773
8774
8775 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8776 PyObject *resultobj;
8777 wxLog *result;
8778 char *kwnames[] = {
8779 NULL
8780 };
8781
8782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8783 {
8784 PyThreadState* __tstate = wxPyBeginAllowThreads();
8785 result = (wxLog *)wxLog::GetActiveTarget();
8786
8787 wxPyEndAllowThreads(__tstate);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8791 return resultobj;
8792 fail:
8793 return NULL;
8794 }
8795
8796
8797 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj;
8799 wxLog *arg1 = (wxLog *) 0 ;
8800 wxLog *result;
8801 PyObject * obj0 = 0 ;
8802 char *kwnames[] = {
8803 (char *) "pLogger", NULL
8804 };
8805
8806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8808 if (SWIG_arg_fail(1)) SWIG_fail;
8809 {
8810 PyThreadState* __tstate = wxPyBeginAllowThreads();
8811 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8812
8813 wxPyEndAllowThreads(__tstate);
8814 if (PyErr_Occurred()) SWIG_fail;
8815 }
8816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8817 return resultobj;
8818 fail:
8819 return NULL;
8820 }
8821
8822
8823 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8824 PyObject *resultobj;
8825 char *kwnames[] = {
8826 NULL
8827 };
8828
8829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8830 {
8831 PyThreadState* __tstate = wxPyBeginAllowThreads();
8832 wxLog::Suspend();
8833
8834 wxPyEndAllowThreads(__tstate);
8835 if (PyErr_Occurred()) SWIG_fail;
8836 }
8837 Py_INCREF(Py_None); resultobj = Py_None;
8838 return resultobj;
8839 fail:
8840 return NULL;
8841 }
8842
8843
8844 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8845 PyObject *resultobj;
8846 char *kwnames[] = {
8847 NULL
8848 };
8849
8850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8851 {
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 wxLog::Resume();
8854
8855 wxPyEndAllowThreads(__tstate);
8856 if (PyErr_Occurred()) SWIG_fail;
8857 }
8858 Py_INCREF(Py_None); resultobj = Py_None;
8859 return resultobj;
8860 fail:
8861 return NULL;
8862 }
8863
8864
8865 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8866 PyObject *resultobj;
8867 bool arg1 = (bool) true ;
8868 PyObject * obj0 = 0 ;
8869 char *kwnames[] = {
8870 (char *) "bVerbose", NULL
8871 };
8872
8873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8874 if (obj0) {
8875 {
8876 arg1 = (bool)(SWIG_As_bool(obj0));
8877 if (SWIG_arg_fail(1)) SWIG_fail;
8878 }
8879 }
8880 {
8881 PyThreadState* __tstate = wxPyBeginAllowThreads();
8882 wxLog::SetVerbose(arg1);
8883
8884 wxPyEndAllowThreads(__tstate);
8885 if (PyErr_Occurred()) SWIG_fail;
8886 }
8887 Py_INCREF(Py_None); resultobj = Py_None;
8888 return resultobj;
8889 fail:
8890 return NULL;
8891 }
8892
8893
8894 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8895 PyObject *resultobj;
8896 wxLogLevel arg1 ;
8897 PyObject * obj0 = 0 ;
8898 char *kwnames[] = {
8899 (char *) "logLevel", NULL
8900 };
8901
8902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8903 {
8904 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8905 if (SWIG_arg_fail(1)) SWIG_fail;
8906 }
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 wxLog::SetLogLevel(arg1);
8910
8911 wxPyEndAllowThreads(__tstate);
8912 if (PyErr_Occurred()) SWIG_fail;
8913 }
8914 Py_INCREF(Py_None); resultobj = Py_None;
8915 return resultobj;
8916 fail:
8917 return NULL;
8918 }
8919
8920
8921 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8922 PyObject *resultobj;
8923 char *kwnames[] = {
8924 NULL
8925 };
8926
8927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 wxLog::DontCreateOnDemand();
8931
8932 wxPyEndAllowThreads(__tstate);
8933 if (PyErr_Occurred()) SWIG_fail;
8934 }
8935 Py_INCREF(Py_None); resultobj = Py_None;
8936 return resultobj;
8937 fail:
8938 return NULL;
8939 }
8940
8941
8942 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8943 PyObject *resultobj;
8944 wxTraceMask arg1 ;
8945 PyObject * obj0 = 0 ;
8946 char *kwnames[] = {
8947 (char *) "ulMask", NULL
8948 };
8949
8950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8951 {
8952 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8953 if (SWIG_arg_fail(1)) SWIG_fail;
8954 }
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 wxLog::SetTraceMask(arg1);
8958
8959 wxPyEndAllowThreads(__tstate);
8960 if (PyErr_Occurred()) SWIG_fail;
8961 }
8962 Py_INCREF(Py_None); resultobj = Py_None;
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8970 PyObject *resultobj;
8971 wxString *arg1 = 0 ;
8972 bool temp1 = false ;
8973 PyObject * obj0 = 0 ;
8974 char *kwnames[] = {
8975 (char *) "str", NULL
8976 };
8977
8978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
8979 {
8980 arg1 = wxString_in_helper(obj0);
8981 if (arg1 == NULL) SWIG_fail;
8982 temp1 = true;
8983 }
8984 {
8985 PyThreadState* __tstate = wxPyBeginAllowThreads();
8986 wxLog::AddTraceMask((wxString const &)*arg1);
8987
8988 wxPyEndAllowThreads(__tstate);
8989 if (PyErr_Occurred()) SWIG_fail;
8990 }
8991 Py_INCREF(Py_None); resultobj = Py_None;
8992 {
8993 if (temp1)
8994 delete arg1;
8995 }
8996 return resultobj;
8997 fail:
8998 {
8999 if (temp1)
9000 delete arg1;
9001 }
9002 return NULL;
9003 }
9004
9005
9006 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9007 PyObject *resultobj;
9008 wxString *arg1 = 0 ;
9009 bool temp1 = false ;
9010 PyObject * obj0 = 0 ;
9011 char *kwnames[] = {
9012 (char *) "str", NULL
9013 };
9014
9015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9016 {
9017 arg1 = wxString_in_helper(obj0);
9018 if (arg1 == NULL) SWIG_fail;
9019 temp1 = true;
9020 }
9021 {
9022 PyThreadState* __tstate = wxPyBeginAllowThreads();
9023 wxLog::RemoveTraceMask((wxString const &)*arg1);
9024
9025 wxPyEndAllowThreads(__tstate);
9026 if (PyErr_Occurred()) SWIG_fail;
9027 }
9028 Py_INCREF(Py_None); resultobj = Py_None;
9029 {
9030 if (temp1)
9031 delete arg1;
9032 }
9033 return resultobj;
9034 fail:
9035 {
9036 if (temp1)
9037 delete arg1;
9038 }
9039 return NULL;
9040 }
9041
9042
9043 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj;
9045 char *kwnames[] = {
9046 NULL
9047 };
9048
9049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9050 {
9051 PyThreadState* __tstate = wxPyBeginAllowThreads();
9052 wxLog::ClearTraceMasks();
9053
9054 wxPyEndAllowThreads(__tstate);
9055 if (PyErr_Occurred()) SWIG_fail;
9056 }
9057 Py_INCREF(Py_None); resultobj = Py_None;
9058 return resultobj;
9059 fail:
9060 return NULL;
9061 }
9062
9063
9064 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9065 PyObject *resultobj;
9066 wxArrayString *result;
9067 char *kwnames[] = {
9068 NULL
9069 };
9070
9071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9072 {
9073 PyThreadState* __tstate = wxPyBeginAllowThreads();
9074 {
9075 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9076 result = (wxArrayString *) &_result_ref;
9077 }
9078
9079 wxPyEndAllowThreads(__tstate);
9080 if (PyErr_Occurred()) SWIG_fail;
9081 }
9082 {
9083 resultobj = wxArrayString2PyList_helper(*result);
9084 }
9085 return resultobj;
9086 fail:
9087 return NULL;
9088 }
9089
9090
9091 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9092 PyObject *resultobj;
9093 wxChar *arg1 = (wxChar *) 0 ;
9094 PyObject * obj0 = 0 ;
9095 char *kwnames[] = {
9096 (char *) "ts", NULL
9097 };
9098
9099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9101 if (SWIG_arg_fail(1)) SWIG_fail;
9102 {
9103 PyThreadState* __tstate = wxPyBeginAllowThreads();
9104 wxLog::SetTimestamp((wxChar const *)arg1);
9105
9106 wxPyEndAllowThreads(__tstate);
9107 if (PyErr_Occurred()) SWIG_fail;
9108 }
9109 Py_INCREF(Py_None); resultobj = Py_None;
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj;
9118 bool result;
9119 char *kwnames[] = {
9120 NULL
9121 };
9122
9123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9124 {
9125 PyThreadState* __tstate = wxPyBeginAllowThreads();
9126 result = (bool)wxLog::GetVerbose();
9127
9128 wxPyEndAllowThreads(__tstate);
9129 if (PyErr_Occurred()) SWIG_fail;
9130 }
9131 {
9132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9133 }
9134 return resultobj;
9135 fail:
9136 return NULL;
9137 }
9138
9139
9140 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9141 PyObject *resultobj;
9142 wxTraceMask result;
9143 char *kwnames[] = {
9144 NULL
9145 };
9146
9147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9148 {
9149 PyThreadState* __tstate = wxPyBeginAllowThreads();
9150 result = (wxTraceMask)wxLog::GetTraceMask();
9151
9152 wxPyEndAllowThreads(__tstate);
9153 if (PyErr_Occurred()) SWIG_fail;
9154 }
9155 {
9156 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9157 }
9158 return resultobj;
9159 fail:
9160 return NULL;
9161 }
9162
9163
9164 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9165 PyObject *resultobj;
9166 wxChar *arg1 = (wxChar *) 0 ;
9167 bool result;
9168 PyObject * obj0 = 0 ;
9169 char *kwnames[] = {
9170 (char *) "mask", NULL
9171 };
9172
9173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9175 if (SWIG_arg_fail(1)) SWIG_fail;
9176 {
9177 PyThreadState* __tstate = wxPyBeginAllowThreads();
9178 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9179
9180 wxPyEndAllowThreads(__tstate);
9181 if (PyErr_Occurred()) SWIG_fail;
9182 }
9183 {
9184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9185 }
9186 return resultobj;
9187 fail:
9188 return NULL;
9189 }
9190
9191
9192 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9193 PyObject *resultobj;
9194 wxLogLevel result;
9195 char *kwnames[] = {
9196 NULL
9197 };
9198
9199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9200 {
9201 PyThreadState* __tstate = wxPyBeginAllowThreads();
9202 result = (wxLogLevel)wxLog::GetLogLevel();
9203
9204 wxPyEndAllowThreads(__tstate);
9205 if (PyErr_Occurred()) SWIG_fail;
9206 }
9207 {
9208 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9209 }
9210 return resultobj;
9211 fail:
9212 return NULL;
9213 }
9214
9215
9216 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9217 PyObject *resultobj;
9218 wxChar *result;
9219 char *kwnames[] = {
9220 NULL
9221 };
9222
9223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9224 {
9225 PyThreadState* __tstate = wxPyBeginAllowThreads();
9226 result = (wxChar *)wxLog::GetTimestamp();
9227
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9232 return resultobj;
9233 fail:
9234 return NULL;
9235 }
9236
9237
9238 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9239 PyObject *resultobj;
9240 wxString result;
9241 char *kwnames[] = {
9242 NULL
9243 };
9244
9245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9246 {
9247 PyThreadState* __tstate = wxPyBeginAllowThreads();
9248 result = Log_TimeStamp();
9249
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 {
9254 #if wxUSE_UNICODE
9255 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9256 #else
9257 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9258 #endif
9259 }
9260 return resultobj;
9261 fail:
9262 return NULL;
9263 }
9264
9265
9266 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9267 PyObject *resultobj;
9268 wxLog *arg1 = (wxLog *) 0 ;
9269 PyObject * obj0 = 0 ;
9270 char *kwnames[] = {
9271 (char *) "self", NULL
9272 };
9273
9274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9276 if (SWIG_arg_fail(1)) SWIG_fail;
9277 {
9278 PyThreadState* __tstate = wxPyBeginAllowThreads();
9279 wxLog_Destroy(arg1);
9280
9281 wxPyEndAllowThreads(__tstate);
9282 if (PyErr_Occurred()) SWIG_fail;
9283 }
9284 Py_INCREF(Py_None); resultobj = Py_None;
9285 return resultobj;
9286 fail:
9287 return NULL;
9288 }
9289
9290
9291 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9292 PyObject *obj;
9293 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9294 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9295 Py_INCREF(obj);
9296 return Py_BuildValue((char *)"");
9297 }
9298 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9299 PyObject *resultobj;
9300 wxLogStderr *result;
9301 char *kwnames[] = {
9302 NULL
9303 };
9304
9305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9306 {
9307 PyThreadState* __tstate = wxPyBeginAllowThreads();
9308 result = (wxLogStderr *)new wxLogStderr();
9309
9310 wxPyEndAllowThreads(__tstate);
9311 if (PyErr_Occurred()) SWIG_fail;
9312 }
9313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9314 return resultobj;
9315 fail:
9316 return NULL;
9317 }
9318
9319
9320 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9321 PyObject *obj;
9322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9323 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9324 Py_INCREF(obj);
9325 return Py_BuildValue((char *)"");
9326 }
9327 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9328 PyObject *resultobj;
9329 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9330 wxLogTextCtrl *result;
9331 PyObject * obj0 = 0 ;
9332 char *kwnames[] = {
9333 (char *) "pTextCtrl", NULL
9334 };
9335
9336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9338 if (SWIG_arg_fail(1)) SWIG_fail;
9339 {
9340 PyThreadState* __tstate = wxPyBeginAllowThreads();
9341 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9342
9343 wxPyEndAllowThreads(__tstate);
9344 if (PyErr_Occurred()) SWIG_fail;
9345 }
9346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9347 return resultobj;
9348 fail:
9349 return NULL;
9350 }
9351
9352
9353 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9354 PyObject *obj;
9355 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9356 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9357 Py_INCREF(obj);
9358 return Py_BuildValue((char *)"");
9359 }
9360 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9361 PyObject *resultobj;
9362 wxLogGui *result;
9363 char *kwnames[] = {
9364 NULL
9365 };
9366
9367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9368 {
9369 PyThreadState* __tstate = wxPyBeginAllowThreads();
9370 result = (wxLogGui *)new wxLogGui();
9371
9372 wxPyEndAllowThreads(__tstate);
9373 if (PyErr_Occurred()) SWIG_fail;
9374 }
9375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9376 return resultobj;
9377 fail:
9378 return NULL;
9379 }
9380
9381
9382 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9383 PyObject *obj;
9384 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9385 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9386 Py_INCREF(obj);
9387 return Py_BuildValue((char *)"");
9388 }
9389 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9390 PyObject *resultobj;
9391 wxFrame *arg1 = (wxFrame *) 0 ;
9392 wxString *arg2 = 0 ;
9393 bool arg3 = (bool) true ;
9394 bool arg4 = (bool) true ;
9395 wxLogWindow *result;
9396 bool temp2 = false ;
9397 PyObject * obj0 = 0 ;
9398 PyObject * obj1 = 0 ;
9399 PyObject * obj2 = 0 ;
9400 PyObject * obj3 = 0 ;
9401 char *kwnames[] = {
9402 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9403 };
9404
9405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9407 if (SWIG_arg_fail(1)) SWIG_fail;
9408 {
9409 arg2 = wxString_in_helper(obj1);
9410 if (arg2 == NULL) SWIG_fail;
9411 temp2 = true;
9412 }
9413 if (obj2) {
9414 {
9415 arg3 = (bool)(SWIG_As_bool(obj2));
9416 if (SWIG_arg_fail(3)) SWIG_fail;
9417 }
9418 }
9419 if (obj3) {
9420 {
9421 arg4 = (bool)(SWIG_As_bool(obj3));
9422 if (SWIG_arg_fail(4)) SWIG_fail;
9423 }
9424 }
9425 {
9426 PyThreadState* __tstate = wxPyBeginAllowThreads();
9427 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9428
9429 wxPyEndAllowThreads(__tstate);
9430 if (PyErr_Occurred()) SWIG_fail;
9431 }
9432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9433 {
9434 if (temp2)
9435 delete arg2;
9436 }
9437 return resultobj;
9438 fail:
9439 {
9440 if (temp2)
9441 delete arg2;
9442 }
9443 return NULL;
9444 }
9445
9446
9447 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9448 PyObject *resultobj;
9449 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9450 bool arg2 = (bool) true ;
9451 PyObject * obj0 = 0 ;
9452 PyObject * obj1 = 0 ;
9453 char *kwnames[] = {
9454 (char *) "self",(char *) "bShow", NULL
9455 };
9456
9457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9459 if (SWIG_arg_fail(1)) SWIG_fail;
9460 if (obj1) {
9461 {
9462 arg2 = (bool)(SWIG_As_bool(obj1));
9463 if (SWIG_arg_fail(2)) SWIG_fail;
9464 }
9465 }
9466 {
9467 PyThreadState* __tstate = wxPyBeginAllowThreads();
9468 (arg1)->Show(arg2);
9469
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 Py_INCREF(Py_None); resultobj = Py_None;
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9481 PyObject *resultobj;
9482 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9483 wxFrame *result;
9484 PyObject * obj0 = 0 ;
9485 char *kwnames[] = {
9486 (char *) "self", NULL
9487 };
9488
9489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9491 if (SWIG_arg_fail(1)) SWIG_fail;
9492 {
9493 PyThreadState* __tstate = wxPyBeginAllowThreads();
9494 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9495
9496 wxPyEndAllowThreads(__tstate);
9497 if (PyErr_Occurred()) SWIG_fail;
9498 }
9499 {
9500 resultobj = wxPyMake_wxObject(result, 0);
9501 }
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj;
9510 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9511 wxLog *result;
9512 PyObject * obj0 = 0 ;
9513 char *kwnames[] = {
9514 (char *) "self", NULL
9515 };
9516
9517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9519 if (SWIG_arg_fail(1)) SWIG_fail;
9520 {
9521 PyThreadState* __tstate = wxPyBeginAllowThreads();
9522 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9523
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9528 return resultobj;
9529 fail:
9530 return NULL;
9531 }
9532
9533
9534 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9535 PyObject *resultobj;
9536 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9537 bool result;
9538 PyObject * obj0 = 0 ;
9539 char *kwnames[] = {
9540 (char *) "self", NULL
9541 };
9542
9543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9545 if (SWIG_arg_fail(1)) SWIG_fail;
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9549
9550 wxPyEndAllowThreads(__tstate);
9551 if (PyErr_Occurred()) SWIG_fail;
9552 }
9553 {
9554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9555 }
9556 return resultobj;
9557 fail:
9558 return NULL;
9559 }
9560
9561
9562 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9563 PyObject *resultobj;
9564 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9565 bool arg2 ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char *kwnames[] = {
9569 (char *) "self",(char *) "bDoPass", NULL
9570 };
9571
9572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9574 if (SWIG_arg_fail(1)) SWIG_fail;
9575 {
9576 arg2 = (bool)(SWIG_As_bool(obj1));
9577 if (SWIG_arg_fail(2)) SWIG_fail;
9578 }
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 (arg1)->PassMessages(arg2);
9582
9583 wxPyEndAllowThreads(__tstate);
9584 if (PyErr_Occurred()) SWIG_fail;
9585 }
9586 Py_INCREF(Py_None); resultobj = Py_None;
9587 return resultobj;
9588 fail:
9589 return NULL;
9590 }
9591
9592
9593 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9594 PyObject *obj;
9595 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9596 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9597 Py_INCREF(obj);
9598 return Py_BuildValue((char *)"");
9599 }
9600 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9601 PyObject *resultobj;
9602 wxLog *arg1 = (wxLog *) 0 ;
9603 wxLogChain *result;
9604 PyObject * obj0 = 0 ;
9605 char *kwnames[] = {
9606 (char *) "logger", NULL
9607 };
9608
9609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9611 if (SWIG_arg_fail(1)) SWIG_fail;
9612 {
9613 PyThreadState* __tstate = wxPyBeginAllowThreads();
9614 result = (wxLogChain *)new wxLogChain(arg1);
9615
9616 wxPyEndAllowThreads(__tstate);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj;
9628 wxLogChain *arg1 = (wxLogChain *) 0 ;
9629 wxLog *arg2 = (wxLog *) 0 ;
9630 PyObject * obj0 = 0 ;
9631 PyObject * obj1 = 0 ;
9632 char *kwnames[] = {
9633 (char *) "self",(char *) "logger", NULL
9634 };
9635
9636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9638 if (SWIG_arg_fail(1)) SWIG_fail;
9639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9640 if (SWIG_arg_fail(2)) SWIG_fail;
9641 {
9642 PyThreadState* __tstate = wxPyBeginAllowThreads();
9643 (arg1)->SetLog(arg2);
9644
9645 wxPyEndAllowThreads(__tstate);
9646 if (PyErr_Occurred()) SWIG_fail;
9647 }
9648 Py_INCREF(Py_None); resultobj = Py_None;
9649 return resultobj;
9650 fail:
9651 return NULL;
9652 }
9653
9654
9655 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9656 PyObject *resultobj;
9657 wxLogChain *arg1 = (wxLogChain *) 0 ;
9658 bool arg2 ;
9659 PyObject * obj0 = 0 ;
9660 PyObject * obj1 = 0 ;
9661 char *kwnames[] = {
9662 (char *) "self",(char *) "bDoPass", NULL
9663 };
9664
9665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9667 if (SWIG_arg_fail(1)) SWIG_fail;
9668 {
9669 arg2 = (bool)(SWIG_As_bool(obj1));
9670 if (SWIG_arg_fail(2)) SWIG_fail;
9671 }
9672 {
9673 PyThreadState* __tstate = wxPyBeginAllowThreads();
9674 (arg1)->PassMessages(arg2);
9675
9676 wxPyEndAllowThreads(__tstate);
9677 if (PyErr_Occurred()) SWIG_fail;
9678 }
9679 Py_INCREF(Py_None); resultobj = Py_None;
9680 return resultobj;
9681 fail:
9682 return NULL;
9683 }
9684
9685
9686 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9687 PyObject *resultobj;
9688 wxLogChain *arg1 = (wxLogChain *) 0 ;
9689 bool result;
9690 PyObject * obj0 = 0 ;
9691 char *kwnames[] = {
9692 (char *) "self", NULL
9693 };
9694
9695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9697 if (SWIG_arg_fail(1)) SWIG_fail;
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 result = (bool)(arg1)->IsPassingMessages();
9701
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 {
9706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9707 }
9708 return resultobj;
9709 fail:
9710 return NULL;
9711 }
9712
9713
9714 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9715 PyObject *resultobj;
9716 wxLogChain *arg1 = (wxLogChain *) 0 ;
9717 wxLog *result;
9718 PyObject * obj0 = 0 ;
9719 char *kwnames[] = {
9720 (char *) "self", NULL
9721 };
9722
9723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9725 if (SWIG_arg_fail(1)) SWIG_fail;
9726 {
9727 PyThreadState* __tstate = wxPyBeginAllowThreads();
9728 result = (wxLog *)(arg1)->GetOldLog();
9729
9730 wxPyEndAllowThreads(__tstate);
9731 if (PyErr_Occurred()) SWIG_fail;
9732 }
9733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9734 return resultobj;
9735 fail:
9736 return NULL;
9737 }
9738
9739
9740 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9741 PyObject *obj;
9742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9743 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9744 Py_INCREF(obj);
9745 return Py_BuildValue((char *)"");
9746 }
9747 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9748 PyObject *resultobj;
9749 unsigned long result;
9750 char *kwnames[] = {
9751 NULL
9752 };
9753
9754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9755 {
9756 PyThreadState* __tstate = wxPyBeginAllowThreads();
9757 result = (unsigned long)wxSysErrorCode();
9758
9759 wxPyEndAllowThreads(__tstate);
9760 if (PyErr_Occurred()) SWIG_fail;
9761 }
9762 {
9763 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9764 }
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9772 PyObject *resultobj;
9773 unsigned long arg1 = (unsigned long) 0 ;
9774 wxString result;
9775 PyObject * obj0 = 0 ;
9776 char *kwnames[] = {
9777 (char *) "nErrCode", NULL
9778 };
9779
9780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9781 if (obj0) {
9782 {
9783 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9784 if (SWIG_arg_fail(1)) SWIG_fail;
9785 }
9786 }
9787 {
9788 PyThreadState* __tstate = wxPyBeginAllowThreads();
9789 result = wxSysErrorMsg(arg1);
9790
9791 wxPyEndAllowThreads(__tstate);
9792 if (PyErr_Occurred()) SWIG_fail;
9793 }
9794 {
9795 #if wxUSE_UNICODE
9796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9797 #else
9798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9799 #endif
9800 }
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9808 PyObject *resultobj;
9809 wxString *arg1 = 0 ;
9810 bool temp1 = false ;
9811 PyObject * obj0 = 0 ;
9812 char *kwnames[] = {
9813 (char *) "msg", NULL
9814 };
9815
9816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9817 {
9818 arg1 = wxString_in_helper(obj0);
9819 if (arg1 == NULL) SWIG_fail;
9820 temp1 = true;
9821 }
9822 {
9823 PyThreadState* __tstate = wxPyBeginAllowThreads();
9824 wxPyLogFatalError((wxString const &)*arg1);
9825
9826 wxPyEndAllowThreads(__tstate);
9827 if (PyErr_Occurred()) SWIG_fail;
9828 }
9829 Py_INCREF(Py_None); resultobj = Py_None;
9830 {
9831 if (temp1)
9832 delete arg1;
9833 }
9834 return resultobj;
9835 fail:
9836 {
9837 if (temp1)
9838 delete arg1;
9839 }
9840 return NULL;
9841 }
9842
9843
9844 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9845 PyObject *resultobj;
9846 wxString *arg1 = 0 ;
9847 bool temp1 = false ;
9848 PyObject * obj0 = 0 ;
9849 char *kwnames[] = {
9850 (char *) "msg", NULL
9851 };
9852
9853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9854 {
9855 arg1 = wxString_in_helper(obj0);
9856 if (arg1 == NULL) SWIG_fail;
9857 temp1 = true;
9858 }
9859 {
9860 PyThreadState* __tstate = wxPyBeginAllowThreads();
9861 wxPyLogError((wxString const &)*arg1);
9862
9863 wxPyEndAllowThreads(__tstate);
9864 if (PyErr_Occurred()) SWIG_fail;
9865 }
9866 Py_INCREF(Py_None); resultobj = Py_None;
9867 {
9868 if (temp1)
9869 delete arg1;
9870 }
9871 return resultobj;
9872 fail:
9873 {
9874 if (temp1)
9875 delete arg1;
9876 }
9877 return NULL;
9878 }
9879
9880
9881 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9882 PyObject *resultobj;
9883 wxString *arg1 = 0 ;
9884 bool temp1 = false ;
9885 PyObject * obj0 = 0 ;
9886 char *kwnames[] = {
9887 (char *) "msg", NULL
9888 };
9889
9890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9891 {
9892 arg1 = wxString_in_helper(obj0);
9893 if (arg1 == NULL) SWIG_fail;
9894 temp1 = true;
9895 }
9896 {
9897 PyThreadState* __tstate = wxPyBeginAllowThreads();
9898 wxPyLogWarning((wxString const &)*arg1);
9899
9900 wxPyEndAllowThreads(__tstate);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 Py_INCREF(Py_None); resultobj = Py_None;
9904 {
9905 if (temp1)
9906 delete arg1;
9907 }
9908 return resultobj;
9909 fail:
9910 {
9911 if (temp1)
9912 delete arg1;
9913 }
9914 return NULL;
9915 }
9916
9917
9918 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9919 PyObject *resultobj;
9920 wxString *arg1 = 0 ;
9921 bool temp1 = false ;
9922 PyObject * obj0 = 0 ;
9923 char *kwnames[] = {
9924 (char *) "msg", NULL
9925 };
9926
9927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9928 {
9929 arg1 = wxString_in_helper(obj0);
9930 if (arg1 == NULL) SWIG_fail;
9931 temp1 = true;
9932 }
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 wxPyLogMessage((wxString const &)*arg1);
9936
9937 wxPyEndAllowThreads(__tstate);
9938 if (PyErr_Occurred()) SWIG_fail;
9939 }
9940 Py_INCREF(Py_None); resultobj = Py_None;
9941 {
9942 if (temp1)
9943 delete arg1;
9944 }
9945 return resultobj;
9946 fail:
9947 {
9948 if (temp1)
9949 delete arg1;
9950 }
9951 return NULL;
9952 }
9953
9954
9955 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9956 PyObject *resultobj;
9957 wxString *arg1 = 0 ;
9958 bool temp1 = false ;
9959 PyObject * obj0 = 0 ;
9960 char *kwnames[] = {
9961 (char *) "msg", NULL
9962 };
9963
9964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9965 {
9966 arg1 = wxString_in_helper(obj0);
9967 if (arg1 == NULL) SWIG_fail;
9968 temp1 = true;
9969 }
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 wxPyLogInfo((wxString const &)*arg1);
9973
9974 wxPyEndAllowThreads(__tstate);
9975 if (PyErr_Occurred()) SWIG_fail;
9976 }
9977 Py_INCREF(Py_None); resultobj = Py_None;
9978 {
9979 if (temp1)
9980 delete arg1;
9981 }
9982 return resultobj;
9983 fail:
9984 {
9985 if (temp1)
9986 delete arg1;
9987 }
9988 return NULL;
9989 }
9990
9991
9992 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj;
9994 wxString *arg1 = 0 ;
9995 bool temp1 = false ;
9996 PyObject * obj0 = 0 ;
9997 char *kwnames[] = {
9998 (char *) "msg", NULL
9999 };
10000
10001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10002 {
10003 arg1 = wxString_in_helper(obj0);
10004 if (arg1 == NULL) SWIG_fail;
10005 temp1 = true;
10006 }
10007 {
10008 PyThreadState* __tstate = wxPyBeginAllowThreads();
10009 wxPyLogDebug((wxString const &)*arg1);
10010
10011 wxPyEndAllowThreads(__tstate);
10012 if (PyErr_Occurred()) SWIG_fail;
10013 }
10014 Py_INCREF(Py_None); resultobj = Py_None;
10015 {
10016 if (temp1)
10017 delete arg1;
10018 }
10019 return resultobj;
10020 fail:
10021 {
10022 if (temp1)
10023 delete arg1;
10024 }
10025 return NULL;
10026 }
10027
10028
10029 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10030 PyObject *resultobj;
10031 wxString *arg1 = 0 ;
10032 bool temp1 = false ;
10033 PyObject * obj0 = 0 ;
10034 char *kwnames[] = {
10035 (char *) "msg", NULL
10036 };
10037
10038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10039 {
10040 arg1 = wxString_in_helper(obj0);
10041 if (arg1 == NULL) SWIG_fail;
10042 temp1 = true;
10043 }
10044 {
10045 PyThreadState* __tstate = wxPyBeginAllowThreads();
10046 wxPyLogVerbose((wxString const &)*arg1);
10047
10048 wxPyEndAllowThreads(__tstate);
10049 if (PyErr_Occurred()) SWIG_fail;
10050 }
10051 Py_INCREF(Py_None); resultobj = Py_None;
10052 {
10053 if (temp1)
10054 delete arg1;
10055 }
10056 return resultobj;
10057 fail:
10058 {
10059 if (temp1)
10060 delete arg1;
10061 }
10062 return NULL;
10063 }
10064
10065
10066 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10067 PyObject *resultobj;
10068 wxString *arg1 = 0 ;
10069 bool temp1 = false ;
10070 PyObject * obj0 = 0 ;
10071 char *kwnames[] = {
10072 (char *) "msg", NULL
10073 };
10074
10075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10076 {
10077 arg1 = wxString_in_helper(obj0);
10078 if (arg1 == NULL) SWIG_fail;
10079 temp1 = true;
10080 }
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 wxPyLogStatus((wxString const &)*arg1);
10084
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 Py_INCREF(Py_None); resultobj = Py_None;
10089 {
10090 if (temp1)
10091 delete arg1;
10092 }
10093 return resultobj;
10094 fail:
10095 {
10096 if (temp1)
10097 delete arg1;
10098 }
10099 return NULL;
10100 }
10101
10102
10103 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj;
10105 wxFrame *arg1 = (wxFrame *) 0 ;
10106 wxString *arg2 = 0 ;
10107 bool temp2 = false ;
10108 PyObject * obj0 = 0 ;
10109 PyObject * obj1 = 0 ;
10110 char *kwnames[] = {
10111 (char *) "pFrame",(char *) "msg", NULL
10112 };
10113
10114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10116 if (SWIG_arg_fail(1)) SWIG_fail;
10117 {
10118 arg2 = wxString_in_helper(obj1);
10119 if (arg2 == NULL) SWIG_fail;
10120 temp2 = true;
10121 }
10122 {
10123 PyThreadState* __tstate = wxPyBeginAllowThreads();
10124 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10125
10126 wxPyEndAllowThreads(__tstate);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 Py_INCREF(Py_None); resultobj = Py_None;
10130 {
10131 if (temp2)
10132 delete arg2;
10133 }
10134 return resultobj;
10135 fail:
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return NULL;
10141 }
10142
10143
10144 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10145 PyObject *resultobj;
10146 wxString *arg1 = 0 ;
10147 bool temp1 = false ;
10148 PyObject * obj0 = 0 ;
10149 char *kwnames[] = {
10150 (char *) "msg", NULL
10151 };
10152
10153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10154 {
10155 arg1 = wxString_in_helper(obj0);
10156 if (arg1 == NULL) SWIG_fail;
10157 temp1 = true;
10158 }
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 wxPyLogSysError((wxString const &)*arg1);
10162
10163 wxPyEndAllowThreads(__tstate);
10164 if (PyErr_Occurred()) SWIG_fail;
10165 }
10166 Py_INCREF(Py_None); resultobj = Py_None;
10167 {
10168 if (temp1)
10169 delete arg1;
10170 }
10171 return resultobj;
10172 fail:
10173 {
10174 if (temp1)
10175 delete arg1;
10176 }
10177 return NULL;
10178 }
10179
10180
10181 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10182 PyObject *resultobj;
10183 unsigned long arg1 ;
10184 wxString *arg2 = 0 ;
10185 bool temp2 = false ;
10186 PyObject * obj0 = 0 ;
10187 PyObject * obj1 = 0 ;
10188 char *kwnames[] = {
10189 (char *) "level",(char *) "msg", NULL
10190 };
10191
10192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10193 {
10194 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10195 if (SWIG_arg_fail(1)) SWIG_fail;
10196 }
10197 {
10198 arg2 = wxString_in_helper(obj1);
10199 if (arg2 == NULL) SWIG_fail;
10200 temp2 = true;
10201 }
10202 {
10203 PyThreadState* __tstate = wxPyBeginAllowThreads();
10204 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10205
10206 wxPyEndAllowThreads(__tstate);
10207 if (PyErr_Occurred()) SWIG_fail;
10208 }
10209 Py_INCREF(Py_None); resultobj = Py_None;
10210 {
10211 if (temp2)
10212 delete arg2;
10213 }
10214 return resultobj;
10215 fail:
10216 {
10217 if (temp2)
10218 delete arg2;
10219 }
10220 return NULL;
10221 }
10222
10223
10224 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10225 PyObject *resultobj;
10226 unsigned long arg1 ;
10227 wxString *arg2 = 0 ;
10228 bool temp2 = false ;
10229 PyObject * obj0 = 0 ;
10230 PyObject * obj1 = 0 ;
10231
10232 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10233 {
10234 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10235 if (SWIG_arg_fail(1)) SWIG_fail;
10236 }
10237 {
10238 arg2 = wxString_in_helper(obj1);
10239 if (arg2 == NULL) SWIG_fail;
10240 temp2 = true;
10241 }
10242 {
10243 PyThreadState* __tstate = wxPyBeginAllowThreads();
10244 wxPyLogTrace(arg1,(wxString const &)*arg2);
10245
10246 wxPyEndAllowThreads(__tstate);
10247 if (PyErr_Occurred()) SWIG_fail;
10248 }
10249 Py_INCREF(Py_None); resultobj = Py_None;
10250 {
10251 if (temp2)
10252 delete arg2;
10253 }
10254 return resultobj;
10255 fail:
10256 {
10257 if (temp2)
10258 delete arg2;
10259 }
10260 return NULL;
10261 }
10262
10263
10264 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10265 PyObject *resultobj;
10266 wxString *arg1 = 0 ;
10267 wxString *arg2 = 0 ;
10268 bool temp1 = false ;
10269 bool temp2 = false ;
10270 PyObject * obj0 = 0 ;
10271 PyObject * obj1 = 0 ;
10272
10273 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10274 {
10275 arg1 = wxString_in_helper(obj0);
10276 if (arg1 == NULL) SWIG_fail;
10277 temp1 = true;
10278 }
10279 {
10280 arg2 = wxString_in_helper(obj1);
10281 if (arg2 == NULL) SWIG_fail;
10282 temp2 = true;
10283 }
10284 {
10285 PyThreadState* __tstate = wxPyBeginAllowThreads();
10286 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10287
10288 wxPyEndAllowThreads(__tstate);
10289 if (PyErr_Occurred()) SWIG_fail;
10290 }
10291 Py_INCREF(Py_None); resultobj = Py_None;
10292 {
10293 if (temp1)
10294 delete arg1;
10295 }
10296 {
10297 if (temp2)
10298 delete arg2;
10299 }
10300 return resultobj;
10301 fail:
10302 {
10303 if (temp1)
10304 delete arg1;
10305 }
10306 {
10307 if (temp2)
10308 delete arg2;
10309 }
10310 return NULL;
10311 }
10312
10313
10314 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10315 int argc;
10316 PyObject *argv[3];
10317 int ii;
10318
10319 argc = PyObject_Length(args);
10320 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10321 argv[ii] = PyTuple_GetItem(args,ii);
10322 }
10323 if (argc == 2) {
10324 int _v;
10325 {
10326 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10327 }
10328 if (_v) {
10329 {
10330 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10331 }
10332 if (_v) {
10333 return _wrap_LogTrace__SWIG_1(self,args);
10334 }
10335 }
10336 }
10337 if (argc == 2) {
10338 int _v;
10339 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10340 if (_v) {
10341 {
10342 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10343 }
10344 if (_v) {
10345 return _wrap_LogTrace__SWIG_0(self,args);
10346 }
10347 }
10348 }
10349
10350 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10351 return NULL;
10352 }
10353
10354
10355 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10356 PyObject *resultobj;
10357 wxString *arg1 = 0 ;
10358 wxString *arg2 = 0 ;
10359 bool temp1 = false ;
10360 bool temp2 = false ;
10361 PyObject * obj0 = 0 ;
10362 PyObject * obj1 = 0 ;
10363 char *kwnames[] = {
10364 (char *) "title",(char *) "text", NULL
10365 };
10366
10367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10368 {
10369 arg1 = wxString_in_helper(obj0);
10370 if (arg1 == NULL) SWIG_fail;
10371 temp1 = true;
10372 }
10373 {
10374 arg2 = wxString_in_helper(obj1);
10375 if (arg2 == NULL) SWIG_fail;
10376 temp2 = true;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10381
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 Py_INCREF(Py_None); resultobj = Py_None;
10386 {
10387 if (temp1)
10388 delete arg1;
10389 }
10390 {
10391 if (temp2)
10392 delete arg2;
10393 }
10394 return resultobj;
10395 fail:
10396 {
10397 if (temp1)
10398 delete arg1;
10399 }
10400 {
10401 if (temp2)
10402 delete arg2;
10403 }
10404 return NULL;
10405 }
10406
10407
10408 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10409 PyObject *resultobj;
10410 wxLogNull *result;
10411 char *kwnames[] = {
10412 NULL
10413 };
10414
10415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10416 {
10417 PyThreadState* __tstate = wxPyBeginAllowThreads();
10418 result = (wxLogNull *)new wxLogNull();
10419
10420 wxPyEndAllowThreads(__tstate);
10421 if (PyErr_Occurred()) SWIG_fail;
10422 }
10423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10424 return resultobj;
10425 fail:
10426 return NULL;
10427 }
10428
10429
10430 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10431 PyObject *resultobj;
10432 wxLogNull *arg1 = (wxLogNull *) 0 ;
10433 PyObject * obj0 = 0 ;
10434 char *kwnames[] = {
10435 (char *) "self", NULL
10436 };
10437
10438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10440 if (SWIG_arg_fail(1)) SWIG_fail;
10441 {
10442 PyThreadState* __tstate = wxPyBeginAllowThreads();
10443 delete arg1;
10444
10445 wxPyEndAllowThreads(__tstate);
10446 if (PyErr_Occurred()) SWIG_fail;
10447 }
10448 Py_INCREF(Py_None); resultobj = Py_None;
10449 return resultobj;
10450 fail:
10451 return NULL;
10452 }
10453
10454
10455 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10456 PyObject *obj;
10457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10458 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10459 Py_INCREF(obj);
10460 return Py_BuildValue((char *)"");
10461 }
10462 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10463 PyObject *resultobj;
10464 wxPyLog *result;
10465 char *kwnames[] = {
10466 NULL
10467 };
10468
10469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10470 {
10471 PyThreadState* __tstate = wxPyBeginAllowThreads();
10472 result = (wxPyLog *)new wxPyLog();
10473
10474 wxPyEndAllowThreads(__tstate);
10475 if (PyErr_Occurred()) SWIG_fail;
10476 }
10477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10478 return resultobj;
10479 fail:
10480 return NULL;
10481 }
10482
10483
10484 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10485 PyObject *resultobj;
10486 wxPyLog *arg1 = (wxPyLog *) 0 ;
10487 PyObject *arg2 = (PyObject *) 0 ;
10488 PyObject *arg3 = (PyObject *) 0 ;
10489 PyObject * obj0 = 0 ;
10490 PyObject * obj1 = 0 ;
10491 PyObject * obj2 = 0 ;
10492 char *kwnames[] = {
10493 (char *) "self",(char *) "self",(char *) "_class", NULL
10494 };
10495
10496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10498 if (SWIG_arg_fail(1)) SWIG_fail;
10499 arg2 = obj1;
10500 arg3 = obj2;
10501 {
10502 PyThreadState* __tstate = wxPyBeginAllowThreads();
10503 (arg1)->_setCallbackInfo(arg2,arg3);
10504
10505 wxPyEndAllowThreads(__tstate);
10506 if (PyErr_Occurred()) SWIG_fail;
10507 }
10508 Py_INCREF(Py_None); resultobj = Py_None;
10509 return resultobj;
10510 fail:
10511 return NULL;
10512 }
10513
10514
10515 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10516 PyObject *obj;
10517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10518 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10519 Py_INCREF(obj);
10520 return Py_BuildValue((char *)"");
10521 }
10522 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10523 PyObject *resultobj;
10524 int arg1 ;
10525 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10526 int arg3 = (int) wxKILL_NOCHILDREN ;
10527 wxKillError result;
10528 PyObject * obj0 = 0 ;
10529 PyObject * obj1 = 0 ;
10530 PyObject * obj2 = 0 ;
10531 char *kwnames[] = {
10532 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10533 };
10534
10535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10536 {
10537 arg1 = (int)(SWIG_As_int(obj0));
10538 if (SWIG_arg_fail(1)) SWIG_fail;
10539 }
10540 if (obj1) {
10541 {
10542 arg2 = (wxSignal)(SWIG_As_int(obj1));
10543 if (SWIG_arg_fail(2)) SWIG_fail;
10544 }
10545 }
10546 if (obj2) {
10547 {
10548 arg3 = (int)(SWIG_As_int(obj2));
10549 if (SWIG_arg_fail(3)) SWIG_fail;
10550 }
10551 }
10552 {
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10555
10556 wxPyEndAllowThreads(__tstate);
10557 if (PyErr_Occurred()) SWIG_fail;
10558 }
10559 resultobj = SWIG_From_int((result));
10560 return resultobj;
10561 fail:
10562 return NULL;
10563 }
10564
10565
10566 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10567 PyObject *resultobj;
10568 int arg1 ;
10569 bool result;
10570 PyObject * obj0 = 0 ;
10571 char *kwnames[] = {
10572 (char *) "pid", NULL
10573 };
10574
10575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10576 {
10577 arg1 = (int)(SWIG_As_int(obj0));
10578 if (SWIG_arg_fail(1)) SWIG_fail;
10579 }
10580 {
10581 PyThreadState* __tstate = wxPyBeginAllowThreads();
10582 result = (bool)wxPyProcess::Exists(arg1);
10583
10584 wxPyEndAllowThreads(__tstate);
10585 if (PyErr_Occurred()) SWIG_fail;
10586 }
10587 {
10588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10589 }
10590 return resultobj;
10591 fail:
10592 return NULL;
10593 }
10594
10595
10596 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10597 PyObject *resultobj;
10598 wxString *arg1 = 0 ;
10599 int arg2 = (int) wxEXEC_ASYNC ;
10600 wxPyProcess *result;
10601 bool temp1 = false ;
10602 PyObject * obj0 = 0 ;
10603 PyObject * obj1 = 0 ;
10604 char *kwnames[] = {
10605 (char *) "cmd",(char *) "flags", NULL
10606 };
10607
10608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10609 {
10610 arg1 = wxString_in_helper(obj0);
10611 if (arg1 == NULL) SWIG_fail;
10612 temp1 = true;
10613 }
10614 if (obj1) {
10615 {
10616 arg2 = (int)(SWIG_As_int(obj1));
10617 if (SWIG_arg_fail(2)) SWIG_fail;
10618 }
10619 }
10620 {
10621 PyThreadState* __tstate = wxPyBeginAllowThreads();
10622 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10623
10624 wxPyEndAllowThreads(__tstate);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10628 {
10629 if (temp1)
10630 delete arg1;
10631 }
10632 return resultobj;
10633 fail:
10634 {
10635 if (temp1)
10636 delete arg1;
10637 }
10638 return NULL;
10639 }
10640
10641
10642 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10643 PyObject *resultobj;
10644 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10645 int arg2 = (int) -1 ;
10646 wxPyProcess *result;
10647 PyObject * obj0 = 0 ;
10648 PyObject * obj1 = 0 ;
10649 char *kwnames[] = {
10650 (char *) "parent",(char *) "id", NULL
10651 };
10652
10653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10654 if (obj0) {
10655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10656 if (SWIG_arg_fail(1)) SWIG_fail;
10657 }
10658 if (obj1) {
10659 {
10660 arg2 = (int)(SWIG_As_int(obj1));
10661 if (SWIG_arg_fail(2)) SWIG_fail;
10662 }
10663 }
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10667
10668 wxPyEndAllowThreads(__tstate);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10679 PyObject *resultobj;
10680 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10681 PyObject *arg2 = (PyObject *) 0 ;
10682 PyObject *arg3 = (PyObject *) 0 ;
10683 PyObject * obj0 = 0 ;
10684 PyObject * obj1 = 0 ;
10685 PyObject * obj2 = 0 ;
10686 char *kwnames[] = {
10687 (char *) "self",(char *) "self",(char *) "_class", NULL
10688 };
10689
10690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10692 if (SWIG_arg_fail(1)) SWIG_fail;
10693 arg2 = obj1;
10694 arg3 = obj2;
10695 {
10696 PyThreadState* __tstate = wxPyBeginAllowThreads();
10697 (arg1)->_setCallbackInfo(arg2,arg3);
10698
10699 wxPyEndAllowThreads(__tstate);
10700 if (PyErr_Occurred()) SWIG_fail;
10701 }
10702 Py_INCREF(Py_None); resultobj = Py_None;
10703 return resultobj;
10704 fail:
10705 return NULL;
10706 }
10707
10708
10709 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10710 PyObject *resultobj;
10711 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10712 int arg2 ;
10713 int arg3 ;
10714 PyObject * obj0 = 0 ;
10715 PyObject * obj1 = 0 ;
10716 PyObject * obj2 = 0 ;
10717 char *kwnames[] = {
10718 (char *) "self",(char *) "pid",(char *) "status", NULL
10719 };
10720
10721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10723 if (SWIG_arg_fail(1)) SWIG_fail;
10724 {
10725 arg2 = (int)(SWIG_As_int(obj1));
10726 if (SWIG_arg_fail(2)) SWIG_fail;
10727 }
10728 {
10729 arg3 = (int)(SWIG_As_int(obj2));
10730 if (SWIG_arg_fail(3)) SWIG_fail;
10731 }
10732 {
10733 PyThreadState* __tstate = wxPyBeginAllowThreads();
10734 (arg1)->base_OnTerminate(arg2,arg3);
10735
10736 wxPyEndAllowThreads(__tstate);
10737 if (PyErr_Occurred()) SWIG_fail;
10738 }
10739 Py_INCREF(Py_None); resultobj = Py_None;
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10747 PyObject *resultobj;
10748 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10749 PyObject * obj0 = 0 ;
10750 char *kwnames[] = {
10751 (char *) "self", NULL
10752 };
10753
10754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10756 if (SWIG_arg_fail(1)) SWIG_fail;
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 (arg1)->Redirect();
10760
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 Py_INCREF(Py_None); resultobj = Py_None;
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10772 PyObject *resultobj;
10773 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10774 bool result;
10775 PyObject * obj0 = 0 ;
10776 char *kwnames[] = {
10777 (char *) "self", NULL
10778 };
10779
10780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10782 if (SWIG_arg_fail(1)) SWIG_fail;
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = (bool)(arg1)->IsRedirected();
10786
10787 wxPyEndAllowThreads(__tstate);
10788 if (PyErr_Occurred()) SWIG_fail;
10789 }
10790 {
10791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10792 }
10793 return resultobj;
10794 fail:
10795 return NULL;
10796 }
10797
10798
10799 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10800 PyObject *resultobj;
10801 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10802 PyObject * obj0 = 0 ;
10803 char *kwnames[] = {
10804 (char *) "self", NULL
10805 };
10806
10807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10809 if (SWIG_arg_fail(1)) SWIG_fail;
10810 {
10811 PyThreadState* __tstate = wxPyBeginAllowThreads();
10812 (arg1)->Detach();
10813
10814 wxPyEndAllowThreads(__tstate);
10815 if (PyErr_Occurred()) SWIG_fail;
10816 }
10817 Py_INCREF(Py_None); resultobj = Py_None;
10818 return resultobj;
10819 fail:
10820 return NULL;
10821 }
10822
10823
10824 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10825 PyObject *resultobj;
10826 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10827 wxInputStream *result;
10828 PyObject * obj0 = 0 ;
10829 char *kwnames[] = {
10830 (char *) "self", NULL
10831 };
10832
10833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10835 if (SWIG_arg_fail(1)) SWIG_fail;
10836 {
10837 PyThreadState* __tstate = wxPyBeginAllowThreads();
10838 result = (wxInputStream *)(arg1)->GetInputStream();
10839
10840 wxPyEndAllowThreads(__tstate);
10841 if (PyErr_Occurred()) SWIG_fail;
10842 }
10843 {
10844 wxPyInputStream * _ptr = NULL;
10845
10846 if (result) {
10847 _ptr = new wxPyInputStream(result);
10848 }
10849 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10850 }
10851 return resultobj;
10852 fail:
10853 return NULL;
10854 }
10855
10856
10857 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj;
10859 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10860 wxInputStream *result;
10861 PyObject * obj0 = 0 ;
10862 char *kwnames[] = {
10863 (char *) "self", NULL
10864 };
10865
10866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10868 if (SWIG_arg_fail(1)) SWIG_fail;
10869 {
10870 PyThreadState* __tstate = wxPyBeginAllowThreads();
10871 result = (wxInputStream *)(arg1)->GetErrorStream();
10872
10873 wxPyEndAllowThreads(__tstate);
10874 if (PyErr_Occurred()) SWIG_fail;
10875 }
10876 {
10877 wxPyInputStream * _ptr = NULL;
10878
10879 if (result) {
10880 _ptr = new wxPyInputStream(result);
10881 }
10882 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10883 }
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj;
10892 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10893 wxOutputStream *result;
10894 PyObject * obj0 = 0 ;
10895 char *kwnames[] = {
10896 (char *) "self", NULL
10897 };
10898
10899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10901 if (SWIG_arg_fail(1)) SWIG_fail;
10902 {
10903 PyThreadState* __tstate = wxPyBeginAllowThreads();
10904 result = (wxOutputStream *)(arg1)->GetOutputStream();
10905
10906 wxPyEndAllowThreads(__tstate);
10907 if (PyErr_Occurred()) SWIG_fail;
10908 }
10909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10917 PyObject *resultobj;
10918 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10919 PyObject * obj0 = 0 ;
10920 char *kwnames[] = {
10921 (char *) "self", NULL
10922 };
10923
10924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10926 if (SWIG_arg_fail(1)) SWIG_fail;
10927 {
10928 PyThreadState* __tstate = wxPyBeginAllowThreads();
10929 (arg1)->CloseOutput();
10930
10931 wxPyEndAllowThreads(__tstate);
10932 if (PyErr_Occurred()) SWIG_fail;
10933 }
10934 Py_INCREF(Py_None); resultobj = Py_None;
10935 return resultobj;
10936 fail:
10937 return NULL;
10938 }
10939
10940
10941 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10942 PyObject *resultobj;
10943 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10944 bool result;
10945 PyObject * obj0 = 0 ;
10946 char *kwnames[] = {
10947 (char *) "self", NULL
10948 };
10949
10950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10952 if (SWIG_arg_fail(1)) SWIG_fail;
10953 {
10954 PyThreadState* __tstate = wxPyBeginAllowThreads();
10955 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
10956
10957 wxPyEndAllowThreads(__tstate);
10958 if (PyErr_Occurred()) SWIG_fail;
10959 }
10960 {
10961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10962 }
10963 return resultobj;
10964 fail:
10965 return NULL;
10966 }
10967
10968
10969 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj;
10971 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10972 bool result;
10973 PyObject * obj0 = 0 ;
10974 char *kwnames[] = {
10975 (char *) "self", NULL
10976 };
10977
10978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
10979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10980 if (SWIG_arg_fail(1)) SWIG_fail;
10981 {
10982 PyThreadState* __tstate = wxPyBeginAllowThreads();
10983 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
10984
10985 wxPyEndAllowThreads(__tstate);
10986 if (PyErr_Occurred()) SWIG_fail;
10987 }
10988 {
10989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10990 }
10991 return resultobj;
10992 fail:
10993 return NULL;
10994 }
10995
10996
10997 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10998 PyObject *resultobj;
10999 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11000 bool result;
11001 PyObject * obj0 = 0 ;
11002 char *kwnames[] = {
11003 (char *) "self", NULL
11004 };
11005
11006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11008 if (SWIG_arg_fail(1)) SWIG_fail;
11009 {
11010 PyThreadState* __tstate = wxPyBeginAllowThreads();
11011 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11012
11013 wxPyEndAllowThreads(__tstate);
11014 if (PyErr_Occurred()) SWIG_fail;
11015 }
11016 {
11017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11018 }
11019 return resultobj;
11020 fail:
11021 return NULL;
11022 }
11023
11024
11025 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11026 PyObject *obj;
11027 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11028 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11029 Py_INCREF(obj);
11030 return Py_BuildValue((char *)"");
11031 }
11032 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj;
11034 int arg1 = (int) 0 ;
11035 int arg2 = (int) 0 ;
11036 int arg3 = (int) 0 ;
11037 wxProcessEvent *result;
11038 PyObject * obj0 = 0 ;
11039 PyObject * obj1 = 0 ;
11040 PyObject * obj2 = 0 ;
11041 char *kwnames[] = {
11042 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11043 };
11044
11045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11046 if (obj0) {
11047 {
11048 arg1 = (int)(SWIG_As_int(obj0));
11049 if (SWIG_arg_fail(1)) SWIG_fail;
11050 }
11051 }
11052 if (obj1) {
11053 {
11054 arg2 = (int)(SWIG_As_int(obj1));
11055 if (SWIG_arg_fail(2)) SWIG_fail;
11056 }
11057 }
11058 if (obj2) {
11059 {
11060 arg3 = (int)(SWIG_As_int(obj2));
11061 if (SWIG_arg_fail(3)) SWIG_fail;
11062 }
11063 }
11064 {
11065 PyThreadState* __tstate = wxPyBeginAllowThreads();
11066 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11067
11068 wxPyEndAllowThreads(__tstate);
11069 if (PyErr_Occurred()) SWIG_fail;
11070 }
11071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11072 return resultobj;
11073 fail:
11074 return NULL;
11075 }
11076
11077
11078 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11079 PyObject *resultobj;
11080 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11081 int result;
11082 PyObject * obj0 = 0 ;
11083 char *kwnames[] = {
11084 (char *) "self", NULL
11085 };
11086
11087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11089 if (SWIG_arg_fail(1)) SWIG_fail;
11090 {
11091 PyThreadState* __tstate = wxPyBeginAllowThreads();
11092 result = (int)(arg1)->GetPid();
11093
11094 wxPyEndAllowThreads(__tstate);
11095 if (PyErr_Occurred()) SWIG_fail;
11096 }
11097 {
11098 resultobj = SWIG_From_int((int)(result));
11099 }
11100 return resultobj;
11101 fail:
11102 return NULL;
11103 }
11104
11105
11106 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11107 PyObject *resultobj;
11108 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11109 int result;
11110 PyObject * obj0 = 0 ;
11111 char *kwnames[] = {
11112 (char *) "self", NULL
11113 };
11114
11115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11117 if (SWIG_arg_fail(1)) SWIG_fail;
11118 {
11119 PyThreadState* __tstate = wxPyBeginAllowThreads();
11120 result = (int)(arg1)->GetExitCode();
11121
11122 wxPyEndAllowThreads(__tstate);
11123 if (PyErr_Occurred()) SWIG_fail;
11124 }
11125 {
11126 resultobj = SWIG_From_int((int)(result));
11127 }
11128 return resultobj;
11129 fail:
11130 return NULL;
11131 }
11132
11133
11134 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11135 PyObject *resultobj;
11136 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11137 int arg2 ;
11138 PyObject * obj0 = 0 ;
11139 PyObject * obj1 = 0 ;
11140 char *kwnames[] = {
11141 (char *) "self",(char *) "m_pid", NULL
11142 };
11143
11144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11146 if (SWIG_arg_fail(1)) SWIG_fail;
11147 {
11148 arg2 = (int)(SWIG_As_int(obj1));
11149 if (SWIG_arg_fail(2)) SWIG_fail;
11150 }
11151 if (arg1) (arg1)->m_pid = arg2;
11152
11153 Py_INCREF(Py_None); resultobj = Py_None;
11154 return resultobj;
11155 fail:
11156 return NULL;
11157 }
11158
11159
11160 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11161 PyObject *resultobj;
11162 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11163 int result;
11164 PyObject * obj0 = 0 ;
11165 char *kwnames[] = {
11166 (char *) "self", NULL
11167 };
11168
11169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11171 if (SWIG_arg_fail(1)) SWIG_fail;
11172 result = (int) ((arg1)->m_pid);
11173
11174 {
11175 resultobj = SWIG_From_int((int)(result));
11176 }
11177 return resultobj;
11178 fail:
11179 return NULL;
11180 }
11181
11182
11183 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11184 PyObject *resultobj;
11185 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11186 int arg2 ;
11187 PyObject * obj0 = 0 ;
11188 PyObject * obj1 = 0 ;
11189 char *kwnames[] = {
11190 (char *) "self",(char *) "m_exitcode", NULL
11191 };
11192
11193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11195 if (SWIG_arg_fail(1)) SWIG_fail;
11196 {
11197 arg2 = (int)(SWIG_As_int(obj1));
11198 if (SWIG_arg_fail(2)) SWIG_fail;
11199 }
11200 if (arg1) (arg1)->m_exitcode = arg2;
11201
11202 Py_INCREF(Py_None); resultobj = Py_None;
11203 return resultobj;
11204 fail:
11205 return NULL;
11206 }
11207
11208
11209 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11210 PyObject *resultobj;
11211 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11212 int result;
11213 PyObject * obj0 = 0 ;
11214 char *kwnames[] = {
11215 (char *) "self", NULL
11216 };
11217
11218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11220 if (SWIG_arg_fail(1)) SWIG_fail;
11221 result = (int) ((arg1)->m_exitcode);
11222
11223 {
11224 resultobj = SWIG_From_int((int)(result));
11225 }
11226 return resultobj;
11227 fail:
11228 return NULL;
11229 }
11230
11231
11232 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11233 PyObject *obj;
11234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11235 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11236 Py_INCREF(obj);
11237 return Py_BuildValue((char *)"");
11238 }
11239 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11240 PyObject *resultobj;
11241 wxString *arg1 = 0 ;
11242 int arg2 = (int) wxEXEC_ASYNC ;
11243 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11244 long result;
11245 bool temp1 = false ;
11246 PyObject * obj0 = 0 ;
11247 PyObject * obj1 = 0 ;
11248 PyObject * obj2 = 0 ;
11249 char *kwnames[] = {
11250 (char *) "command",(char *) "flags",(char *) "process", NULL
11251 };
11252
11253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11254 {
11255 arg1 = wxString_in_helper(obj0);
11256 if (arg1 == NULL) SWIG_fail;
11257 temp1 = true;
11258 }
11259 if (obj1) {
11260 {
11261 arg2 = (int)(SWIG_As_int(obj1));
11262 if (SWIG_arg_fail(2)) SWIG_fail;
11263 }
11264 }
11265 if (obj2) {
11266 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11267 if (SWIG_arg_fail(3)) SWIG_fail;
11268 }
11269 {
11270 if (!wxPyCheckForApp()) SWIG_fail;
11271 PyThreadState* __tstate = wxPyBeginAllowThreads();
11272 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11273
11274 wxPyEndAllowThreads(__tstate);
11275 if (PyErr_Occurred()) SWIG_fail;
11276 }
11277 {
11278 resultobj = SWIG_From_long((long)(result));
11279 }
11280 {
11281 if (temp1)
11282 delete arg1;
11283 }
11284 return resultobj;
11285 fail:
11286 {
11287 if (temp1)
11288 delete arg1;
11289 }
11290 return NULL;
11291 }
11292
11293
11294 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11295 PyObject *resultobj;
11296 long arg1 ;
11297 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11298 wxKillError *arg3 = (wxKillError *) 0 ;
11299 int arg4 = (int) wxKILL_NOCHILDREN ;
11300 int result;
11301 wxKillError temp3 ;
11302 PyObject * obj0 = 0 ;
11303 PyObject * obj1 = 0 ;
11304 PyObject * obj2 = 0 ;
11305 char *kwnames[] = {
11306 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11307 };
11308
11309 {
11310 arg3 = &temp3;
11311 }
11312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11313 {
11314 arg1 = (long)(SWIG_As_long(obj0));
11315 if (SWIG_arg_fail(1)) SWIG_fail;
11316 }
11317 if (obj1) {
11318 {
11319 arg2 = (wxSignal)(SWIG_As_int(obj1));
11320 if (SWIG_arg_fail(2)) SWIG_fail;
11321 }
11322 }
11323 if (obj2) {
11324 {
11325 arg4 = (int)(SWIG_As_int(obj2));
11326 if (SWIG_arg_fail(4)) SWIG_fail;
11327 }
11328 }
11329 {
11330 PyThreadState* __tstate = wxPyBeginAllowThreads();
11331 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11332
11333 wxPyEndAllowThreads(__tstate);
11334 if (PyErr_Occurred()) SWIG_fail;
11335 }
11336 {
11337 resultobj = SWIG_From_int((int)(result));
11338 }
11339 {
11340 PyObject* o;
11341 o = PyInt_FromLong((long) (*arg3));
11342 resultobj = t_output_helper(resultobj, o);
11343 }
11344 return resultobj;
11345 fail:
11346 return NULL;
11347 }
11348
11349
11350 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11351 PyObject *resultobj;
11352 int arg1 = (int) wxJOYSTICK1 ;
11353 wxJoystick *result;
11354 PyObject * obj0 = 0 ;
11355 char *kwnames[] = {
11356 (char *) "joystick", NULL
11357 };
11358
11359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11360 if (obj0) {
11361 {
11362 arg1 = (int)(SWIG_As_int(obj0));
11363 if (SWIG_arg_fail(1)) SWIG_fail;
11364 }
11365 }
11366 {
11367 if (!wxPyCheckForApp()) SWIG_fail;
11368 PyThreadState* __tstate = wxPyBeginAllowThreads();
11369 result = (wxJoystick *)new wxJoystick(arg1);
11370
11371 wxPyEndAllowThreads(__tstate);
11372 if (PyErr_Occurred()) SWIG_fail;
11373 }
11374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11375 return resultobj;
11376 fail:
11377 return NULL;
11378 }
11379
11380
11381 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11382 PyObject *resultobj;
11383 wxJoystick *arg1 = (wxJoystick *) 0 ;
11384 PyObject * obj0 = 0 ;
11385 char *kwnames[] = {
11386 (char *) "self", NULL
11387 };
11388
11389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11391 if (SWIG_arg_fail(1)) SWIG_fail;
11392 {
11393 PyThreadState* __tstate = wxPyBeginAllowThreads();
11394 delete arg1;
11395
11396 wxPyEndAllowThreads(__tstate);
11397 if (PyErr_Occurred()) SWIG_fail;
11398 }
11399 Py_INCREF(Py_None); resultobj = Py_None;
11400 return resultobj;
11401 fail:
11402 return NULL;
11403 }
11404
11405
11406 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11407 PyObject *resultobj;
11408 wxJoystick *arg1 = (wxJoystick *) 0 ;
11409 wxPoint result;
11410 PyObject * obj0 = 0 ;
11411 char *kwnames[] = {
11412 (char *) "self", NULL
11413 };
11414
11415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11417 if (SWIG_arg_fail(1)) SWIG_fail;
11418 {
11419 PyThreadState* __tstate = wxPyBeginAllowThreads();
11420 result = (arg1)->GetPosition();
11421
11422 wxPyEndAllowThreads(__tstate);
11423 if (PyErr_Occurred()) SWIG_fail;
11424 }
11425 {
11426 wxPoint * resultptr;
11427 resultptr = new wxPoint((wxPoint &)(result));
11428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11429 }
11430 return resultobj;
11431 fail:
11432 return NULL;
11433 }
11434
11435
11436 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11437 PyObject *resultobj;
11438 wxJoystick *arg1 = (wxJoystick *) 0 ;
11439 int result;
11440 PyObject * obj0 = 0 ;
11441 char *kwnames[] = {
11442 (char *) "self", NULL
11443 };
11444
11445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11447 if (SWIG_arg_fail(1)) SWIG_fail;
11448 {
11449 PyThreadState* __tstate = wxPyBeginAllowThreads();
11450 result = (int)(arg1)->GetZPosition();
11451
11452 wxPyEndAllowThreads(__tstate);
11453 if (PyErr_Occurred()) SWIG_fail;
11454 }
11455 {
11456 resultobj = SWIG_From_int((int)(result));
11457 }
11458 return resultobj;
11459 fail:
11460 return NULL;
11461 }
11462
11463
11464 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11465 PyObject *resultobj;
11466 wxJoystick *arg1 = (wxJoystick *) 0 ;
11467 int result;
11468 PyObject * obj0 = 0 ;
11469 char *kwnames[] = {
11470 (char *) "self", NULL
11471 };
11472
11473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11475 if (SWIG_arg_fail(1)) SWIG_fail;
11476 {
11477 PyThreadState* __tstate = wxPyBeginAllowThreads();
11478 result = (int)(arg1)->GetButtonState();
11479
11480 wxPyEndAllowThreads(__tstate);
11481 if (PyErr_Occurred()) SWIG_fail;
11482 }
11483 {
11484 resultobj = SWIG_From_int((int)(result));
11485 }
11486 return resultobj;
11487 fail:
11488 return NULL;
11489 }
11490
11491
11492 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11493 PyObject *resultobj;
11494 wxJoystick *arg1 = (wxJoystick *) 0 ;
11495 int result;
11496 PyObject * obj0 = 0 ;
11497 char *kwnames[] = {
11498 (char *) "self", NULL
11499 };
11500
11501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11503 if (SWIG_arg_fail(1)) SWIG_fail;
11504 {
11505 PyThreadState* __tstate = wxPyBeginAllowThreads();
11506 result = (int)(arg1)->GetPOVPosition();
11507
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 {
11512 resultobj = SWIG_From_int((int)(result));
11513 }
11514 return resultobj;
11515 fail:
11516 return NULL;
11517 }
11518
11519
11520 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11521 PyObject *resultobj;
11522 wxJoystick *arg1 = (wxJoystick *) 0 ;
11523 int result;
11524 PyObject * obj0 = 0 ;
11525 char *kwnames[] = {
11526 (char *) "self", NULL
11527 };
11528
11529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11531 if (SWIG_arg_fail(1)) SWIG_fail;
11532 {
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 result = (int)(arg1)->GetPOVCTSPosition();
11535
11536 wxPyEndAllowThreads(__tstate);
11537 if (PyErr_Occurred()) SWIG_fail;
11538 }
11539 {
11540 resultobj = SWIG_From_int((int)(result));
11541 }
11542 return resultobj;
11543 fail:
11544 return NULL;
11545 }
11546
11547
11548 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11549 PyObject *resultobj;
11550 wxJoystick *arg1 = (wxJoystick *) 0 ;
11551 int result;
11552 PyObject * obj0 = 0 ;
11553 char *kwnames[] = {
11554 (char *) "self", NULL
11555 };
11556
11557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11559 if (SWIG_arg_fail(1)) SWIG_fail;
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 result = (int)(arg1)->GetRudderPosition();
11563
11564 wxPyEndAllowThreads(__tstate);
11565 if (PyErr_Occurred()) SWIG_fail;
11566 }
11567 {
11568 resultobj = SWIG_From_int((int)(result));
11569 }
11570 return resultobj;
11571 fail:
11572 return NULL;
11573 }
11574
11575
11576 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11577 PyObject *resultobj;
11578 wxJoystick *arg1 = (wxJoystick *) 0 ;
11579 int result;
11580 PyObject * obj0 = 0 ;
11581 char *kwnames[] = {
11582 (char *) "self", NULL
11583 };
11584
11585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11587 if (SWIG_arg_fail(1)) SWIG_fail;
11588 {
11589 PyThreadState* __tstate = wxPyBeginAllowThreads();
11590 result = (int)(arg1)->GetUPosition();
11591
11592 wxPyEndAllowThreads(__tstate);
11593 if (PyErr_Occurred()) SWIG_fail;
11594 }
11595 {
11596 resultobj = SWIG_From_int((int)(result));
11597 }
11598 return resultobj;
11599 fail:
11600 return NULL;
11601 }
11602
11603
11604 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11605 PyObject *resultobj;
11606 wxJoystick *arg1 = (wxJoystick *) 0 ;
11607 int result;
11608 PyObject * obj0 = 0 ;
11609 char *kwnames[] = {
11610 (char *) "self", NULL
11611 };
11612
11613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11615 if (SWIG_arg_fail(1)) SWIG_fail;
11616 {
11617 PyThreadState* __tstate = wxPyBeginAllowThreads();
11618 result = (int)(arg1)->GetVPosition();
11619
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 {
11624 resultobj = SWIG_From_int((int)(result));
11625 }
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11633 PyObject *resultobj;
11634 wxJoystick *arg1 = (wxJoystick *) 0 ;
11635 int result;
11636 PyObject * obj0 = 0 ;
11637 char *kwnames[] = {
11638 (char *) "self", NULL
11639 };
11640
11641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11643 if (SWIG_arg_fail(1)) SWIG_fail;
11644 {
11645 PyThreadState* __tstate = wxPyBeginAllowThreads();
11646 result = (int)(arg1)->GetMovementThreshold();
11647
11648 wxPyEndAllowThreads(__tstate);
11649 if (PyErr_Occurred()) SWIG_fail;
11650 }
11651 {
11652 resultobj = SWIG_From_int((int)(result));
11653 }
11654 return resultobj;
11655 fail:
11656 return NULL;
11657 }
11658
11659
11660 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11661 PyObject *resultobj;
11662 wxJoystick *arg1 = (wxJoystick *) 0 ;
11663 int arg2 ;
11664 PyObject * obj0 = 0 ;
11665 PyObject * obj1 = 0 ;
11666 char *kwnames[] = {
11667 (char *) "self",(char *) "threshold", NULL
11668 };
11669
11670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11672 if (SWIG_arg_fail(1)) SWIG_fail;
11673 {
11674 arg2 = (int)(SWIG_As_int(obj1));
11675 if (SWIG_arg_fail(2)) SWIG_fail;
11676 }
11677 {
11678 PyThreadState* __tstate = wxPyBeginAllowThreads();
11679 (arg1)->SetMovementThreshold(arg2);
11680
11681 wxPyEndAllowThreads(__tstate);
11682 if (PyErr_Occurred()) SWIG_fail;
11683 }
11684 Py_INCREF(Py_None); resultobj = Py_None;
11685 return resultobj;
11686 fail:
11687 return NULL;
11688 }
11689
11690
11691 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11692 PyObject *resultobj;
11693 wxJoystick *arg1 = (wxJoystick *) 0 ;
11694 bool result;
11695 PyObject * obj0 = 0 ;
11696 char *kwnames[] = {
11697 (char *) "self", NULL
11698 };
11699
11700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11702 if (SWIG_arg_fail(1)) SWIG_fail;
11703 {
11704 PyThreadState* __tstate = wxPyBeginAllowThreads();
11705 result = (bool)(arg1)->IsOk();
11706
11707 wxPyEndAllowThreads(__tstate);
11708 if (PyErr_Occurred()) SWIG_fail;
11709 }
11710 {
11711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11712 }
11713 return resultobj;
11714 fail:
11715 return NULL;
11716 }
11717
11718
11719 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11720 PyObject *resultobj;
11721 wxJoystick *arg1 = (wxJoystick *) 0 ;
11722 int result;
11723 PyObject * obj0 = 0 ;
11724 char *kwnames[] = {
11725 (char *) "self", NULL
11726 };
11727
11728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11730 if (SWIG_arg_fail(1)) SWIG_fail;
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 result = (int)(arg1)->GetNumberJoysticks();
11734
11735 wxPyEndAllowThreads(__tstate);
11736 if (PyErr_Occurred()) SWIG_fail;
11737 }
11738 {
11739 resultobj = SWIG_From_int((int)(result));
11740 }
11741 return resultobj;
11742 fail:
11743 return NULL;
11744 }
11745
11746
11747 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11748 PyObject *resultobj;
11749 wxJoystick *arg1 = (wxJoystick *) 0 ;
11750 int result;
11751 PyObject * obj0 = 0 ;
11752 char *kwnames[] = {
11753 (char *) "self", NULL
11754 };
11755
11756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11758 if (SWIG_arg_fail(1)) SWIG_fail;
11759 {
11760 PyThreadState* __tstate = wxPyBeginAllowThreads();
11761 result = (int)(arg1)->GetManufacturerId();
11762
11763 wxPyEndAllowThreads(__tstate);
11764 if (PyErr_Occurred()) SWIG_fail;
11765 }
11766 {
11767 resultobj = SWIG_From_int((int)(result));
11768 }
11769 return resultobj;
11770 fail:
11771 return NULL;
11772 }
11773
11774
11775 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11776 PyObject *resultobj;
11777 wxJoystick *arg1 = (wxJoystick *) 0 ;
11778 int result;
11779 PyObject * obj0 = 0 ;
11780 char *kwnames[] = {
11781 (char *) "self", NULL
11782 };
11783
11784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11786 if (SWIG_arg_fail(1)) SWIG_fail;
11787 {
11788 PyThreadState* __tstate = wxPyBeginAllowThreads();
11789 result = (int)(arg1)->GetProductId();
11790
11791 wxPyEndAllowThreads(__tstate);
11792 if (PyErr_Occurred()) SWIG_fail;
11793 }
11794 {
11795 resultobj = SWIG_From_int((int)(result));
11796 }
11797 return resultobj;
11798 fail:
11799 return NULL;
11800 }
11801
11802
11803 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11804 PyObject *resultobj;
11805 wxJoystick *arg1 = (wxJoystick *) 0 ;
11806 wxString result;
11807 PyObject * obj0 = 0 ;
11808 char *kwnames[] = {
11809 (char *) "self", NULL
11810 };
11811
11812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11814 if (SWIG_arg_fail(1)) SWIG_fail;
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 result = (arg1)->GetProductName();
11818
11819 wxPyEndAllowThreads(__tstate);
11820 if (PyErr_Occurred()) SWIG_fail;
11821 }
11822 {
11823 #if wxUSE_UNICODE
11824 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11825 #else
11826 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11827 #endif
11828 }
11829 return resultobj;
11830 fail:
11831 return NULL;
11832 }
11833
11834
11835 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11836 PyObject *resultobj;
11837 wxJoystick *arg1 = (wxJoystick *) 0 ;
11838 int result;
11839 PyObject * obj0 = 0 ;
11840 char *kwnames[] = {
11841 (char *) "self", NULL
11842 };
11843
11844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11846 if (SWIG_arg_fail(1)) SWIG_fail;
11847 {
11848 PyThreadState* __tstate = wxPyBeginAllowThreads();
11849 result = (int)(arg1)->GetXMin();
11850
11851 wxPyEndAllowThreads(__tstate);
11852 if (PyErr_Occurred()) SWIG_fail;
11853 }
11854 {
11855 resultobj = SWIG_From_int((int)(result));
11856 }
11857 return resultobj;
11858 fail:
11859 return NULL;
11860 }
11861
11862
11863 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11864 PyObject *resultobj;
11865 wxJoystick *arg1 = (wxJoystick *) 0 ;
11866 int result;
11867 PyObject * obj0 = 0 ;
11868 char *kwnames[] = {
11869 (char *) "self", NULL
11870 };
11871
11872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11874 if (SWIG_arg_fail(1)) SWIG_fail;
11875 {
11876 PyThreadState* __tstate = wxPyBeginAllowThreads();
11877 result = (int)(arg1)->GetYMin();
11878
11879 wxPyEndAllowThreads(__tstate);
11880 if (PyErr_Occurred()) SWIG_fail;
11881 }
11882 {
11883 resultobj = SWIG_From_int((int)(result));
11884 }
11885 return resultobj;
11886 fail:
11887 return NULL;
11888 }
11889
11890
11891 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11892 PyObject *resultobj;
11893 wxJoystick *arg1 = (wxJoystick *) 0 ;
11894 int result;
11895 PyObject * obj0 = 0 ;
11896 char *kwnames[] = {
11897 (char *) "self", NULL
11898 };
11899
11900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11902 if (SWIG_arg_fail(1)) SWIG_fail;
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (int)(arg1)->GetZMin();
11906
11907 wxPyEndAllowThreads(__tstate);
11908 if (PyErr_Occurred()) SWIG_fail;
11909 }
11910 {
11911 resultobj = SWIG_From_int((int)(result));
11912 }
11913 return resultobj;
11914 fail:
11915 return NULL;
11916 }
11917
11918
11919 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11920 PyObject *resultobj;
11921 wxJoystick *arg1 = (wxJoystick *) 0 ;
11922 int result;
11923 PyObject * obj0 = 0 ;
11924 char *kwnames[] = {
11925 (char *) "self", NULL
11926 };
11927
11928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
11929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11930 if (SWIG_arg_fail(1)) SWIG_fail;
11931 {
11932 PyThreadState* __tstate = wxPyBeginAllowThreads();
11933 result = (int)(arg1)->GetXMax();
11934
11935 wxPyEndAllowThreads(__tstate);
11936 if (PyErr_Occurred()) SWIG_fail;
11937 }
11938 {
11939 resultobj = SWIG_From_int((int)(result));
11940 }
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj;
11949 wxJoystick *arg1 = (wxJoystick *) 0 ;
11950 int result;
11951 PyObject * obj0 = 0 ;
11952 char *kwnames[] = {
11953 (char *) "self", NULL
11954 };
11955
11956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11958 if (SWIG_arg_fail(1)) SWIG_fail;
11959 {
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 result = (int)(arg1)->GetYMax();
11962
11963 wxPyEndAllowThreads(__tstate);
11964 if (PyErr_Occurred()) SWIG_fail;
11965 }
11966 {
11967 resultobj = SWIG_From_int((int)(result));
11968 }
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
11976 PyObject *resultobj;
11977 wxJoystick *arg1 = (wxJoystick *) 0 ;
11978 int result;
11979 PyObject * obj0 = 0 ;
11980 char *kwnames[] = {
11981 (char *) "self", NULL
11982 };
11983
11984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
11985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11986 if (SWIG_arg_fail(1)) SWIG_fail;
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (int)(arg1)->GetZMax();
11990
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 {
11995 resultobj = SWIG_From_int((int)(result));
11996 }
11997 return resultobj;
11998 fail:
11999 return NULL;
12000 }
12001
12002
12003 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj;
12005 wxJoystick *arg1 = (wxJoystick *) 0 ;
12006 int result;
12007 PyObject * obj0 = 0 ;
12008 char *kwnames[] = {
12009 (char *) "self", NULL
12010 };
12011
12012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12014 if (SWIG_arg_fail(1)) SWIG_fail;
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (int)(arg1)->GetNumberButtons();
12018
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 {
12023 resultobj = SWIG_From_int((int)(result));
12024 }
12025 return resultobj;
12026 fail:
12027 return NULL;
12028 }
12029
12030
12031 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj;
12033 wxJoystick *arg1 = (wxJoystick *) 0 ;
12034 int result;
12035 PyObject * obj0 = 0 ;
12036 char *kwnames[] = {
12037 (char *) "self", NULL
12038 };
12039
12040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12042 if (SWIG_arg_fail(1)) SWIG_fail;
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (int)(arg1)->GetNumberAxes();
12046
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 {
12051 resultobj = SWIG_From_int((int)(result));
12052 }
12053 return resultobj;
12054 fail:
12055 return NULL;
12056 }
12057
12058
12059 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj;
12061 wxJoystick *arg1 = (wxJoystick *) 0 ;
12062 int result;
12063 PyObject * obj0 = 0 ;
12064 char *kwnames[] = {
12065 (char *) "self", NULL
12066 };
12067
12068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12070 if (SWIG_arg_fail(1)) SWIG_fail;
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (int)(arg1)->GetMaxButtons();
12074
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 {
12079 resultobj = SWIG_From_int((int)(result));
12080 }
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj;
12089 wxJoystick *arg1 = (wxJoystick *) 0 ;
12090 int result;
12091 PyObject * obj0 = 0 ;
12092 char *kwnames[] = {
12093 (char *) "self", NULL
12094 };
12095
12096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12098 if (SWIG_arg_fail(1)) SWIG_fail;
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 result = (int)(arg1)->GetMaxAxes();
12102
12103 wxPyEndAllowThreads(__tstate);
12104 if (PyErr_Occurred()) SWIG_fail;
12105 }
12106 {
12107 resultobj = SWIG_From_int((int)(result));
12108 }
12109 return resultobj;
12110 fail:
12111 return NULL;
12112 }
12113
12114
12115 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12116 PyObject *resultobj;
12117 wxJoystick *arg1 = (wxJoystick *) 0 ;
12118 int result;
12119 PyObject * obj0 = 0 ;
12120 char *kwnames[] = {
12121 (char *) "self", NULL
12122 };
12123
12124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12126 if (SWIG_arg_fail(1)) SWIG_fail;
12127 {
12128 PyThreadState* __tstate = wxPyBeginAllowThreads();
12129 result = (int)(arg1)->GetPollingMin();
12130
12131 wxPyEndAllowThreads(__tstate);
12132 if (PyErr_Occurred()) SWIG_fail;
12133 }
12134 {
12135 resultobj = SWIG_From_int((int)(result));
12136 }
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12144 PyObject *resultobj;
12145 wxJoystick *arg1 = (wxJoystick *) 0 ;
12146 int result;
12147 PyObject * obj0 = 0 ;
12148 char *kwnames[] = {
12149 (char *) "self", NULL
12150 };
12151
12152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12154 if (SWIG_arg_fail(1)) SWIG_fail;
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (int)(arg1)->GetPollingMax();
12158
12159 wxPyEndAllowThreads(__tstate);
12160 if (PyErr_Occurred()) SWIG_fail;
12161 }
12162 {
12163 resultobj = SWIG_From_int((int)(result));
12164 }
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12172 PyObject *resultobj;
12173 wxJoystick *arg1 = (wxJoystick *) 0 ;
12174 int result;
12175 PyObject * obj0 = 0 ;
12176 char *kwnames[] = {
12177 (char *) "self", NULL
12178 };
12179
12180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12182 if (SWIG_arg_fail(1)) SWIG_fail;
12183 {
12184 PyThreadState* __tstate = wxPyBeginAllowThreads();
12185 result = (int)(arg1)->GetRudderMin();
12186
12187 wxPyEndAllowThreads(__tstate);
12188 if (PyErr_Occurred()) SWIG_fail;
12189 }
12190 {
12191 resultobj = SWIG_From_int((int)(result));
12192 }
12193 return resultobj;
12194 fail:
12195 return NULL;
12196 }
12197
12198
12199 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12200 PyObject *resultobj;
12201 wxJoystick *arg1 = (wxJoystick *) 0 ;
12202 int result;
12203 PyObject * obj0 = 0 ;
12204 char *kwnames[] = {
12205 (char *) "self", NULL
12206 };
12207
12208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12210 if (SWIG_arg_fail(1)) SWIG_fail;
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 result = (int)(arg1)->GetRudderMax();
12214
12215 wxPyEndAllowThreads(__tstate);
12216 if (PyErr_Occurred()) SWIG_fail;
12217 }
12218 {
12219 resultobj = SWIG_From_int((int)(result));
12220 }
12221 return resultobj;
12222 fail:
12223 return NULL;
12224 }
12225
12226
12227 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12228 PyObject *resultobj;
12229 wxJoystick *arg1 = (wxJoystick *) 0 ;
12230 int result;
12231 PyObject * obj0 = 0 ;
12232 char *kwnames[] = {
12233 (char *) "self", NULL
12234 };
12235
12236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12238 if (SWIG_arg_fail(1)) SWIG_fail;
12239 {
12240 PyThreadState* __tstate = wxPyBeginAllowThreads();
12241 result = (int)(arg1)->GetUMin();
12242
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 {
12247 resultobj = SWIG_From_int((int)(result));
12248 }
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj;
12257 wxJoystick *arg1 = (wxJoystick *) 0 ;
12258 int result;
12259 PyObject * obj0 = 0 ;
12260 char *kwnames[] = {
12261 (char *) "self", NULL
12262 };
12263
12264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12266 if (SWIG_arg_fail(1)) SWIG_fail;
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (int)(arg1)->GetUMax();
12270
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 {
12275 resultobj = SWIG_From_int((int)(result));
12276 }
12277 return resultobj;
12278 fail:
12279 return NULL;
12280 }
12281
12282
12283 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj;
12285 wxJoystick *arg1 = (wxJoystick *) 0 ;
12286 int result;
12287 PyObject * obj0 = 0 ;
12288 char *kwnames[] = {
12289 (char *) "self", NULL
12290 };
12291
12292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12294 if (SWIG_arg_fail(1)) SWIG_fail;
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 result = (int)(arg1)->GetVMin();
12298
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 {
12303 resultobj = SWIG_From_int((int)(result));
12304 }
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj;
12313 wxJoystick *arg1 = (wxJoystick *) 0 ;
12314 int result;
12315 PyObject * obj0 = 0 ;
12316 char *kwnames[] = {
12317 (char *) "self", NULL
12318 };
12319
12320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12322 if (SWIG_arg_fail(1)) SWIG_fail;
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 result = (int)(arg1)->GetVMax();
12326
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 {
12331 resultobj = SWIG_From_int((int)(result));
12332 }
12333 return resultobj;
12334 fail:
12335 return NULL;
12336 }
12337
12338
12339 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj;
12341 wxJoystick *arg1 = (wxJoystick *) 0 ;
12342 bool result;
12343 PyObject * obj0 = 0 ;
12344 char *kwnames[] = {
12345 (char *) "self", NULL
12346 };
12347
12348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12350 if (SWIG_arg_fail(1)) SWIG_fail;
12351 {
12352 PyThreadState* __tstate = wxPyBeginAllowThreads();
12353 result = (bool)(arg1)->HasRudder();
12354
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 {
12359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12360 }
12361 return resultobj;
12362 fail:
12363 return NULL;
12364 }
12365
12366
12367 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12368 PyObject *resultobj;
12369 wxJoystick *arg1 = (wxJoystick *) 0 ;
12370 bool result;
12371 PyObject * obj0 = 0 ;
12372 char *kwnames[] = {
12373 (char *) "self", NULL
12374 };
12375
12376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12378 if (SWIG_arg_fail(1)) SWIG_fail;
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 result = (bool)(arg1)->HasZ();
12382
12383 wxPyEndAllowThreads(__tstate);
12384 if (PyErr_Occurred()) SWIG_fail;
12385 }
12386 {
12387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12388 }
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12396 PyObject *resultobj;
12397 wxJoystick *arg1 = (wxJoystick *) 0 ;
12398 bool result;
12399 PyObject * obj0 = 0 ;
12400 char *kwnames[] = {
12401 (char *) "self", NULL
12402 };
12403
12404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12406 if (SWIG_arg_fail(1)) SWIG_fail;
12407 {
12408 PyThreadState* __tstate = wxPyBeginAllowThreads();
12409 result = (bool)(arg1)->HasU();
12410
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 {
12415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12416 }
12417 return resultobj;
12418 fail:
12419 return NULL;
12420 }
12421
12422
12423 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12424 PyObject *resultobj;
12425 wxJoystick *arg1 = (wxJoystick *) 0 ;
12426 bool result;
12427 PyObject * obj0 = 0 ;
12428 char *kwnames[] = {
12429 (char *) "self", NULL
12430 };
12431
12432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12434 if (SWIG_arg_fail(1)) SWIG_fail;
12435 {
12436 PyThreadState* __tstate = wxPyBeginAllowThreads();
12437 result = (bool)(arg1)->HasV();
12438
12439 wxPyEndAllowThreads(__tstate);
12440 if (PyErr_Occurred()) SWIG_fail;
12441 }
12442 {
12443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12444 }
12445 return resultobj;
12446 fail:
12447 return NULL;
12448 }
12449
12450
12451 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12452 PyObject *resultobj;
12453 wxJoystick *arg1 = (wxJoystick *) 0 ;
12454 bool result;
12455 PyObject * obj0 = 0 ;
12456 char *kwnames[] = {
12457 (char *) "self", NULL
12458 };
12459
12460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12462 if (SWIG_arg_fail(1)) SWIG_fail;
12463 {
12464 PyThreadState* __tstate = wxPyBeginAllowThreads();
12465 result = (bool)(arg1)->HasPOV();
12466
12467 wxPyEndAllowThreads(__tstate);
12468 if (PyErr_Occurred()) SWIG_fail;
12469 }
12470 {
12471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12472 }
12473 return resultobj;
12474 fail:
12475 return NULL;
12476 }
12477
12478
12479 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12480 PyObject *resultobj;
12481 wxJoystick *arg1 = (wxJoystick *) 0 ;
12482 bool result;
12483 PyObject * obj0 = 0 ;
12484 char *kwnames[] = {
12485 (char *) "self", NULL
12486 };
12487
12488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12490 if (SWIG_arg_fail(1)) SWIG_fail;
12491 {
12492 PyThreadState* __tstate = wxPyBeginAllowThreads();
12493 result = (bool)(arg1)->HasPOV4Dir();
12494
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 {
12499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12500 }
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12508 PyObject *resultobj;
12509 wxJoystick *arg1 = (wxJoystick *) 0 ;
12510 bool result;
12511 PyObject * obj0 = 0 ;
12512 char *kwnames[] = {
12513 (char *) "self", NULL
12514 };
12515
12516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12518 if (SWIG_arg_fail(1)) SWIG_fail;
12519 {
12520 PyThreadState* __tstate = wxPyBeginAllowThreads();
12521 result = (bool)(arg1)->HasPOVCTS();
12522
12523 wxPyEndAllowThreads(__tstate);
12524 if (PyErr_Occurred()) SWIG_fail;
12525 }
12526 {
12527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12528 }
12529 return resultobj;
12530 fail:
12531 return NULL;
12532 }
12533
12534
12535 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj;
12537 wxJoystick *arg1 = (wxJoystick *) 0 ;
12538 wxWindow *arg2 = (wxWindow *) 0 ;
12539 int arg3 = (int) 0 ;
12540 bool result;
12541 PyObject * obj0 = 0 ;
12542 PyObject * obj1 = 0 ;
12543 PyObject * obj2 = 0 ;
12544 char *kwnames[] = {
12545 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12546 };
12547
12548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12550 if (SWIG_arg_fail(1)) SWIG_fail;
12551 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12552 if (SWIG_arg_fail(2)) SWIG_fail;
12553 if (obj2) {
12554 {
12555 arg3 = (int)(SWIG_As_int(obj2));
12556 if (SWIG_arg_fail(3)) SWIG_fail;
12557 }
12558 }
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (bool)(arg1)->SetCapture(arg2,arg3);
12562
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 {
12567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12568 }
12569 return resultobj;
12570 fail:
12571 return NULL;
12572 }
12573
12574
12575 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12576 PyObject *resultobj;
12577 wxJoystick *arg1 = (wxJoystick *) 0 ;
12578 bool result;
12579 PyObject * obj0 = 0 ;
12580 char *kwnames[] = {
12581 (char *) "self", NULL
12582 };
12583
12584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12586 if (SWIG_arg_fail(1)) SWIG_fail;
12587 {
12588 PyThreadState* __tstate = wxPyBeginAllowThreads();
12589 result = (bool)(arg1)->ReleaseCapture();
12590
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 {
12595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12596 }
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12604 PyObject *obj;
12605 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12606 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12607 Py_INCREF(obj);
12608 return Py_BuildValue((char *)"");
12609 }
12610 static PyObject *_wrap_JoystickEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj;
12612 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12613 wxPoint *arg2 = (wxPoint *) 0 ;
12614 PyObject * obj0 = 0 ;
12615 PyObject * obj1 = 0 ;
12616 char *kwnames[] = {
12617 (char *) "self",(char *) "m_pos", NULL
12618 };
12619
12620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
12621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12622 if (SWIG_arg_fail(1)) SWIG_fail;
12623 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12624 if (SWIG_arg_fail(2)) SWIG_fail;
12625 if (arg1) (arg1)->m_pos = *arg2;
12626
12627 Py_INCREF(Py_None); resultobj = Py_None;
12628 return resultobj;
12629 fail:
12630 return NULL;
12631 }
12632
12633
12634 static PyObject *_wrap_JoystickEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
12635 PyObject *resultobj;
12636 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12637 wxPoint *result;
12638 PyObject * obj0 = 0 ;
12639 char *kwnames[] = {
12640 (char *) "self", NULL
12641 };
12642
12643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_pos_get",kwnames,&obj0)) goto fail;
12644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12645 if (SWIG_arg_fail(1)) SWIG_fail;
12646 result = (wxPoint *)& ((arg1)->m_pos);
12647
12648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
12649 return resultobj;
12650 fail:
12651 return NULL;
12652 }
12653
12654
12655 static PyObject *_wrap_JoystickEvent_m_zPosition_set(PyObject *, PyObject *args, PyObject *kwargs) {
12656 PyObject *resultobj;
12657 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12658 int arg2 ;
12659 PyObject * obj0 = 0 ;
12660 PyObject * obj1 = 0 ;
12661 char *kwnames[] = {
12662 (char *) "self",(char *) "m_zPosition", NULL
12663 };
12664
12665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_zPosition_set",kwnames,&obj0,&obj1)) goto fail;
12666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12667 if (SWIG_arg_fail(1)) SWIG_fail;
12668 {
12669 arg2 = (int)(SWIG_As_int(obj1));
12670 if (SWIG_arg_fail(2)) SWIG_fail;
12671 }
12672 if (arg1) (arg1)->m_zPosition = arg2;
12673
12674 Py_INCREF(Py_None); resultobj = Py_None;
12675 return resultobj;
12676 fail:
12677 return NULL;
12678 }
12679
12680
12681 static PyObject *_wrap_JoystickEvent_m_zPosition_get(PyObject *, PyObject *args, PyObject *kwargs) {
12682 PyObject *resultobj;
12683 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12684 int result;
12685 PyObject * obj0 = 0 ;
12686 char *kwnames[] = {
12687 (char *) "self", NULL
12688 };
12689
12690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_zPosition_get",kwnames,&obj0)) goto fail;
12691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12692 if (SWIG_arg_fail(1)) SWIG_fail;
12693 result = (int) ((arg1)->m_zPosition);
12694
12695 {
12696 resultobj = SWIG_From_int((int)(result));
12697 }
12698 return resultobj;
12699 fail:
12700 return NULL;
12701 }
12702
12703
12704 static PyObject *_wrap_JoystickEvent_m_buttonChange_set(PyObject *, PyObject *args, PyObject *kwargs) {
12705 PyObject *resultobj;
12706 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12707 int arg2 ;
12708 PyObject * obj0 = 0 ;
12709 PyObject * obj1 = 0 ;
12710 char *kwnames[] = {
12711 (char *) "self",(char *) "m_buttonChange", NULL
12712 };
12713
12714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonChange_set",kwnames,&obj0,&obj1)) goto fail;
12715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12716 if (SWIG_arg_fail(1)) SWIG_fail;
12717 {
12718 arg2 = (int)(SWIG_As_int(obj1));
12719 if (SWIG_arg_fail(2)) SWIG_fail;
12720 }
12721 if (arg1) (arg1)->m_buttonChange = arg2;
12722
12723 Py_INCREF(Py_None); resultobj = Py_None;
12724 return resultobj;
12725 fail:
12726 return NULL;
12727 }
12728
12729
12730 static PyObject *_wrap_JoystickEvent_m_buttonChange_get(PyObject *, PyObject *args, PyObject *kwargs) {
12731 PyObject *resultobj;
12732 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12733 int result;
12734 PyObject * obj0 = 0 ;
12735 char *kwnames[] = {
12736 (char *) "self", NULL
12737 };
12738
12739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonChange_get",kwnames,&obj0)) goto fail;
12740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12741 if (SWIG_arg_fail(1)) SWIG_fail;
12742 result = (int) ((arg1)->m_buttonChange);
12743
12744 {
12745 resultobj = SWIG_From_int((int)(result));
12746 }
12747 return resultobj;
12748 fail:
12749 return NULL;
12750 }
12751
12752
12753 static PyObject *_wrap_JoystickEvent_m_buttonState_set(PyObject *, PyObject *args, PyObject *kwargs) {
12754 PyObject *resultobj;
12755 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12756 int arg2 ;
12757 PyObject * obj0 = 0 ;
12758 PyObject * obj1 = 0 ;
12759 char *kwnames[] = {
12760 (char *) "self",(char *) "m_buttonState", NULL
12761 };
12762
12763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonState_set",kwnames,&obj0,&obj1)) goto fail;
12764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12765 if (SWIG_arg_fail(1)) SWIG_fail;
12766 {
12767 arg2 = (int)(SWIG_As_int(obj1));
12768 if (SWIG_arg_fail(2)) SWIG_fail;
12769 }
12770 if (arg1) (arg1)->m_buttonState = arg2;
12771
12772 Py_INCREF(Py_None); resultobj = Py_None;
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 static PyObject *_wrap_JoystickEvent_m_buttonState_get(PyObject *, PyObject *args, PyObject *kwargs) {
12780 PyObject *resultobj;
12781 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12782 int result;
12783 PyObject * obj0 = 0 ;
12784 char *kwnames[] = {
12785 (char *) "self", NULL
12786 };
12787
12788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonState_get",kwnames,&obj0)) goto fail;
12789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12790 if (SWIG_arg_fail(1)) SWIG_fail;
12791 result = (int) ((arg1)->m_buttonState);
12792
12793 {
12794 resultobj = SWIG_From_int((int)(result));
12795 }
12796 return resultobj;
12797 fail:
12798 return NULL;
12799 }
12800
12801
12802 static PyObject *_wrap_JoystickEvent_m_joyStick_set(PyObject *, PyObject *args, PyObject *kwargs) {
12803 PyObject *resultobj;
12804 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12805 int arg2 ;
12806 PyObject * obj0 = 0 ;
12807 PyObject * obj1 = 0 ;
12808 char *kwnames[] = {
12809 (char *) "self",(char *) "m_joyStick", NULL
12810 };
12811
12812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_joyStick_set",kwnames,&obj0,&obj1)) goto fail;
12813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12814 if (SWIG_arg_fail(1)) SWIG_fail;
12815 {
12816 arg2 = (int)(SWIG_As_int(obj1));
12817 if (SWIG_arg_fail(2)) SWIG_fail;
12818 }
12819 if (arg1) (arg1)->m_joyStick = arg2;
12820
12821 Py_INCREF(Py_None); resultobj = Py_None;
12822 return resultobj;
12823 fail:
12824 return NULL;
12825 }
12826
12827
12828 static PyObject *_wrap_JoystickEvent_m_joyStick_get(PyObject *, PyObject *args, PyObject *kwargs) {
12829 PyObject *resultobj;
12830 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12831 int result;
12832 PyObject * obj0 = 0 ;
12833 char *kwnames[] = {
12834 (char *) "self", NULL
12835 };
12836
12837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_joyStick_get",kwnames,&obj0)) goto fail;
12838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12839 if (SWIG_arg_fail(1)) SWIG_fail;
12840 result = (int) ((arg1)->m_joyStick);
12841
12842 {
12843 resultobj = SWIG_From_int((int)(result));
12844 }
12845 return resultobj;
12846 fail:
12847 return NULL;
12848 }
12849
12850
12851 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12852 PyObject *resultobj;
12853 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12854 int arg2 = (int) 0 ;
12855 int arg3 = (int) wxJOYSTICK1 ;
12856 int arg4 = (int) 0 ;
12857 wxJoystickEvent *result;
12858 PyObject * obj0 = 0 ;
12859 PyObject * obj1 = 0 ;
12860 PyObject * obj2 = 0 ;
12861 PyObject * obj3 = 0 ;
12862 char *kwnames[] = {
12863 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12864 };
12865
12866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12867 if (obj0) {
12868 {
12869 arg1 = (wxEventType)(SWIG_As_int(obj0));
12870 if (SWIG_arg_fail(1)) SWIG_fail;
12871 }
12872 }
12873 if (obj1) {
12874 {
12875 arg2 = (int)(SWIG_As_int(obj1));
12876 if (SWIG_arg_fail(2)) SWIG_fail;
12877 }
12878 }
12879 if (obj2) {
12880 {
12881 arg3 = (int)(SWIG_As_int(obj2));
12882 if (SWIG_arg_fail(3)) SWIG_fail;
12883 }
12884 }
12885 if (obj3) {
12886 {
12887 arg4 = (int)(SWIG_As_int(obj3));
12888 if (SWIG_arg_fail(4)) SWIG_fail;
12889 }
12890 }
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12894
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12899 return resultobj;
12900 fail:
12901 return NULL;
12902 }
12903
12904
12905 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12906 PyObject *resultobj;
12907 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12908 wxPoint result;
12909 PyObject * obj0 = 0 ;
12910 char *kwnames[] = {
12911 (char *) "self", NULL
12912 };
12913
12914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12916 if (SWIG_arg_fail(1)) SWIG_fail;
12917 {
12918 PyThreadState* __tstate = wxPyBeginAllowThreads();
12919 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12920
12921 wxPyEndAllowThreads(__tstate);
12922 if (PyErr_Occurred()) SWIG_fail;
12923 }
12924 {
12925 wxPoint * resultptr;
12926 resultptr = new wxPoint((wxPoint &)(result));
12927 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12928 }
12929 return resultobj;
12930 fail:
12931 return NULL;
12932 }
12933
12934
12935 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12936 PyObject *resultobj;
12937 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12938 int result;
12939 PyObject * obj0 = 0 ;
12940 char *kwnames[] = {
12941 (char *) "self", NULL
12942 };
12943
12944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12946 if (SWIG_arg_fail(1)) SWIG_fail;
12947 {
12948 PyThreadState* __tstate = wxPyBeginAllowThreads();
12949 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12950
12951 wxPyEndAllowThreads(__tstate);
12952 if (PyErr_Occurred()) SWIG_fail;
12953 }
12954 {
12955 resultobj = SWIG_From_int((int)(result));
12956 }
12957 return resultobj;
12958 fail:
12959 return NULL;
12960 }
12961
12962
12963 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12964 PyObject *resultobj;
12965 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12966 int result;
12967 PyObject * obj0 = 0 ;
12968 char *kwnames[] = {
12969 (char *) "self", NULL
12970 };
12971
12972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12974 if (SWIG_arg_fail(1)) SWIG_fail;
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12978
12979 wxPyEndAllowThreads(__tstate);
12980 if (PyErr_Occurred()) SWIG_fail;
12981 }
12982 {
12983 resultobj = SWIG_From_int((int)(result));
12984 }
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12992 PyObject *resultobj;
12993 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12994 int result;
12995 PyObject * obj0 = 0 ;
12996 char *kwnames[] = {
12997 (char *) "self", NULL
12998 };
12999
13000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13002 if (SWIG_arg_fail(1)) SWIG_fail;
13003 {
13004 PyThreadState* __tstate = wxPyBeginAllowThreads();
13005 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13006
13007 wxPyEndAllowThreads(__tstate);
13008 if (PyErr_Occurred()) SWIG_fail;
13009 }
13010 {
13011 resultobj = SWIG_From_int((int)(result));
13012 }
13013 return resultobj;
13014 fail:
13015 return NULL;
13016 }
13017
13018
13019 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13020 PyObject *resultobj;
13021 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13022 int result;
13023 PyObject * obj0 = 0 ;
13024 char *kwnames[] = {
13025 (char *) "self", NULL
13026 };
13027
13028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13030 if (SWIG_arg_fail(1)) SWIG_fail;
13031 {
13032 PyThreadState* __tstate = wxPyBeginAllowThreads();
13033 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13034
13035 wxPyEndAllowThreads(__tstate);
13036 if (PyErr_Occurred()) SWIG_fail;
13037 }
13038 {
13039 resultobj = SWIG_From_int((int)(result));
13040 }
13041 return resultobj;
13042 fail:
13043 return NULL;
13044 }
13045
13046
13047 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13048 PyObject *resultobj;
13049 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13050 int arg2 ;
13051 PyObject * obj0 = 0 ;
13052 PyObject * obj1 = 0 ;
13053 char *kwnames[] = {
13054 (char *) "self",(char *) "stick", NULL
13055 };
13056
13057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13059 if (SWIG_arg_fail(1)) SWIG_fail;
13060 {
13061 arg2 = (int)(SWIG_As_int(obj1));
13062 if (SWIG_arg_fail(2)) SWIG_fail;
13063 }
13064 {
13065 PyThreadState* __tstate = wxPyBeginAllowThreads();
13066 (arg1)->SetJoystick(arg2);
13067
13068 wxPyEndAllowThreads(__tstate);
13069 if (PyErr_Occurred()) SWIG_fail;
13070 }
13071 Py_INCREF(Py_None); resultobj = Py_None;
13072 return resultobj;
13073 fail:
13074 return NULL;
13075 }
13076
13077
13078 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13079 PyObject *resultobj;
13080 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13081 int arg2 ;
13082 PyObject * obj0 = 0 ;
13083 PyObject * obj1 = 0 ;
13084 char *kwnames[] = {
13085 (char *) "self",(char *) "state", NULL
13086 };
13087
13088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13090 if (SWIG_arg_fail(1)) SWIG_fail;
13091 {
13092 arg2 = (int)(SWIG_As_int(obj1));
13093 if (SWIG_arg_fail(2)) SWIG_fail;
13094 }
13095 {
13096 PyThreadState* __tstate = wxPyBeginAllowThreads();
13097 (arg1)->SetButtonState(arg2);
13098
13099 wxPyEndAllowThreads(__tstate);
13100 if (PyErr_Occurred()) SWIG_fail;
13101 }
13102 Py_INCREF(Py_None); resultobj = Py_None;
13103 return resultobj;
13104 fail:
13105 return NULL;
13106 }
13107
13108
13109 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13110 PyObject *resultobj;
13111 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13112 int arg2 ;
13113 PyObject * obj0 = 0 ;
13114 PyObject * obj1 = 0 ;
13115 char *kwnames[] = {
13116 (char *) "self",(char *) "change", NULL
13117 };
13118
13119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13121 if (SWIG_arg_fail(1)) SWIG_fail;
13122 {
13123 arg2 = (int)(SWIG_As_int(obj1));
13124 if (SWIG_arg_fail(2)) SWIG_fail;
13125 }
13126 {
13127 PyThreadState* __tstate = wxPyBeginAllowThreads();
13128 (arg1)->SetButtonChange(arg2);
13129
13130 wxPyEndAllowThreads(__tstate);
13131 if (PyErr_Occurred()) SWIG_fail;
13132 }
13133 Py_INCREF(Py_None); resultobj = Py_None;
13134 return resultobj;
13135 fail:
13136 return NULL;
13137 }
13138
13139
13140 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13141 PyObject *resultobj;
13142 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13143 wxPoint *arg2 = 0 ;
13144 wxPoint temp2 ;
13145 PyObject * obj0 = 0 ;
13146 PyObject * obj1 = 0 ;
13147 char *kwnames[] = {
13148 (char *) "self",(char *) "pos", NULL
13149 };
13150
13151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13153 if (SWIG_arg_fail(1)) SWIG_fail;
13154 {
13155 arg2 = &temp2;
13156 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13157 }
13158 {
13159 PyThreadState* __tstate = wxPyBeginAllowThreads();
13160 (arg1)->SetPosition((wxPoint const &)*arg2);
13161
13162 wxPyEndAllowThreads(__tstate);
13163 if (PyErr_Occurred()) SWIG_fail;
13164 }
13165 Py_INCREF(Py_None); resultobj = Py_None;
13166 return resultobj;
13167 fail:
13168 return NULL;
13169 }
13170
13171
13172 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13173 PyObject *resultobj;
13174 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13175 int arg2 ;
13176 PyObject * obj0 = 0 ;
13177 PyObject * obj1 = 0 ;
13178 char *kwnames[] = {
13179 (char *) "self",(char *) "zPos", NULL
13180 };
13181
13182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13184 if (SWIG_arg_fail(1)) SWIG_fail;
13185 {
13186 arg2 = (int)(SWIG_As_int(obj1));
13187 if (SWIG_arg_fail(2)) SWIG_fail;
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 (arg1)->SetZPosition(arg2);
13192
13193 wxPyEndAllowThreads(__tstate);
13194 if (PyErr_Occurred()) SWIG_fail;
13195 }
13196 Py_INCREF(Py_None); resultobj = Py_None;
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13204 PyObject *resultobj;
13205 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13206 bool result;
13207 PyObject * obj0 = 0 ;
13208 char *kwnames[] = {
13209 (char *) "self", NULL
13210 };
13211
13212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13214 if (SWIG_arg_fail(1)) SWIG_fail;
13215 {
13216 PyThreadState* __tstate = wxPyBeginAllowThreads();
13217 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13218
13219 wxPyEndAllowThreads(__tstate);
13220 if (PyErr_Occurred()) SWIG_fail;
13221 }
13222 {
13223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13224 }
13225 return resultobj;
13226 fail:
13227 return NULL;
13228 }
13229
13230
13231 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13232 PyObject *resultobj;
13233 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13234 bool result;
13235 PyObject * obj0 = 0 ;
13236 char *kwnames[] = {
13237 (char *) "self", NULL
13238 };
13239
13240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13242 if (SWIG_arg_fail(1)) SWIG_fail;
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13246
13247 wxPyEndAllowThreads(__tstate);
13248 if (PyErr_Occurred()) SWIG_fail;
13249 }
13250 {
13251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13252 }
13253 return resultobj;
13254 fail:
13255 return NULL;
13256 }
13257
13258
13259 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13260 PyObject *resultobj;
13261 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13262 bool result;
13263 PyObject * obj0 = 0 ;
13264 char *kwnames[] = {
13265 (char *) "self", NULL
13266 };
13267
13268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13270 if (SWIG_arg_fail(1)) SWIG_fail;
13271 {
13272 PyThreadState* __tstate = wxPyBeginAllowThreads();
13273 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13274
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 {
13279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13280 }
13281 return resultobj;
13282 fail:
13283 return NULL;
13284 }
13285
13286
13287 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13288 PyObject *resultobj;
13289 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13290 int arg2 = (int) wxJOY_BUTTON_ANY ;
13291 bool result;
13292 PyObject * obj0 = 0 ;
13293 PyObject * obj1 = 0 ;
13294 char *kwnames[] = {
13295 (char *) "self",(char *) "but", NULL
13296 };
13297
13298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13300 if (SWIG_arg_fail(1)) SWIG_fail;
13301 if (obj1) {
13302 {
13303 arg2 = (int)(SWIG_As_int(obj1));
13304 if (SWIG_arg_fail(2)) SWIG_fail;
13305 }
13306 }
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13310
13311 wxPyEndAllowThreads(__tstate);
13312 if (PyErr_Occurred()) SWIG_fail;
13313 }
13314 {
13315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13316 }
13317 return resultobj;
13318 fail:
13319 return NULL;
13320 }
13321
13322
13323 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13324 PyObject *resultobj;
13325 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13326 int arg2 = (int) wxJOY_BUTTON_ANY ;
13327 bool result;
13328 PyObject * obj0 = 0 ;
13329 PyObject * obj1 = 0 ;
13330 char *kwnames[] = {
13331 (char *) "self",(char *) "but", NULL
13332 };
13333
13334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13336 if (SWIG_arg_fail(1)) SWIG_fail;
13337 if (obj1) {
13338 {
13339 arg2 = (int)(SWIG_As_int(obj1));
13340 if (SWIG_arg_fail(2)) SWIG_fail;
13341 }
13342 }
13343 {
13344 PyThreadState* __tstate = wxPyBeginAllowThreads();
13345 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13346
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 {
13351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13352 }
13353 return resultobj;
13354 fail:
13355 return NULL;
13356 }
13357
13358
13359 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13360 PyObject *resultobj;
13361 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13362 int arg2 = (int) wxJOY_BUTTON_ANY ;
13363 bool result;
13364 PyObject * obj0 = 0 ;
13365 PyObject * obj1 = 0 ;
13366 char *kwnames[] = {
13367 (char *) "self",(char *) "but", NULL
13368 };
13369
13370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13372 if (SWIG_arg_fail(1)) SWIG_fail;
13373 if (obj1) {
13374 {
13375 arg2 = (int)(SWIG_As_int(obj1));
13376 if (SWIG_arg_fail(2)) SWIG_fail;
13377 }
13378 }
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13382
13383 wxPyEndAllowThreads(__tstate);
13384 if (PyErr_Occurred()) SWIG_fail;
13385 }
13386 {
13387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13388 }
13389 return resultobj;
13390 fail:
13391 return NULL;
13392 }
13393
13394
13395 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13396 PyObject *obj;
13397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13398 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13399 Py_INCREF(obj);
13400 return Py_BuildValue((char *)"");
13401 }
13402 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13403 PyObject *resultobj;
13404 wxString const &arg1_defvalue = wxPyEmptyString ;
13405 wxString *arg1 = (wxString *) &arg1_defvalue ;
13406 wxSound *result;
13407 bool temp1 = false ;
13408 PyObject * obj0 = 0 ;
13409 char *kwnames[] = {
13410 (char *) "fileName", NULL
13411 };
13412
13413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13414 if (obj0) {
13415 {
13416 arg1 = wxString_in_helper(obj0);
13417 if (arg1 == NULL) SWIG_fail;
13418 temp1 = true;
13419 }
13420 }
13421 {
13422 if (!wxPyCheckForApp()) SWIG_fail;
13423 PyThreadState* __tstate = wxPyBeginAllowThreads();
13424 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13425
13426 wxPyEndAllowThreads(__tstate);
13427 if (PyErr_Occurred()) SWIG_fail;
13428 }
13429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13430 {
13431 if (temp1)
13432 delete arg1;
13433 }
13434 return resultobj;
13435 fail:
13436 {
13437 if (temp1)
13438 delete arg1;
13439 }
13440 return NULL;
13441 }
13442
13443
13444 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13445 PyObject *resultobj;
13446 PyObject *arg1 = (PyObject *) 0 ;
13447 wxSound *result;
13448 PyObject * obj0 = 0 ;
13449 char *kwnames[] = {
13450 (char *) "data", NULL
13451 };
13452
13453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13454 arg1 = obj0;
13455 {
13456 if (!wxPyCheckForApp()) SWIG_fail;
13457 PyThreadState* __tstate = wxPyBeginAllowThreads();
13458 result = (wxSound *)new_wxSound(arg1);
13459
13460 wxPyEndAllowThreads(__tstate);
13461 if (PyErr_Occurred()) SWIG_fail;
13462 }
13463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13464 return resultobj;
13465 fail:
13466 return NULL;
13467 }
13468
13469
13470 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13471 PyObject *resultobj;
13472 wxSound *arg1 = (wxSound *) 0 ;
13473 PyObject * obj0 = 0 ;
13474 char *kwnames[] = {
13475 (char *) "self", NULL
13476 };
13477
13478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13480 if (SWIG_arg_fail(1)) SWIG_fail;
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 delete arg1;
13484
13485 wxPyEndAllowThreads(__tstate);
13486 if (PyErr_Occurred()) SWIG_fail;
13487 }
13488 Py_INCREF(Py_None); resultobj = Py_None;
13489 return resultobj;
13490 fail:
13491 return NULL;
13492 }
13493
13494
13495 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13496 PyObject *resultobj;
13497 wxSound *arg1 = (wxSound *) 0 ;
13498 wxString *arg2 = 0 ;
13499 bool result;
13500 bool temp2 = false ;
13501 PyObject * obj0 = 0 ;
13502 PyObject * obj1 = 0 ;
13503 char *kwnames[] = {
13504 (char *) "self",(char *) "fileName", NULL
13505 };
13506
13507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13509 if (SWIG_arg_fail(1)) SWIG_fail;
13510 {
13511 arg2 = wxString_in_helper(obj1);
13512 if (arg2 == NULL) SWIG_fail;
13513 temp2 = true;
13514 }
13515 {
13516 PyThreadState* __tstate = wxPyBeginAllowThreads();
13517 result = (bool)(arg1)->Create((wxString const &)*arg2);
13518
13519 wxPyEndAllowThreads(__tstate);
13520 if (PyErr_Occurred()) SWIG_fail;
13521 }
13522 {
13523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13524 }
13525 {
13526 if (temp2)
13527 delete arg2;
13528 }
13529 return resultobj;
13530 fail:
13531 {
13532 if (temp2)
13533 delete arg2;
13534 }
13535 return NULL;
13536 }
13537
13538
13539 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13540 PyObject *resultobj;
13541 wxSound *arg1 = (wxSound *) 0 ;
13542 PyObject *arg2 = (PyObject *) 0 ;
13543 bool result;
13544 PyObject * obj0 = 0 ;
13545 PyObject * obj1 = 0 ;
13546 char *kwnames[] = {
13547 (char *) "self",(char *) "data", NULL
13548 };
13549
13550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13552 if (SWIG_arg_fail(1)) SWIG_fail;
13553 arg2 = obj1;
13554 {
13555 PyThreadState* __tstate = wxPyBeginAllowThreads();
13556 result = (bool)wxSound_CreateFromData(arg1,arg2);
13557
13558 wxPyEndAllowThreads(__tstate);
13559 if (PyErr_Occurred()) SWIG_fail;
13560 }
13561 {
13562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13563 }
13564 return resultobj;
13565 fail:
13566 return NULL;
13567 }
13568
13569
13570 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj;
13572 wxSound *arg1 = (wxSound *) 0 ;
13573 bool result;
13574 PyObject * obj0 = 0 ;
13575 char *kwnames[] = {
13576 (char *) "self", NULL
13577 };
13578
13579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13581 if (SWIG_arg_fail(1)) SWIG_fail;
13582 {
13583 PyThreadState* __tstate = wxPyBeginAllowThreads();
13584 result = (bool)(arg1)->IsOk();
13585
13586 wxPyEndAllowThreads(__tstate);
13587 if (PyErr_Occurred()) SWIG_fail;
13588 }
13589 {
13590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13591 }
13592 return resultobj;
13593 fail:
13594 return NULL;
13595 }
13596
13597
13598 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13599 PyObject *resultobj;
13600 wxSound *arg1 = (wxSound *) 0 ;
13601 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13602 bool result;
13603 PyObject * obj0 = 0 ;
13604 PyObject * obj1 = 0 ;
13605 char *kwnames[] = {
13606 (char *) "self",(char *) "flags", NULL
13607 };
13608
13609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13611 if (SWIG_arg_fail(1)) SWIG_fail;
13612 if (obj1) {
13613 {
13614 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13615 if (SWIG_arg_fail(2)) SWIG_fail;
13616 }
13617 }
13618 {
13619 if (!wxPyCheckForApp()) SWIG_fail;
13620 PyThreadState* __tstate = wxPyBeginAllowThreads();
13621 result = (bool)((wxSound const *)arg1)->Play(arg2);
13622
13623 wxPyEndAllowThreads(__tstate);
13624 if (PyErr_Occurred()) SWIG_fail;
13625 }
13626 {
13627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13628 }
13629 return resultobj;
13630 fail:
13631 return NULL;
13632 }
13633
13634
13635 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13636 PyObject *resultobj;
13637 wxString *arg1 = 0 ;
13638 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13639 bool result;
13640 bool temp1 = false ;
13641 PyObject * obj0 = 0 ;
13642 PyObject * obj1 = 0 ;
13643 char *kwnames[] = {
13644 (char *) "filename",(char *) "flags", NULL
13645 };
13646
13647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13648 {
13649 arg1 = wxString_in_helper(obj0);
13650 if (arg1 == NULL) SWIG_fail;
13651 temp1 = true;
13652 }
13653 if (obj1) {
13654 {
13655 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13656 if (SWIG_arg_fail(2)) SWIG_fail;
13657 }
13658 }
13659 {
13660 if (!wxPyCheckForApp()) SWIG_fail;
13661 PyThreadState* __tstate = wxPyBeginAllowThreads();
13662 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13663
13664 wxPyEndAllowThreads(__tstate);
13665 if (PyErr_Occurred()) SWIG_fail;
13666 }
13667 {
13668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13669 }
13670 {
13671 if (temp1)
13672 delete arg1;
13673 }
13674 return resultobj;
13675 fail:
13676 {
13677 if (temp1)
13678 delete arg1;
13679 }
13680 return NULL;
13681 }
13682
13683
13684 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj;
13686 char *kwnames[] = {
13687 NULL
13688 };
13689
13690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13691 {
13692 if (!wxPyCheckForApp()) SWIG_fail;
13693 PyThreadState* __tstate = wxPyBeginAllowThreads();
13694 Sound_Stop();
13695
13696 wxPyEndAllowThreads(__tstate);
13697 if (PyErr_Occurred()) SWIG_fail;
13698 }
13699 Py_INCREF(Py_None); resultobj = Py_None;
13700 return resultobj;
13701 fail:
13702 return NULL;
13703 }
13704
13705
13706 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13707 PyObject *obj;
13708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13709 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13710 Py_INCREF(obj);
13711 return Py_BuildValue((char *)"");
13712 }
13713 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13714 PyObject *resultobj;
13715 wxString *arg1 = 0 ;
13716 wxString *arg2 = 0 ;
13717 wxString *arg3 = 0 ;
13718 wxString *arg4 = 0 ;
13719 wxFileTypeInfo *result;
13720 bool temp1 = false ;
13721 bool temp2 = false ;
13722 bool temp3 = false ;
13723 bool temp4 = false ;
13724 PyObject * obj0 = 0 ;
13725 PyObject * obj1 = 0 ;
13726 PyObject * obj2 = 0 ;
13727 PyObject * obj3 = 0 ;
13728 char *kwnames[] = {
13729 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13730 };
13731
13732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13733 {
13734 arg1 = wxString_in_helper(obj0);
13735 if (arg1 == NULL) SWIG_fail;
13736 temp1 = true;
13737 }
13738 {
13739 arg2 = wxString_in_helper(obj1);
13740 if (arg2 == NULL) SWIG_fail;
13741 temp2 = true;
13742 }
13743 {
13744 arg3 = wxString_in_helper(obj2);
13745 if (arg3 == NULL) SWIG_fail;
13746 temp3 = true;
13747 }
13748 {
13749 arg4 = wxString_in_helper(obj3);
13750 if (arg4 == NULL) SWIG_fail;
13751 temp4 = true;
13752 }
13753 {
13754 PyThreadState* __tstate = wxPyBeginAllowThreads();
13755 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13756
13757 wxPyEndAllowThreads(__tstate);
13758 if (PyErr_Occurred()) SWIG_fail;
13759 }
13760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13761 {
13762 if (temp1)
13763 delete arg1;
13764 }
13765 {
13766 if (temp2)
13767 delete arg2;
13768 }
13769 {
13770 if (temp3)
13771 delete arg3;
13772 }
13773 {
13774 if (temp4)
13775 delete arg4;
13776 }
13777 return resultobj;
13778 fail:
13779 {
13780 if (temp1)
13781 delete arg1;
13782 }
13783 {
13784 if (temp2)
13785 delete arg2;
13786 }
13787 {
13788 if (temp3)
13789 delete arg3;
13790 }
13791 {
13792 if (temp4)
13793 delete arg4;
13794 }
13795 return NULL;
13796 }
13797
13798
13799 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13800 PyObject *resultobj;
13801 wxArrayString *arg1 = 0 ;
13802 wxFileTypeInfo *result;
13803 bool temp1 = false ;
13804 PyObject * obj0 = 0 ;
13805 char *kwnames[] = {
13806 (char *) "sArray", NULL
13807 };
13808
13809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13810 {
13811 if (! PySequence_Check(obj0)) {
13812 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13813 SWIG_fail;
13814 }
13815 arg1 = new wxArrayString;
13816 temp1 = true;
13817 int i, len=PySequence_Length(obj0);
13818 for (i=0; i<len; i++) {
13819 PyObject* item = PySequence_GetItem(obj0, i);
13820 #if wxUSE_UNICODE
13821 PyObject* str = PyObject_Unicode(item);
13822 #else
13823 PyObject* str = PyObject_Str(item);
13824 #endif
13825 if (PyErr_Occurred()) SWIG_fail;
13826 arg1->Add(Py2wxString(str));
13827 Py_DECREF(item);
13828 Py_DECREF(str);
13829 }
13830 }
13831 {
13832 PyThreadState* __tstate = wxPyBeginAllowThreads();
13833 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13834
13835 wxPyEndAllowThreads(__tstate);
13836 if (PyErr_Occurred()) SWIG_fail;
13837 }
13838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13839 {
13840 if (temp1) delete arg1;
13841 }
13842 return resultobj;
13843 fail:
13844 {
13845 if (temp1) delete arg1;
13846 }
13847 return NULL;
13848 }
13849
13850
13851 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13852 PyObject *resultobj;
13853 wxFileTypeInfo *result;
13854 char *kwnames[] = {
13855 NULL
13856 };
13857
13858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13859 {
13860 PyThreadState* __tstate = wxPyBeginAllowThreads();
13861 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13862
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13867 return resultobj;
13868 fail:
13869 return NULL;
13870 }
13871
13872
13873 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13874 PyObject *resultobj;
13875 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13876 bool result;
13877 PyObject * obj0 = 0 ;
13878 char *kwnames[] = {
13879 (char *) "self", NULL
13880 };
13881
13882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13884 if (SWIG_arg_fail(1)) SWIG_fail;
13885 {
13886 PyThreadState* __tstate = wxPyBeginAllowThreads();
13887 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13888
13889 wxPyEndAllowThreads(__tstate);
13890 if (PyErr_Occurred()) SWIG_fail;
13891 }
13892 {
13893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13894 }
13895 return resultobj;
13896 fail:
13897 return NULL;
13898 }
13899
13900
13901 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13902 PyObject *resultobj;
13903 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13904 wxString *arg2 = 0 ;
13905 int arg3 = (int) 0 ;
13906 bool temp2 = false ;
13907 PyObject * obj0 = 0 ;
13908 PyObject * obj1 = 0 ;
13909 PyObject * obj2 = 0 ;
13910 char *kwnames[] = {
13911 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13912 };
13913
13914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13916 if (SWIG_arg_fail(1)) SWIG_fail;
13917 {
13918 arg2 = wxString_in_helper(obj1);
13919 if (arg2 == NULL) SWIG_fail;
13920 temp2 = true;
13921 }
13922 if (obj2) {
13923 {
13924 arg3 = (int)(SWIG_As_int(obj2));
13925 if (SWIG_arg_fail(3)) SWIG_fail;
13926 }
13927 }
13928 {
13929 PyThreadState* __tstate = wxPyBeginAllowThreads();
13930 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13931
13932 wxPyEndAllowThreads(__tstate);
13933 if (PyErr_Occurred()) SWIG_fail;
13934 }
13935 Py_INCREF(Py_None); resultobj = Py_None;
13936 {
13937 if (temp2)
13938 delete arg2;
13939 }
13940 return resultobj;
13941 fail:
13942 {
13943 if (temp2)
13944 delete arg2;
13945 }
13946 return NULL;
13947 }
13948
13949
13950 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13951 PyObject *resultobj;
13952 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13953 wxString *arg2 = 0 ;
13954 bool temp2 = false ;
13955 PyObject * obj0 = 0 ;
13956 PyObject * obj1 = 0 ;
13957 char *kwnames[] = {
13958 (char *) "self",(char *) "shortDesc", NULL
13959 };
13960
13961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13963 if (SWIG_arg_fail(1)) SWIG_fail;
13964 {
13965 arg2 = wxString_in_helper(obj1);
13966 if (arg2 == NULL) SWIG_fail;
13967 temp2 = true;
13968 }
13969 {
13970 PyThreadState* __tstate = wxPyBeginAllowThreads();
13971 (arg1)->SetShortDesc((wxString const &)*arg2);
13972
13973 wxPyEndAllowThreads(__tstate);
13974 if (PyErr_Occurred()) SWIG_fail;
13975 }
13976 Py_INCREF(Py_None); resultobj = Py_None;
13977 {
13978 if (temp2)
13979 delete arg2;
13980 }
13981 return resultobj;
13982 fail:
13983 {
13984 if (temp2)
13985 delete arg2;
13986 }
13987 return NULL;
13988 }
13989
13990
13991 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13992 PyObject *resultobj;
13993 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13994 wxString *result;
13995 PyObject * obj0 = 0 ;
13996 char *kwnames[] = {
13997 (char *) "self", NULL
13998 };
13999
14000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14002 if (SWIG_arg_fail(1)) SWIG_fail;
14003 {
14004 PyThreadState* __tstate = wxPyBeginAllowThreads();
14005 {
14006 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14007 result = (wxString *) &_result_ref;
14008 }
14009
14010 wxPyEndAllowThreads(__tstate);
14011 if (PyErr_Occurred()) SWIG_fail;
14012 }
14013 {
14014 #if wxUSE_UNICODE
14015 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14016 #else
14017 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14018 #endif
14019 }
14020 return resultobj;
14021 fail:
14022 return NULL;
14023 }
14024
14025
14026 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14027 PyObject *resultobj;
14028 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14029 wxString *result;
14030 PyObject * obj0 = 0 ;
14031 char *kwnames[] = {
14032 (char *) "self", NULL
14033 };
14034
14035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14037 if (SWIG_arg_fail(1)) SWIG_fail;
14038 {
14039 PyThreadState* __tstate = wxPyBeginAllowThreads();
14040 {
14041 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14042 result = (wxString *) &_result_ref;
14043 }
14044
14045 wxPyEndAllowThreads(__tstate);
14046 if (PyErr_Occurred()) SWIG_fail;
14047 }
14048 {
14049 #if wxUSE_UNICODE
14050 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14051 #else
14052 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14053 #endif
14054 }
14055 return resultobj;
14056 fail:
14057 return NULL;
14058 }
14059
14060
14061 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14062 PyObject *resultobj;
14063 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14064 wxString *result;
14065 PyObject * obj0 = 0 ;
14066 char *kwnames[] = {
14067 (char *) "self", NULL
14068 };
14069
14070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14072 if (SWIG_arg_fail(1)) SWIG_fail;
14073 {
14074 PyThreadState* __tstate = wxPyBeginAllowThreads();
14075 {
14076 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14077 result = (wxString *) &_result_ref;
14078 }
14079
14080 wxPyEndAllowThreads(__tstate);
14081 if (PyErr_Occurred()) SWIG_fail;
14082 }
14083 {
14084 #if wxUSE_UNICODE
14085 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14086 #else
14087 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14088 #endif
14089 }
14090 return resultobj;
14091 fail:
14092 return NULL;
14093 }
14094
14095
14096 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14097 PyObject *resultobj;
14098 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14099 wxString *result;
14100 PyObject * obj0 = 0 ;
14101 char *kwnames[] = {
14102 (char *) "self", NULL
14103 };
14104
14105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14107 if (SWIG_arg_fail(1)) SWIG_fail;
14108 {
14109 PyThreadState* __tstate = wxPyBeginAllowThreads();
14110 {
14111 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14112 result = (wxString *) &_result_ref;
14113 }
14114
14115 wxPyEndAllowThreads(__tstate);
14116 if (PyErr_Occurred()) SWIG_fail;
14117 }
14118 {
14119 #if wxUSE_UNICODE
14120 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14121 #else
14122 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14123 #endif
14124 }
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14132 PyObject *resultobj;
14133 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14134 wxString *result;
14135 PyObject * obj0 = 0 ;
14136 char *kwnames[] = {
14137 (char *) "self", NULL
14138 };
14139
14140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14142 if (SWIG_arg_fail(1)) SWIG_fail;
14143 {
14144 PyThreadState* __tstate = wxPyBeginAllowThreads();
14145 {
14146 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14147 result = (wxString *) &_result_ref;
14148 }
14149
14150 wxPyEndAllowThreads(__tstate);
14151 if (PyErr_Occurred()) SWIG_fail;
14152 }
14153 {
14154 #if wxUSE_UNICODE
14155 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14156 #else
14157 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14158 #endif
14159 }
14160 return resultobj;
14161 fail:
14162 return NULL;
14163 }
14164
14165
14166 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14167 PyObject *resultobj;
14168 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14169 wxArrayString *result;
14170 PyObject * obj0 = 0 ;
14171 char *kwnames[] = {
14172 (char *) "self", NULL
14173 };
14174
14175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14177 if (SWIG_arg_fail(1)) SWIG_fail;
14178 {
14179 PyThreadState* __tstate = wxPyBeginAllowThreads();
14180 {
14181 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14182 result = (wxArrayString *) &_result_ref;
14183 }
14184
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 {
14189 resultobj = wxArrayString2PyList_helper(*result);
14190 }
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj;
14199 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14200 int result;
14201 PyObject * obj0 = 0 ;
14202 char *kwnames[] = {
14203 (char *) "self", NULL
14204 };
14205
14206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14208 if (SWIG_arg_fail(1)) SWIG_fail;
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14212
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 {
14217 resultobj = SWIG_From_int((int)(result));
14218 }
14219 return resultobj;
14220 fail:
14221 return NULL;
14222 }
14223
14224
14225 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14226 PyObject *resultobj;
14227 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14228 wxString *result;
14229 PyObject * obj0 = 0 ;
14230 char *kwnames[] = {
14231 (char *) "self", NULL
14232 };
14233
14234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14236 if (SWIG_arg_fail(1)) SWIG_fail;
14237 {
14238 PyThreadState* __tstate = wxPyBeginAllowThreads();
14239 {
14240 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14241 result = (wxString *) &_result_ref;
14242 }
14243
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 {
14248 #if wxUSE_UNICODE
14249 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14250 #else
14251 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14252 #endif
14253 }
14254 return resultobj;
14255 fail:
14256 return NULL;
14257 }
14258
14259
14260 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14261 PyObject *resultobj;
14262 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14263 int result;
14264 PyObject * obj0 = 0 ;
14265 char *kwnames[] = {
14266 (char *) "self", NULL
14267 };
14268
14269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14271 if (SWIG_arg_fail(1)) SWIG_fail;
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14275
14276 wxPyEndAllowThreads(__tstate);
14277 if (PyErr_Occurred()) SWIG_fail;
14278 }
14279 {
14280 resultobj = SWIG_From_int((int)(result));
14281 }
14282 return resultobj;
14283 fail:
14284 return NULL;
14285 }
14286
14287
14288 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14289 PyObject *obj;
14290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14291 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14292 Py_INCREF(obj);
14293 return Py_BuildValue((char *)"");
14294 }
14295 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14296 PyObject *resultobj;
14297 wxFileTypeInfo *arg1 = 0 ;
14298 wxFileType *result;
14299 PyObject * obj0 = 0 ;
14300 char *kwnames[] = {
14301 (char *) "ftInfo", NULL
14302 };
14303
14304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14305 {
14306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14307 if (SWIG_arg_fail(1)) SWIG_fail;
14308 if (arg1 == NULL) {
14309 SWIG_null_ref("wxFileTypeInfo");
14310 }
14311 if (SWIG_arg_fail(1)) SWIG_fail;
14312 }
14313 {
14314 PyThreadState* __tstate = wxPyBeginAllowThreads();
14315 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14316
14317 wxPyEndAllowThreads(__tstate);
14318 if (PyErr_Occurred()) SWIG_fail;
14319 }
14320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14321 return resultobj;
14322 fail:
14323 return NULL;
14324 }
14325
14326
14327 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14328 PyObject *resultobj;
14329 wxFileType *arg1 = (wxFileType *) 0 ;
14330 PyObject * obj0 = 0 ;
14331 char *kwnames[] = {
14332 (char *) "self", NULL
14333 };
14334
14335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14337 if (SWIG_arg_fail(1)) SWIG_fail;
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 delete arg1;
14341
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 Py_INCREF(Py_None); resultobj = Py_None;
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14353 PyObject *resultobj;
14354 wxFileType *arg1 = (wxFileType *) 0 ;
14355 PyObject *result;
14356 PyObject * obj0 = 0 ;
14357 char *kwnames[] = {
14358 (char *) "self", NULL
14359 };
14360
14361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14363 if (SWIG_arg_fail(1)) SWIG_fail;
14364 {
14365 PyThreadState* __tstate = wxPyBeginAllowThreads();
14366 result = (PyObject *)wxFileType_GetMimeType(arg1);
14367
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 resultobj = result;
14372 return resultobj;
14373 fail:
14374 return NULL;
14375 }
14376
14377
14378 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14379 PyObject *resultobj;
14380 wxFileType *arg1 = (wxFileType *) 0 ;
14381 PyObject *result;
14382 PyObject * obj0 = 0 ;
14383 char *kwnames[] = {
14384 (char *) "self", NULL
14385 };
14386
14387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14389 if (SWIG_arg_fail(1)) SWIG_fail;
14390 {
14391 PyThreadState* __tstate = wxPyBeginAllowThreads();
14392 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14393
14394 wxPyEndAllowThreads(__tstate);
14395 if (PyErr_Occurred()) SWIG_fail;
14396 }
14397 resultobj = result;
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj;
14406 wxFileType *arg1 = (wxFileType *) 0 ;
14407 PyObject *result;
14408 PyObject * obj0 = 0 ;
14409 char *kwnames[] = {
14410 (char *) "self", NULL
14411 };
14412
14413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14415 if (SWIG_arg_fail(1)) SWIG_fail;
14416 {
14417 PyThreadState* __tstate = wxPyBeginAllowThreads();
14418 result = (PyObject *)wxFileType_GetExtensions(arg1);
14419
14420 wxPyEndAllowThreads(__tstate);
14421 if (PyErr_Occurred()) SWIG_fail;
14422 }
14423 resultobj = result;
14424 return resultobj;
14425 fail:
14426 return NULL;
14427 }
14428
14429
14430 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14431 PyObject *resultobj;
14432 wxFileType *arg1 = (wxFileType *) 0 ;
14433 wxIcon *result;
14434 PyObject * obj0 = 0 ;
14435 char *kwnames[] = {
14436 (char *) "self", NULL
14437 };
14438
14439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14441 if (SWIG_arg_fail(1)) SWIG_fail;
14442 {
14443 PyThreadState* __tstate = wxPyBeginAllowThreads();
14444 result = (wxIcon *)wxFileType_GetIcon(arg1);
14445
14446 wxPyEndAllowThreads(__tstate);
14447 if (PyErr_Occurred()) SWIG_fail;
14448 }
14449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14450 return resultobj;
14451 fail:
14452 return NULL;
14453 }
14454
14455
14456 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14457 PyObject *resultobj;
14458 wxFileType *arg1 = (wxFileType *) 0 ;
14459 PyObject *result;
14460 PyObject * obj0 = 0 ;
14461 char *kwnames[] = {
14462 (char *) "self", NULL
14463 };
14464
14465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14467 if (SWIG_arg_fail(1)) SWIG_fail;
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14471
14472 wxPyEndAllowThreads(__tstate);
14473 if (PyErr_Occurred()) SWIG_fail;
14474 }
14475 resultobj = result;
14476 return resultobj;
14477 fail:
14478 return NULL;
14479 }
14480
14481
14482 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14483 PyObject *resultobj;
14484 wxFileType *arg1 = (wxFileType *) 0 ;
14485 PyObject *result;
14486 PyObject * obj0 = 0 ;
14487 char *kwnames[] = {
14488 (char *) "self", NULL
14489 };
14490
14491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14493 if (SWIG_arg_fail(1)) SWIG_fail;
14494 {
14495 PyThreadState* __tstate = wxPyBeginAllowThreads();
14496 result = (PyObject *)wxFileType_GetDescription(arg1);
14497
14498 wxPyEndAllowThreads(__tstate);
14499 if (PyErr_Occurred()) SWIG_fail;
14500 }
14501 resultobj = result;
14502 return resultobj;
14503 fail:
14504 return NULL;
14505 }
14506
14507
14508 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14509 PyObject *resultobj;
14510 wxFileType *arg1 = (wxFileType *) 0 ;
14511 wxString *arg2 = 0 ;
14512 wxString const &arg3_defvalue = wxPyEmptyString ;
14513 wxString *arg3 = (wxString *) &arg3_defvalue ;
14514 PyObject *result;
14515 bool temp2 = false ;
14516 bool temp3 = false ;
14517 PyObject * obj0 = 0 ;
14518 PyObject * obj1 = 0 ;
14519 PyObject * obj2 = 0 ;
14520 char *kwnames[] = {
14521 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14522 };
14523
14524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14526 if (SWIG_arg_fail(1)) SWIG_fail;
14527 {
14528 arg2 = wxString_in_helper(obj1);
14529 if (arg2 == NULL) SWIG_fail;
14530 temp2 = true;
14531 }
14532 if (obj2) {
14533 {
14534 arg3 = wxString_in_helper(obj2);
14535 if (arg3 == NULL) SWIG_fail;
14536 temp3 = true;
14537 }
14538 }
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14542
14543 wxPyEndAllowThreads(__tstate);
14544 if (PyErr_Occurred()) SWIG_fail;
14545 }
14546 resultobj = result;
14547 {
14548 if (temp2)
14549 delete arg2;
14550 }
14551 {
14552 if (temp3)
14553 delete arg3;
14554 }
14555 return resultobj;
14556 fail:
14557 {
14558 if (temp2)
14559 delete arg2;
14560 }
14561 {
14562 if (temp3)
14563 delete arg3;
14564 }
14565 return NULL;
14566 }
14567
14568
14569 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14570 PyObject *resultobj;
14571 wxFileType *arg1 = (wxFileType *) 0 ;
14572 wxString *arg2 = 0 ;
14573 wxString const &arg3_defvalue = wxPyEmptyString ;
14574 wxString *arg3 = (wxString *) &arg3_defvalue ;
14575 PyObject *result;
14576 bool temp2 = false ;
14577 bool temp3 = false ;
14578 PyObject * obj0 = 0 ;
14579 PyObject * obj1 = 0 ;
14580 PyObject * obj2 = 0 ;
14581 char *kwnames[] = {
14582 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14583 };
14584
14585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14587 if (SWIG_arg_fail(1)) SWIG_fail;
14588 {
14589 arg2 = wxString_in_helper(obj1);
14590 if (arg2 == NULL) SWIG_fail;
14591 temp2 = true;
14592 }
14593 if (obj2) {
14594 {
14595 arg3 = wxString_in_helper(obj2);
14596 if (arg3 == NULL) SWIG_fail;
14597 temp3 = true;
14598 }
14599 }
14600 {
14601 PyThreadState* __tstate = wxPyBeginAllowThreads();
14602 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14603
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 resultobj = result;
14608 {
14609 if (temp2)
14610 delete arg2;
14611 }
14612 {
14613 if (temp3)
14614 delete arg3;
14615 }
14616 return resultobj;
14617 fail:
14618 {
14619 if (temp2)
14620 delete arg2;
14621 }
14622 {
14623 if (temp3)
14624 delete arg3;
14625 }
14626 return NULL;
14627 }
14628
14629
14630 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14631 PyObject *resultobj;
14632 wxFileType *arg1 = (wxFileType *) 0 ;
14633 wxString *arg2 = 0 ;
14634 wxString const &arg3_defvalue = wxPyEmptyString ;
14635 wxString *arg3 = (wxString *) &arg3_defvalue ;
14636 PyObject *result;
14637 bool temp2 = false ;
14638 bool temp3 = false ;
14639 PyObject * obj0 = 0 ;
14640 PyObject * obj1 = 0 ;
14641 PyObject * obj2 = 0 ;
14642 char *kwnames[] = {
14643 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14644 };
14645
14646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14648 if (SWIG_arg_fail(1)) SWIG_fail;
14649 {
14650 arg2 = wxString_in_helper(obj1);
14651 if (arg2 == NULL) SWIG_fail;
14652 temp2 = true;
14653 }
14654 if (obj2) {
14655 {
14656 arg3 = wxString_in_helper(obj2);
14657 if (arg3 == NULL) SWIG_fail;
14658 temp3 = true;
14659 }
14660 }
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14664
14665 wxPyEndAllowThreads(__tstate);
14666 if (PyErr_Occurred()) SWIG_fail;
14667 }
14668 resultobj = result;
14669 {
14670 if (temp2)
14671 delete arg2;
14672 }
14673 {
14674 if (temp3)
14675 delete arg3;
14676 }
14677 return resultobj;
14678 fail:
14679 {
14680 if (temp2)
14681 delete arg2;
14682 }
14683 {
14684 if (temp3)
14685 delete arg3;
14686 }
14687 return NULL;
14688 }
14689
14690
14691 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14692 PyObject *resultobj;
14693 wxFileType *arg1 = (wxFileType *) 0 ;
14694 wxString *arg2 = 0 ;
14695 wxString *arg3 = 0 ;
14696 bool arg4 = (bool) true ;
14697 bool result;
14698 bool temp2 = false ;
14699 bool temp3 = false ;
14700 PyObject * obj0 = 0 ;
14701 PyObject * obj1 = 0 ;
14702 PyObject * obj2 = 0 ;
14703 PyObject * obj3 = 0 ;
14704 char *kwnames[] = {
14705 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14706 };
14707
14708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14710 if (SWIG_arg_fail(1)) SWIG_fail;
14711 {
14712 arg2 = wxString_in_helper(obj1);
14713 if (arg2 == NULL) SWIG_fail;
14714 temp2 = true;
14715 }
14716 {
14717 arg3 = wxString_in_helper(obj2);
14718 if (arg3 == NULL) SWIG_fail;
14719 temp3 = true;
14720 }
14721 if (obj3) {
14722 {
14723 arg4 = (bool)(SWIG_As_bool(obj3));
14724 if (SWIG_arg_fail(4)) SWIG_fail;
14725 }
14726 }
14727 {
14728 PyThreadState* __tstate = wxPyBeginAllowThreads();
14729 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14730
14731 wxPyEndAllowThreads(__tstate);
14732 if (PyErr_Occurred()) SWIG_fail;
14733 }
14734 {
14735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14736 }
14737 {
14738 if (temp2)
14739 delete arg2;
14740 }
14741 {
14742 if (temp3)
14743 delete arg3;
14744 }
14745 return resultobj;
14746 fail:
14747 {
14748 if (temp2)
14749 delete arg2;
14750 }
14751 {
14752 if (temp3)
14753 delete arg3;
14754 }
14755 return NULL;
14756 }
14757
14758
14759 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14760 PyObject *resultobj;
14761 wxFileType *arg1 = (wxFileType *) 0 ;
14762 wxString const &arg2_defvalue = wxPyEmptyString ;
14763 wxString *arg2 = (wxString *) &arg2_defvalue ;
14764 int arg3 = (int) 0 ;
14765 bool result;
14766 bool temp2 = false ;
14767 PyObject * obj0 = 0 ;
14768 PyObject * obj1 = 0 ;
14769 PyObject * obj2 = 0 ;
14770 char *kwnames[] = {
14771 (char *) "self",(char *) "cmd",(char *) "index", NULL
14772 };
14773
14774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14776 if (SWIG_arg_fail(1)) SWIG_fail;
14777 if (obj1) {
14778 {
14779 arg2 = wxString_in_helper(obj1);
14780 if (arg2 == NULL) SWIG_fail;
14781 temp2 = true;
14782 }
14783 }
14784 if (obj2) {
14785 {
14786 arg3 = (int)(SWIG_As_int(obj2));
14787 if (SWIG_arg_fail(3)) SWIG_fail;
14788 }
14789 }
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14793
14794 wxPyEndAllowThreads(__tstate);
14795 if (PyErr_Occurred()) SWIG_fail;
14796 }
14797 {
14798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14799 }
14800 {
14801 if (temp2)
14802 delete arg2;
14803 }
14804 return resultobj;
14805 fail:
14806 {
14807 if (temp2)
14808 delete arg2;
14809 }
14810 return NULL;
14811 }
14812
14813
14814 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14815 PyObject *resultobj;
14816 wxFileType *arg1 = (wxFileType *) 0 ;
14817 bool result;
14818 PyObject * obj0 = 0 ;
14819 char *kwnames[] = {
14820 (char *) "self", NULL
14821 };
14822
14823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14825 if (SWIG_arg_fail(1)) SWIG_fail;
14826 {
14827 PyThreadState* __tstate = wxPyBeginAllowThreads();
14828 result = (bool)(arg1)->Unassociate();
14829
14830 wxPyEndAllowThreads(__tstate);
14831 if (PyErr_Occurred()) SWIG_fail;
14832 }
14833 {
14834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14835 }
14836 return resultobj;
14837 fail:
14838 return NULL;
14839 }
14840
14841
14842 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14843 PyObject *resultobj;
14844 wxString *arg1 = 0 ;
14845 wxString *arg2 = 0 ;
14846 wxString const &arg3_defvalue = wxPyEmptyString ;
14847 wxString *arg3 = (wxString *) &arg3_defvalue ;
14848 wxString result;
14849 bool temp1 = false ;
14850 bool temp2 = false ;
14851 bool temp3 = false ;
14852 PyObject * obj0 = 0 ;
14853 PyObject * obj1 = 0 ;
14854 PyObject * obj2 = 0 ;
14855 char *kwnames[] = {
14856 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14857 };
14858
14859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14860 {
14861 arg1 = wxString_in_helper(obj0);
14862 if (arg1 == NULL) SWIG_fail;
14863 temp1 = true;
14864 }
14865 {
14866 arg2 = wxString_in_helper(obj1);
14867 if (arg2 == NULL) SWIG_fail;
14868 temp2 = true;
14869 }
14870 if (obj2) {
14871 {
14872 arg3 = wxString_in_helper(obj2);
14873 if (arg3 == NULL) SWIG_fail;
14874 temp3 = true;
14875 }
14876 }
14877 {
14878 PyThreadState* __tstate = wxPyBeginAllowThreads();
14879 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14880
14881 wxPyEndAllowThreads(__tstate);
14882 if (PyErr_Occurred()) SWIG_fail;
14883 }
14884 {
14885 #if wxUSE_UNICODE
14886 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14887 #else
14888 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14889 #endif
14890 }
14891 {
14892 if (temp1)
14893 delete arg1;
14894 }
14895 {
14896 if (temp2)
14897 delete arg2;
14898 }
14899 {
14900 if (temp3)
14901 delete arg3;
14902 }
14903 return resultobj;
14904 fail:
14905 {
14906 if (temp1)
14907 delete arg1;
14908 }
14909 {
14910 if (temp2)
14911 delete arg2;
14912 }
14913 {
14914 if (temp3)
14915 delete arg3;
14916 }
14917 return NULL;
14918 }
14919
14920
14921 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14922 PyObject *obj;
14923 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14924 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14925 Py_INCREF(obj);
14926 return Py_BuildValue((char *)"");
14927 }
14928 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14929 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14930 return 1;
14931 }
14932
14933
14934 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14935 PyObject *pyobj;
14936
14937 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14938 return pyobj;
14939 }
14940
14941
14942 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14943 PyObject *resultobj;
14944 wxString *arg1 = 0 ;
14945 wxString *arg2 = 0 ;
14946 bool result;
14947 bool temp1 = false ;
14948 bool temp2 = false ;
14949 PyObject * obj0 = 0 ;
14950 PyObject * obj1 = 0 ;
14951 char *kwnames[] = {
14952 (char *) "mimeType",(char *) "wildcard", NULL
14953 };
14954
14955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14956 {
14957 arg1 = wxString_in_helper(obj0);
14958 if (arg1 == NULL) SWIG_fail;
14959 temp1 = true;
14960 }
14961 {
14962 arg2 = wxString_in_helper(obj1);
14963 if (arg2 == NULL) SWIG_fail;
14964 temp2 = true;
14965 }
14966 {
14967 PyThreadState* __tstate = wxPyBeginAllowThreads();
14968 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14969
14970 wxPyEndAllowThreads(__tstate);
14971 if (PyErr_Occurred()) SWIG_fail;
14972 }
14973 {
14974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14975 }
14976 {
14977 if (temp1)
14978 delete arg1;
14979 }
14980 {
14981 if (temp2)
14982 delete arg2;
14983 }
14984 return resultobj;
14985 fail:
14986 {
14987 if (temp1)
14988 delete arg1;
14989 }
14990 {
14991 if (temp2)
14992 delete arg2;
14993 }
14994 return NULL;
14995 }
14996
14997
14998 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14999 PyObject *resultobj;
15000 wxMimeTypesManager *result;
15001 char *kwnames[] = {
15002 NULL
15003 };
15004
15005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15006 {
15007 PyThreadState* __tstate = wxPyBeginAllowThreads();
15008 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15009
15010 wxPyEndAllowThreads(__tstate);
15011 if (PyErr_Occurred()) SWIG_fail;
15012 }
15013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15014 return resultobj;
15015 fail:
15016 return NULL;
15017 }
15018
15019
15020 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15021 PyObject *resultobj;
15022 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15023 int arg2 = (int) wxMAILCAP_ALL ;
15024 wxString const &arg3_defvalue = wxPyEmptyString ;
15025 wxString *arg3 = (wxString *) &arg3_defvalue ;
15026 bool temp3 = false ;
15027 PyObject * obj0 = 0 ;
15028 PyObject * obj1 = 0 ;
15029 PyObject * obj2 = 0 ;
15030 char *kwnames[] = {
15031 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15032 };
15033
15034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15036 if (SWIG_arg_fail(1)) SWIG_fail;
15037 if (obj1) {
15038 {
15039 arg2 = (int)(SWIG_As_int(obj1));
15040 if (SWIG_arg_fail(2)) SWIG_fail;
15041 }
15042 }
15043 if (obj2) {
15044 {
15045 arg3 = wxString_in_helper(obj2);
15046 if (arg3 == NULL) SWIG_fail;
15047 temp3 = true;
15048 }
15049 }
15050 {
15051 PyThreadState* __tstate = wxPyBeginAllowThreads();
15052 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15053
15054 wxPyEndAllowThreads(__tstate);
15055 if (PyErr_Occurred()) SWIG_fail;
15056 }
15057 Py_INCREF(Py_None); resultobj = Py_None;
15058 {
15059 if (temp3)
15060 delete arg3;
15061 }
15062 return resultobj;
15063 fail:
15064 {
15065 if (temp3)
15066 delete arg3;
15067 }
15068 return NULL;
15069 }
15070
15071
15072 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15073 PyObject *resultobj;
15074 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15075 PyObject * obj0 = 0 ;
15076 char *kwnames[] = {
15077 (char *) "self", NULL
15078 };
15079
15080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15082 if (SWIG_arg_fail(1)) SWIG_fail;
15083 {
15084 PyThreadState* __tstate = wxPyBeginAllowThreads();
15085 (arg1)->ClearData();
15086
15087 wxPyEndAllowThreads(__tstate);
15088 if (PyErr_Occurred()) SWIG_fail;
15089 }
15090 Py_INCREF(Py_None); resultobj = Py_None;
15091 return resultobj;
15092 fail:
15093 return NULL;
15094 }
15095
15096
15097 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15098 PyObject *resultobj;
15099 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15100 wxString *arg2 = 0 ;
15101 wxFileType *result;
15102 bool temp2 = false ;
15103 PyObject * obj0 = 0 ;
15104 PyObject * obj1 = 0 ;
15105 char *kwnames[] = {
15106 (char *) "self",(char *) "ext", NULL
15107 };
15108
15109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15111 if (SWIG_arg_fail(1)) SWIG_fail;
15112 {
15113 arg2 = wxString_in_helper(obj1);
15114 if (arg2 == NULL) SWIG_fail;
15115 temp2 = true;
15116 }
15117 {
15118 PyThreadState* __tstate = wxPyBeginAllowThreads();
15119 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15120
15121 wxPyEndAllowThreads(__tstate);
15122 if (PyErr_Occurred()) SWIG_fail;
15123 }
15124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15125 {
15126 if (temp2)
15127 delete arg2;
15128 }
15129 return resultobj;
15130 fail:
15131 {
15132 if (temp2)
15133 delete arg2;
15134 }
15135 return NULL;
15136 }
15137
15138
15139 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15140 PyObject *resultobj;
15141 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15142 wxString *arg2 = 0 ;
15143 wxFileType *result;
15144 bool temp2 = false ;
15145 PyObject * obj0 = 0 ;
15146 PyObject * obj1 = 0 ;
15147 char *kwnames[] = {
15148 (char *) "self",(char *) "mimeType", NULL
15149 };
15150
15151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15153 if (SWIG_arg_fail(1)) SWIG_fail;
15154 {
15155 arg2 = wxString_in_helper(obj1);
15156 if (arg2 == NULL) SWIG_fail;
15157 temp2 = true;
15158 }
15159 {
15160 PyThreadState* __tstate = wxPyBeginAllowThreads();
15161 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15162
15163 wxPyEndAllowThreads(__tstate);
15164 if (PyErr_Occurred()) SWIG_fail;
15165 }
15166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15167 {
15168 if (temp2)
15169 delete arg2;
15170 }
15171 return resultobj;
15172 fail:
15173 {
15174 if (temp2)
15175 delete arg2;
15176 }
15177 return NULL;
15178 }
15179
15180
15181 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15182 PyObject *resultobj;
15183 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15184 wxString *arg2 = 0 ;
15185 bool arg3 = (bool) false ;
15186 bool result;
15187 bool temp2 = false ;
15188 PyObject * obj0 = 0 ;
15189 PyObject * obj1 = 0 ;
15190 PyObject * obj2 = 0 ;
15191 char *kwnames[] = {
15192 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15193 };
15194
15195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15197 if (SWIG_arg_fail(1)) SWIG_fail;
15198 {
15199 arg2 = wxString_in_helper(obj1);
15200 if (arg2 == NULL) SWIG_fail;
15201 temp2 = true;
15202 }
15203 if (obj2) {
15204 {
15205 arg3 = (bool)(SWIG_As_bool(obj2));
15206 if (SWIG_arg_fail(3)) SWIG_fail;
15207 }
15208 }
15209 {
15210 PyThreadState* __tstate = wxPyBeginAllowThreads();
15211 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15212
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 {
15217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15218 }
15219 {
15220 if (temp2)
15221 delete arg2;
15222 }
15223 return resultobj;
15224 fail:
15225 {
15226 if (temp2)
15227 delete arg2;
15228 }
15229 return NULL;
15230 }
15231
15232
15233 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15234 PyObject *resultobj;
15235 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15236 wxString *arg2 = 0 ;
15237 bool result;
15238 bool temp2 = false ;
15239 PyObject * obj0 = 0 ;
15240 PyObject * obj1 = 0 ;
15241 char *kwnames[] = {
15242 (char *) "self",(char *) "filename", NULL
15243 };
15244
15245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15247 if (SWIG_arg_fail(1)) SWIG_fail;
15248 {
15249 arg2 = wxString_in_helper(obj1);
15250 if (arg2 == NULL) SWIG_fail;
15251 temp2 = true;
15252 }
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15256
15257 wxPyEndAllowThreads(__tstate);
15258 if (PyErr_Occurred()) SWIG_fail;
15259 }
15260 {
15261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15262 }
15263 {
15264 if (temp2)
15265 delete arg2;
15266 }
15267 return resultobj;
15268 fail:
15269 {
15270 if (temp2)
15271 delete arg2;
15272 }
15273 return NULL;
15274 }
15275
15276
15277 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15278 PyObject *resultobj;
15279 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15280 PyObject *result;
15281 PyObject * obj0 = 0 ;
15282 char *kwnames[] = {
15283 (char *) "self", NULL
15284 };
15285
15286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15288 if (SWIG_arg_fail(1)) SWIG_fail;
15289 {
15290 PyThreadState* __tstate = wxPyBeginAllowThreads();
15291 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15292
15293 wxPyEndAllowThreads(__tstate);
15294 if (PyErr_Occurred()) SWIG_fail;
15295 }
15296 resultobj = result;
15297 return resultobj;
15298 fail:
15299 return NULL;
15300 }
15301
15302
15303 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15304 PyObject *resultobj;
15305 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15306 wxFileTypeInfo *arg2 = 0 ;
15307 PyObject * obj0 = 0 ;
15308 PyObject * obj1 = 0 ;
15309 char *kwnames[] = {
15310 (char *) "self",(char *) "ft", NULL
15311 };
15312
15313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15315 if (SWIG_arg_fail(1)) SWIG_fail;
15316 {
15317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15318 if (SWIG_arg_fail(2)) SWIG_fail;
15319 if (arg2 == NULL) {
15320 SWIG_null_ref("wxFileTypeInfo");
15321 }
15322 if (SWIG_arg_fail(2)) SWIG_fail;
15323 }
15324 {
15325 PyThreadState* __tstate = wxPyBeginAllowThreads();
15326 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15327
15328 wxPyEndAllowThreads(__tstate);
15329 if (PyErr_Occurred()) SWIG_fail;
15330 }
15331 Py_INCREF(Py_None); resultobj = Py_None;
15332 return resultobj;
15333 fail:
15334 return NULL;
15335 }
15336
15337
15338 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15339 PyObject *resultobj;
15340 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15341 wxFileTypeInfo *arg2 = 0 ;
15342 wxFileType *result;
15343 PyObject * obj0 = 0 ;
15344 PyObject * obj1 = 0 ;
15345 char *kwnames[] = {
15346 (char *) "self",(char *) "ftInfo", NULL
15347 };
15348
15349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15351 if (SWIG_arg_fail(1)) SWIG_fail;
15352 {
15353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15354 if (SWIG_arg_fail(2)) SWIG_fail;
15355 if (arg2 == NULL) {
15356 SWIG_null_ref("wxFileTypeInfo");
15357 }
15358 if (SWIG_arg_fail(2)) SWIG_fail;
15359 }
15360 {
15361 PyThreadState* __tstate = wxPyBeginAllowThreads();
15362 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15363
15364 wxPyEndAllowThreads(__tstate);
15365 if (PyErr_Occurred()) SWIG_fail;
15366 }
15367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15368 return resultobj;
15369 fail:
15370 return NULL;
15371 }
15372
15373
15374 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15375 PyObject *resultobj;
15376 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15377 wxFileType *arg2 = (wxFileType *) 0 ;
15378 bool result;
15379 PyObject * obj0 = 0 ;
15380 PyObject * obj1 = 0 ;
15381 char *kwnames[] = {
15382 (char *) "self",(char *) "ft", NULL
15383 };
15384
15385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15387 if (SWIG_arg_fail(1)) SWIG_fail;
15388 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15389 if (SWIG_arg_fail(2)) SWIG_fail;
15390 {
15391 PyThreadState* __tstate = wxPyBeginAllowThreads();
15392 result = (bool)(arg1)->Unassociate(arg2);
15393
15394 wxPyEndAllowThreads(__tstate);
15395 if (PyErr_Occurred()) SWIG_fail;
15396 }
15397 {
15398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15399 }
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15407 PyObject *resultobj;
15408 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15409 PyObject * obj0 = 0 ;
15410 char *kwnames[] = {
15411 (char *) "self", NULL
15412 };
15413
15414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15416 if (SWIG_arg_fail(1)) SWIG_fail;
15417 {
15418 PyThreadState* __tstate = wxPyBeginAllowThreads();
15419 delete arg1;
15420
15421 wxPyEndAllowThreads(__tstate);
15422 if (PyErr_Occurred()) SWIG_fail;
15423 }
15424 Py_INCREF(Py_None); resultobj = Py_None;
15425 return resultobj;
15426 fail:
15427 return NULL;
15428 }
15429
15430
15431 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15432 PyObject *obj;
15433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15434 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15435 Py_INCREF(obj);
15436 return Py_BuildValue((char *)"");
15437 }
15438 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15439 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15440 return 1;
15441 }
15442
15443
15444 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15445 PyObject *pyobj;
15446
15447 {
15448 #if wxUSE_UNICODE
15449 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15450 #else
15451 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15452 #endif
15453 }
15454 return pyobj;
15455 }
15456
15457
15458 static int _wrap_ART_MENU_set(PyObject *) {
15459 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15460 return 1;
15461 }
15462
15463
15464 static PyObject *_wrap_ART_MENU_get(void) {
15465 PyObject *pyobj;
15466
15467 {
15468 #if wxUSE_UNICODE
15469 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15470 #else
15471 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15472 #endif
15473 }
15474 return pyobj;
15475 }
15476
15477
15478 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15479 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15480 return 1;
15481 }
15482
15483
15484 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15485 PyObject *pyobj;
15486
15487 {
15488 #if wxUSE_UNICODE
15489 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15490 #else
15491 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15492 #endif
15493 }
15494 return pyobj;
15495 }
15496
15497
15498 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15499 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15500 return 1;
15501 }
15502
15503
15504 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15505 PyObject *pyobj;
15506
15507 {
15508 #if wxUSE_UNICODE
15509 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15510 #else
15511 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15512 #endif
15513 }
15514 return pyobj;
15515 }
15516
15517
15518 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15519 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15520 return 1;
15521 }
15522
15523
15524 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15525 PyObject *pyobj;
15526
15527 {
15528 #if wxUSE_UNICODE
15529 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15530 #else
15531 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15532 #endif
15533 }
15534 return pyobj;
15535 }
15536
15537
15538 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15539 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15540 return 1;
15541 }
15542
15543
15544 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15545 PyObject *pyobj;
15546
15547 {
15548 #if wxUSE_UNICODE
15549 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15550 #else
15551 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15552 #endif
15553 }
15554 return pyobj;
15555 }
15556
15557
15558 static int _wrap_ART_BUTTON_set(PyObject *) {
15559 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15560 return 1;
15561 }
15562
15563
15564 static PyObject *_wrap_ART_BUTTON_get(void) {
15565 PyObject *pyobj;
15566
15567 {
15568 #if wxUSE_UNICODE
15569 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15570 #else
15571 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15572 #endif
15573 }
15574 return pyobj;
15575 }
15576
15577
15578 static int _wrap_ART_OTHER_set(PyObject *) {
15579 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15580 return 1;
15581 }
15582
15583
15584 static PyObject *_wrap_ART_OTHER_get(void) {
15585 PyObject *pyobj;
15586
15587 {
15588 #if wxUSE_UNICODE
15589 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15590 #else
15591 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15592 #endif
15593 }
15594 return pyobj;
15595 }
15596
15597
15598 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15599 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15600 return 1;
15601 }
15602
15603
15604 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15605 PyObject *pyobj;
15606
15607 {
15608 #if wxUSE_UNICODE
15609 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15610 #else
15611 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15612 #endif
15613 }
15614 return pyobj;
15615 }
15616
15617
15618 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15619 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15620 return 1;
15621 }
15622
15623
15624 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15625 PyObject *pyobj;
15626
15627 {
15628 #if wxUSE_UNICODE
15629 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15630 #else
15631 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15632 #endif
15633 }
15634 return pyobj;
15635 }
15636
15637
15638 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15639 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15640 return 1;
15641 }
15642
15643
15644 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15645 PyObject *pyobj;
15646
15647 {
15648 #if wxUSE_UNICODE
15649 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15650 #else
15651 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15652 #endif
15653 }
15654 return pyobj;
15655 }
15656
15657
15658 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15659 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15660 return 1;
15661 }
15662
15663
15664 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15665 PyObject *pyobj;
15666
15667 {
15668 #if wxUSE_UNICODE
15669 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15670 #else
15671 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15672 #endif
15673 }
15674 return pyobj;
15675 }
15676
15677
15678 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15679 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15680 return 1;
15681 }
15682
15683
15684 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15685 PyObject *pyobj;
15686
15687 {
15688 #if wxUSE_UNICODE
15689 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15690 #else
15691 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15692 #endif
15693 }
15694 return pyobj;
15695 }
15696
15697
15698 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15699 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15700 return 1;
15701 }
15702
15703
15704 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15705 PyObject *pyobj;
15706
15707 {
15708 #if wxUSE_UNICODE
15709 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15710 #else
15711 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15712 #endif
15713 }
15714 return pyobj;
15715 }
15716
15717
15718 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15719 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15720 return 1;
15721 }
15722
15723
15724 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15725 PyObject *pyobj;
15726
15727 {
15728 #if wxUSE_UNICODE
15729 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15730 #else
15731 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15732 #endif
15733 }
15734 return pyobj;
15735 }
15736
15737
15738 static int _wrap_ART_GO_BACK_set(PyObject *) {
15739 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15740 return 1;
15741 }
15742
15743
15744 static PyObject *_wrap_ART_GO_BACK_get(void) {
15745 PyObject *pyobj;
15746
15747 {
15748 #if wxUSE_UNICODE
15749 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15750 #else
15751 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15752 #endif
15753 }
15754 return pyobj;
15755 }
15756
15757
15758 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15759 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15760 return 1;
15761 }
15762
15763
15764 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15765 PyObject *pyobj;
15766
15767 {
15768 #if wxUSE_UNICODE
15769 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15770 #else
15771 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15772 #endif
15773 }
15774 return pyobj;
15775 }
15776
15777
15778 static int _wrap_ART_GO_UP_set(PyObject *) {
15779 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15780 return 1;
15781 }
15782
15783
15784 static PyObject *_wrap_ART_GO_UP_get(void) {
15785 PyObject *pyobj;
15786
15787 {
15788 #if wxUSE_UNICODE
15789 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15790 #else
15791 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15792 #endif
15793 }
15794 return pyobj;
15795 }
15796
15797
15798 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15799 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15800 return 1;
15801 }
15802
15803
15804 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15805 PyObject *pyobj;
15806
15807 {
15808 #if wxUSE_UNICODE
15809 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15810 #else
15811 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15812 #endif
15813 }
15814 return pyobj;
15815 }
15816
15817
15818 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15819 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15820 return 1;
15821 }
15822
15823
15824 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15825 PyObject *pyobj;
15826
15827 {
15828 #if wxUSE_UNICODE
15829 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15830 #else
15831 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15832 #endif
15833 }
15834 return pyobj;
15835 }
15836
15837
15838 static int _wrap_ART_GO_HOME_set(PyObject *) {
15839 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15840 return 1;
15841 }
15842
15843
15844 static PyObject *_wrap_ART_GO_HOME_get(void) {
15845 PyObject *pyobj;
15846
15847 {
15848 #if wxUSE_UNICODE
15849 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15850 #else
15851 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15852 #endif
15853 }
15854 return pyobj;
15855 }
15856
15857
15858 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15859 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15860 return 1;
15861 }
15862
15863
15864 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15865 PyObject *pyobj;
15866
15867 {
15868 #if wxUSE_UNICODE
15869 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15870 #else
15871 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15872 #endif
15873 }
15874 return pyobj;
15875 }
15876
15877
15878 static int _wrap_ART_PRINT_set(PyObject *) {
15879 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15880 return 1;
15881 }
15882
15883
15884 static PyObject *_wrap_ART_PRINT_get(void) {
15885 PyObject *pyobj;
15886
15887 {
15888 #if wxUSE_UNICODE
15889 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15890 #else
15891 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15892 #endif
15893 }
15894 return pyobj;
15895 }
15896
15897
15898 static int _wrap_ART_HELP_set(PyObject *) {
15899 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15900 return 1;
15901 }
15902
15903
15904 static PyObject *_wrap_ART_HELP_get(void) {
15905 PyObject *pyobj;
15906
15907 {
15908 #if wxUSE_UNICODE
15909 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15910 #else
15911 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15912 #endif
15913 }
15914 return pyobj;
15915 }
15916
15917
15918 static int _wrap_ART_TIP_set(PyObject *) {
15919 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15920 return 1;
15921 }
15922
15923
15924 static PyObject *_wrap_ART_TIP_get(void) {
15925 PyObject *pyobj;
15926
15927 {
15928 #if wxUSE_UNICODE
15929 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15930 #else
15931 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15932 #endif
15933 }
15934 return pyobj;
15935 }
15936
15937
15938 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15939 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15940 return 1;
15941 }
15942
15943
15944 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15945 PyObject *pyobj;
15946
15947 {
15948 #if wxUSE_UNICODE
15949 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15950 #else
15951 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15952 #endif
15953 }
15954 return pyobj;
15955 }
15956
15957
15958 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15959 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15960 return 1;
15961 }
15962
15963
15964 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15965 PyObject *pyobj;
15966
15967 {
15968 #if wxUSE_UNICODE
15969 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15970 #else
15971 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15972 #endif
15973 }
15974 return pyobj;
15975 }
15976
15977
15978 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15979 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15980 return 1;
15981 }
15982
15983
15984 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15985 PyObject *pyobj;
15986
15987 {
15988 #if wxUSE_UNICODE
15989 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15990 #else
15991 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15992 #endif
15993 }
15994 return pyobj;
15995 }
15996
15997
15998 static int _wrap_ART_HARDDISK_set(PyObject *) {
15999 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16000 return 1;
16001 }
16002
16003
16004 static PyObject *_wrap_ART_HARDDISK_get(void) {
16005 PyObject *pyobj;
16006
16007 {
16008 #if wxUSE_UNICODE
16009 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16010 #else
16011 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16012 #endif
16013 }
16014 return pyobj;
16015 }
16016
16017
16018 static int _wrap_ART_FLOPPY_set(PyObject *) {
16019 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16020 return 1;
16021 }
16022
16023
16024 static PyObject *_wrap_ART_FLOPPY_get(void) {
16025 PyObject *pyobj;
16026
16027 {
16028 #if wxUSE_UNICODE
16029 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16030 #else
16031 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16032 #endif
16033 }
16034 return pyobj;
16035 }
16036
16037
16038 static int _wrap_ART_CDROM_set(PyObject *) {
16039 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16040 return 1;
16041 }
16042
16043
16044 static PyObject *_wrap_ART_CDROM_get(void) {
16045 PyObject *pyobj;
16046
16047 {
16048 #if wxUSE_UNICODE
16049 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16050 #else
16051 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16052 #endif
16053 }
16054 return pyobj;
16055 }
16056
16057
16058 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16059 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16060 return 1;
16061 }
16062
16063
16064 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16065 PyObject *pyobj;
16066
16067 {
16068 #if wxUSE_UNICODE
16069 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16070 #else
16071 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16072 #endif
16073 }
16074 return pyobj;
16075 }
16076
16077
16078 static int _wrap_ART_FOLDER_set(PyObject *) {
16079 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16080 return 1;
16081 }
16082
16083
16084 static PyObject *_wrap_ART_FOLDER_get(void) {
16085 PyObject *pyobj;
16086
16087 {
16088 #if wxUSE_UNICODE
16089 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16090 #else
16091 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16092 #endif
16093 }
16094 return pyobj;
16095 }
16096
16097
16098 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16099 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16100 return 1;
16101 }
16102
16103
16104 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16105 PyObject *pyobj;
16106
16107 {
16108 #if wxUSE_UNICODE
16109 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16110 #else
16111 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16112 #endif
16113 }
16114 return pyobj;
16115 }
16116
16117
16118 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16119 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16120 return 1;
16121 }
16122
16123
16124 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16125 PyObject *pyobj;
16126
16127 {
16128 #if wxUSE_UNICODE
16129 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16130 #else
16131 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16132 #endif
16133 }
16134 return pyobj;
16135 }
16136
16137
16138 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16139 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16140 return 1;
16141 }
16142
16143
16144 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16145 PyObject *pyobj;
16146
16147 {
16148 #if wxUSE_UNICODE
16149 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16150 #else
16151 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16152 #endif
16153 }
16154 return pyobj;
16155 }
16156
16157
16158 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16159 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16160 return 1;
16161 }
16162
16163
16164 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16165 PyObject *pyobj;
16166
16167 {
16168 #if wxUSE_UNICODE
16169 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16170 #else
16171 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16172 #endif
16173 }
16174 return pyobj;
16175 }
16176
16177
16178 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16179 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16180 return 1;
16181 }
16182
16183
16184 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16185 PyObject *pyobj;
16186
16187 {
16188 #if wxUSE_UNICODE
16189 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16190 #else
16191 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16192 #endif
16193 }
16194 return pyobj;
16195 }
16196
16197
16198 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16199 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16200 return 1;
16201 }
16202
16203
16204 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16205 PyObject *pyobj;
16206
16207 {
16208 #if wxUSE_UNICODE
16209 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16210 #else
16211 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16212 #endif
16213 }
16214 return pyobj;
16215 }
16216
16217
16218 static int _wrap_ART_ERROR_set(PyObject *) {
16219 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16220 return 1;
16221 }
16222
16223
16224 static PyObject *_wrap_ART_ERROR_get(void) {
16225 PyObject *pyobj;
16226
16227 {
16228 #if wxUSE_UNICODE
16229 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16230 #else
16231 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16232 #endif
16233 }
16234 return pyobj;
16235 }
16236
16237
16238 static int _wrap_ART_QUESTION_set(PyObject *) {
16239 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16240 return 1;
16241 }
16242
16243
16244 static PyObject *_wrap_ART_QUESTION_get(void) {
16245 PyObject *pyobj;
16246
16247 {
16248 #if wxUSE_UNICODE
16249 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16250 #else
16251 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16252 #endif
16253 }
16254 return pyobj;
16255 }
16256
16257
16258 static int _wrap_ART_WARNING_set(PyObject *) {
16259 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16260 return 1;
16261 }
16262
16263
16264 static PyObject *_wrap_ART_WARNING_get(void) {
16265 PyObject *pyobj;
16266
16267 {
16268 #if wxUSE_UNICODE
16269 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16270 #else
16271 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16272 #endif
16273 }
16274 return pyobj;
16275 }
16276
16277
16278 static int _wrap_ART_INFORMATION_set(PyObject *) {
16279 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16280 return 1;
16281 }
16282
16283
16284 static PyObject *_wrap_ART_INFORMATION_get(void) {
16285 PyObject *pyobj;
16286
16287 {
16288 #if wxUSE_UNICODE
16289 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16290 #else
16291 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16292 #endif
16293 }
16294 return pyobj;
16295 }
16296
16297
16298 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16299 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16300 return 1;
16301 }
16302
16303
16304 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16305 PyObject *pyobj;
16306
16307 {
16308 #if wxUSE_UNICODE
16309 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16310 #else
16311 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16312 #endif
16313 }
16314 return pyobj;
16315 }
16316
16317
16318 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16319 PyObject *resultobj;
16320 wxPyArtProvider *result;
16321 char *kwnames[] = {
16322 NULL
16323 };
16324
16325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16326 {
16327 if (!wxPyCheckForApp()) SWIG_fail;
16328 PyThreadState* __tstate = wxPyBeginAllowThreads();
16329 result = (wxPyArtProvider *)new wxPyArtProvider();
16330
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16342 PyObject *resultobj;
16343 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16344 PyObject *arg2 = (PyObject *) 0 ;
16345 PyObject *arg3 = (PyObject *) 0 ;
16346 PyObject * obj0 = 0 ;
16347 PyObject * obj1 = 0 ;
16348 PyObject * obj2 = 0 ;
16349 char *kwnames[] = {
16350 (char *) "self",(char *) "self",(char *) "_class", NULL
16351 };
16352
16353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16355 if (SWIG_arg_fail(1)) SWIG_fail;
16356 arg2 = obj1;
16357 arg3 = obj2;
16358 {
16359 PyThreadState* __tstate = wxPyBeginAllowThreads();
16360 (arg1)->_setCallbackInfo(arg2,arg3);
16361
16362 wxPyEndAllowThreads(__tstate);
16363 if (PyErr_Occurred()) SWIG_fail;
16364 }
16365 Py_INCREF(Py_None); resultobj = Py_None;
16366 return resultobj;
16367 fail:
16368 return NULL;
16369 }
16370
16371
16372 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16373 PyObject *resultobj;
16374 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16375 PyObject * obj0 = 0 ;
16376 char *kwnames[] = {
16377 (char *) "provider", NULL
16378 };
16379
16380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16382 if (SWIG_arg_fail(1)) SWIG_fail;
16383 {
16384 PyThreadState* __tstate = wxPyBeginAllowThreads();
16385 wxPyArtProvider::PushProvider(arg1);
16386
16387 wxPyEndAllowThreads(__tstate);
16388 if (PyErr_Occurred()) SWIG_fail;
16389 }
16390 Py_INCREF(Py_None); resultobj = Py_None;
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj;
16399 bool result;
16400 char *kwnames[] = {
16401 NULL
16402 };
16403
16404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16405 {
16406 PyThreadState* __tstate = wxPyBeginAllowThreads();
16407 result = (bool)wxPyArtProvider::PopProvider();
16408
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 {
16413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16414 }
16415 return resultobj;
16416 fail:
16417 return NULL;
16418 }
16419
16420
16421 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj;
16423 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16424 bool result;
16425 PyObject * obj0 = 0 ;
16426 char *kwnames[] = {
16427 (char *) "provider", NULL
16428 };
16429
16430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16432 if (SWIG_arg_fail(1)) SWIG_fail;
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16436
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 {
16441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16442 }
16443 return resultobj;
16444 fail:
16445 return NULL;
16446 }
16447
16448
16449 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16450 PyObject *resultobj;
16451 wxString *arg1 = 0 ;
16452 wxString const &arg2_defvalue = wxPyART_OTHER ;
16453 wxString *arg2 = (wxString *) &arg2_defvalue ;
16454 wxSize const &arg3_defvalue = wxDefaultSize ;
16455 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16456 wxBitmap result;
16457 bool temp1 = false ;
16458 bool temp2 = false ;
16459 wxSize temp3 ;
16460 PyObject * obj0 = 0 ;
16461 PyObject * obj1 = 0 ;
16462 PyObject * obj2 = 0 ;
16463 char *kwnames[] = {
16464 (char *) "id",(char *) "client",(char *) "size", NULL
16465 };
16466
16467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16468 {
16469 arg1 = wxString_in_helper(obj0);
16470 if (arg1 == NULL) SWIG_fail;
16471 temp1 = true;
16472 }
16473 if (obj1) {
16474 {
16475 arg2 = wxString_in_helper(obj1);
16476 if (arg2 == NULL) SWIG_fail;
16477 temp2 = true;
16478 }
16479 }
16480 if (obj2) {
16481 {
16482 arg3 = &temp3;
16483 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16484 }
16485 }
16486 {
16487 if (!wxPyCheckForApp()) SWIG_fail;
16488 PyThreadState* __tstate = wxPyBeginAllowThreads();
16489 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16490
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 {
16495 wxBitmap * resultptr;
16496 resultptr = new wxBitmap((wxBitmap &)(result));
16497 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16498 }
16499 {
16500 if (temp1)
16501 delete arg1;
16502 }
16503 {
16504 if (temp2)
16505 delete arg2;
16506 }
16507 return resultobj;
16508 fail:
16509 {
16510 if (temp1)
16511 delete arg1;
16512 }
16513 {
16514 if (temp2)
16515 delete arg2;
16516 }
16517 return NULL;
16518 }
16519
16520
16521 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16522 PyObject *resultobj;
16523 wxString *arg1 = 0 ;
16524 wxString const &arg2_defvalue = wxPyART_OTHER ;
16525 wxString *arg2 = (wxString *) &arg2_defvalue ;
16526 wxSize const &arg3_defvalue = wxDefaultSize ;
16527 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16528 wxIcon result;
16529 bool temp1 = false ;
16530 bool temp2 = false ;
16531 wxSize temp3 ;
16532 PyObject * obj0 = 0 ;
16533 PyObject * obj1 = 0 ;
16534 PyObject * obj2 = 0 ;
16535 char *kwnames[] = {
16536 (char *) "id",(char *) "client",(char *) "size", NULL
16537 };
16538
16539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16540 {
16541 arg1 = wxString_in_helper(obj0);
16542 if (arg1 == NULL) SWIG_fail;
16543 temp1 = true;
16544 }
16545 if (obj1) {
16546 {
16547 arg2 = wxString_in_helper(obj1);
16548 if (arg2 == NULL) SWIG_fail;
16549 temp2 = true;
16550 }
16551 }
16552 if (obj2) {
16553 {
16554 arg3 = &temp3;
16555 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16556 }
16557 }
16558 {
16559 if (!wxPyCheckForApp()) SWIG_fail;
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16562
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 {
16567 wxIcon * resultptr;
16568 resultptr = new wxIcon((wxIcon &)(result));
16569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16570 }
16571 {
16572 if (temp1)
16573 delete arg1;
16574 }
16575 {
16576 if (temp2)
16577 delete arg2;
16578 }
16579 return resultobj;
16580 fail:
16581 {
16582 if (temp1)
16583 delete arg1;
16584 }
16585 {
16586 if (temp2)
16587 delete arg2;
16588 }
16589 return NULL;
16590 }
16591
16592
16593 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16594 PyObject *resultobj;
16595 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16596 PyObject * obj0 = 0 ;
16597 char *kwnames[] = {
16598 (char *) "self", NULL
16599 };
16600
16601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16603 if (SWIG_arg_fail(1)) SWIG_fail;
16604 {
16605 PyThreadState* __tstate = wxPyBeginAllowThreads();
16606 wxPyArtProvider_Destroy(arg1);
16607
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 Py_INCREF(Py_None); resultobj = Py_None;
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16619 PyObject *obj;
16620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16621 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16622 Py_INCREF(obj);
16623 return Py_BuildValue((char *)"");
16624 }
16625 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16626 PyObject *resultobj;
16627 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16628 PyObject * obj0 = 0 ;
16629 char *kwnames[] = {
16630 (char *) "self", NULL
16631 };
16632
16633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16635 if (SWIG_arg_fail(1)) SWIG_fail;
16636 {
16637 PyThreadState* __tstate = wxPyBeginAllowThreads();
16638 delete arg1;
16639
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 Py_INCREF(Py_None); resultobj = Py_None;
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj;
16652 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16653 wxConfigBase *result;
16654 PyObject * obj0 = 0 ;
16655 char *kwnames[] = {
16656 (char *) "config", NULL
16657 };
16658
16659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16661 if (SWIG_arg_fail(1)) SWIG_fail;
16662 {
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16665
16666 wxPyEndAllowThreads(__tstate);
16667 if (PyErr_Occurred()) SWIG_fail;
16668 }
16669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16670 return resultobj;
16671 fail:
16672 return NULL;
16673 }
16674
16675
16676 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16677 PyObject *resultobj;
16678 bool arg1 = (bool) true ;
16679 wxConfigBase *result;
16680 PyObject * obj0 = 0 ;
16681 char *kwnames[] = {
16682 (char *) "createOnDemand", NULL
16683 };
16684
16685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16686 if (obj0) {
16687 {
16688 arg1 = (bool)(SWIG_As_bool(obj0));
16689 if (SWIG_arg_fail(1)) SWIG_fail;
16690 }
16691 }
16692 {
16693 PyThreadState* __tstate = wxPyBeginAllowThreads();
16694 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16695
16696 wxPyEndAllowThreads(__tstate);
16697 if (PyErr_Occurred()) SWIG_fail;
16698 }
16699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16700 return resultobj;
16701 fail:
16702 return NULL;
16703 }
16704
16705
16706 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16707 PyObject *resultobj;
16708 wxConfigBase *result;
16709 char *kwnames[] = {
16710 NULL
16711 };
16712
16713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16714 {
16715 PyThreadState* __tstate = wxPyBeginAllowThreads();
16716 result = (wxConfigBase *)wxConfigBase::Create();
16717
16718 wxPyEndAllowThreads(__tstate);
16719 if (PyErr_Occurred()) SWIG_fail;
16720 }
16721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16722 return resultobj;
16723 fail:
16724 return NULL;
16725 }
16726
16727
16728 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16729 PyObject *resultobj;
16730 char *kwnames[] = {
16731 NULL
16732 };
16733
16734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 wxConfigBase::DontCreateOnDemand();
16738
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 Py_INCREF(Py_None); resultobj = Py_None;
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj;
16751 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16752 wxString *arg2 = 0 ;
16753 bool temp2 = false ;
16754 PyObject * obj0 = 0 ;
16755 PyObject * obj1 = 0 ;
16756 char *kwnames[] = {
16757 (char *) "self",(char *) "path", NULL
16758 };
16759
16760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16762 if (SWIG_arg_fail(1)) SWIG_fail;
16763 {
16764 arg2 = wxString_in_helper(obj1);
16765 if (arg2 == NULL) SWIG_fail;
16766 temp2 = true;
16767 }
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 (arg1)->SetPath((wxString const &)*arg2);
16771
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 Py_INCREF(Py_None); resultobj = Py_None;
16776 {
16777 if (temp2)
16778 delete arg2;
16779 }
16780 return resultobj;
16781 fail:
16782 {
16783 if (temp2)
16784 delete arg2;
16785 }
16786 return NULL;
16787 }
16788
16789
16790 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16791 PyObject *resultobj;
16792 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16793 wxString *result;
16794 PyObject * obj0 = 0 ;
16795 char *kwnames[] = {
16796 (char *) "self", NULL
16797 };
16798
16799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16801 if (SWIG_arg_fail(1)) SWIG_fail;
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 {
16805 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16806 result = (wxString *) &_result_ref;
16807 }
16808
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 {
16813 #if wxUSE_UNICODE
16814 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16815 #else
16816 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16817 #endif
16818 }
16819 return resultobj;
16820 fail:
16821 return NULL;
16822 }
16823
16824
16825 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16826 PyObject *resultobj;
16827 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16828 PyObject *result;
16829 PyObject * obj0 = 0 ;
16830 char *kwnames[] = {
16831 (char *) "self", NULL
16832 };
16833
16834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16836 if (SWIG_arg_fail(1)) SWIG_fail;
16837 {
16838 PyThreadState* __tstate = wxPyBeginAllowThreads();
16839 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16840
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = result;
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj;
16853 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16854 long arg2 ;
16855 PyObject *result;
16856 PyObject * obj0 = 0 ;
16857 PyObject * obj1 = 0 ;
16858 char *kwnames[] = {
16859 (char *) "self",(char *) "index", NULL
16860 };
16861
16862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16864 if (SWIG_arg_fail(1)) SWIG_fail;
16865 {
16866 arg2 = (long)(SWIG_As_long(obj1));
16867 if (SWIG_arg_fail(2)) SWIG_fail;
16868 }
16869 {
16870 PyThreadState* __tstate = wxPyBeginAllowThreads();
16871 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16872
16873 wxPyEndAllowThreads(__tstate);
16874 if (PyErr_Occurred()) SWIG_fail;
16875 }
16876 resultobj = result;
16877 return resultobj;
16878 fail:
16879 return NULL;
16880 }
16881
16882
16883 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16884 PyObject *resultobj;
16885 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16886 PyObject *result;
16887 PyObject * obj0 = 0 ;
16888 char *kwnames[] = {
16889 (char *) "self", NULL
16890 };
16891
16892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16894 if (SWIG_arg_fail(1)) SWIG_fail;
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16898
16899 wxPyEndAllowThreads(__tstate);
16900 if (PyErr_Occurred()) SWIG_fail;
16901 }
16902 resultobj = result;
16903 return resultobj;
16904 fail:
16905 return NULL;
16906 }
16907
16908
16909 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16910 PyObject *resultobj;
16911 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16912 long arg2 ;
16913 PyObject *result;
16914 PyObject * obj0 = 0 ;
16915 PyObject * obj1 = 0 ;
16916 char *kwnames[] = {
16917 (char *) "self",(char *) "index", NULL
16918 };
16919
16920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16922 if (SWIG_arg_fail(1)) SWIG_fail;
16923 {
16924 arg2 = (long)(SWIG_As_long(obj1));
16925 if (SWIG_arg_fail(2)) SWIG_fail;
16926 }
16927 {
16928 PyThreadState* __tstate = wxPyBeginAllowThreads();
16929 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16930
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 resultobj = result;
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16942 PyObject *resultobj;
16943 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16944 bool arg2 = (bool) false ;
16945 size_t result;
16946 PyObject * obj0 = 0 ;
16947 PyObject * obj1 = 0 ;
16948 char *kwnames[] = {
16949 (char *) "self",(char *) "recursive", NULL
16950 };
16951
16952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16954 if (SWIG_arg_fail(1)) SWIG_fail;
16955 if (obj1) {
16956 {
16957 arg2 = (bool)(SWIG_As_bool(obj1));
16958 if (SWIG_arg_fail(2)) SWIG_fail;
16959 }
16960 }
16961 {
16962 PyThreadState* __tstate = wxPyBeginAllowThreads();
16963 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16964
16965 wxPyEndAllowThreads(__tstate);
16966 if (PyErr_Occurred()) SWIG_fail;
16967 }
16968 {
16969 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16970 }
16971 return resultobj;
16972 fail:
16973 return NULL;
16974 }
16975
16976
16977 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16978 PyObject *resultobj;
16979 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16980 bool arg2 = (bool) false ;
16981 size_t result;
16982 PyObject * obj0 = 0 ;
16983 PyObject * obj1 = 0 ;
16984 char *kwnames[] = {
16985 (char *) "self",(char *) "recursive", NULL
16986 };
16987
16988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
16989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16990 if (SWIG_arg_fail(1)) SWIG_fail;
16991 if (obj1) {
16992 {
16993 arg2 = (bool)(SWIG_As_bool(obj1));
16994 if (SWIG_arg_fail(2)) SWIG_fail;
16995 }
16996 }
16997 {
16998 PyThreadState* __tstate = wxPyBeginAllowThreads();
16999 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17000
17001 wxPyEndAllowThreads(__tstate);
17002 if (PyErr_Occurred()) SWIG_fail;
17003 }
17004 {
17005 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17006 }
17007 return resultobj;
17008 fail:
17009 return NULL;
17010 }
17011
17012
17013 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17014 PyObject *resultobj;
17015 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17016 wxString *arg2 = 0 ;
17017 bool result;
17018 bool temp2 = false ;
17019 PyObject * obj0 = 0 ;
17020 PyObject * obj1 = 0 ;
17021 char *kwnames[] = {
17022 (char *) "self",(char *) "name", NULL
17023 };
17024
17025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17027 if (SWIG_arg_fail(1)) SWIG_fail;
17028 {
17029 arg2 = wxString_in_helper(obj1);
17030 if (arg2 == NULL) SWIG_fail;
17031 temp2 = true;
17032 }
17033 {
17034 PyThreadState* __tstate = wxPyBeginAllowThreads();
17035 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17036
17037 wxPyEndAllowThreads(__tstate);
17038 if (PyErr_Occurred()) SWIG_fail;
17039 }
17040 {
17041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17042 }
17043 {
17044 if (temp2)
17045 delete arg2;
17046 }
17047 return resultobj;
17048 fail:
17049 {
17050 if (temp2)
17051 delete arg2;
17052 }
17053 return NULL;
17054 }
17055
17056
17057 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj;
17059 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17060 wxString *arg2 = 0 ;
17061 bool result;
17062 bool temp2 = false ;
17063 PyObject * obj0 = 0 ;
17064 PyObject * obj1 = 0 ;
17065 char *kwnames[] = {
17066 (char *) "self",(char *) "name", NULL
17067 };
17068
17069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17071 if (SWIG_arg_fail(1)) SWIG_fail;
17072 {
17073 arg2 = wxString_in_helper(obj1);
17074 if (arg2 == NULL) SWIG_fail;
17075 temp2 = true;
17076 }
17077 {
17078 PyThreadState* __tstate = wxPyBeginAllowThreads();
17079 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17080
17081 wxPyEndAllowThreads(__tstate);
17082 if (PyErr_Occurred()) SWIG_fail;
17083 }
17084 {
17085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17086 }
17087 {
17088 if (temp2)
17089 delete arg2;
17090 }
17091 return resultobj;
17092 fail:
17093 {
17094 if (temp2)
17095 delete arg2;
17096 }
17097 return NULL;
17098 }
17099
17100
17101 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17102 PyObject *resultobj;
17103 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17104 wxString *arg2 = 0 ;
17105 bool result;
17106 bool temp2 = false ;
17107 PyObject * obj0 = 0 ;
17108 PyObject * obj1 = 0 ;
17109 char *kwnames[] = {
17110 (char *) "self",(char *) "name", NULL
17111 };
17112
17113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17115 if (SWIG_arg_fail(1)) SWIG_fail;
17116 {
17117 arg2 = wxString_in_helper(obj1);
17118 if (arg2 == NULL) SWIG_fail;
17119 temp2 = true;
17120 }
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17124
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 {
17129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17130 }
17131 {
17132 if (temp2)
17133 delete arg2;
17134 }
17135 return resultobj;
17136 fail:
17137 {
17138 if (temp2)
17139 delete arg2;
17140 }
17141 return NULL;
17142 }
17143
17144
17145 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17146 PyObject *resultobj;
17147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17148 wxString *arg2 = 0 ;
17149 wxConfigBase::EntryType result;
17150 bool temp2 = false ;
17151 PyObject * obj0 = 0 ;
17152 PyObject * obj1 = 0 ;
17153 char *kwnames[] = {
17154 (char *) "self",(char *) "name", NULL
17155 };
17156
17157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17159 if (SWIG_arg_fail(1)) SWIG_fail;
17160 {
17161 arg2 = wxString_in_helper(obj1);
17162 if (arg2 == NULL) SWIG_fail;
17163 temp2 = true;
17164 }
17165 {
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17168
17169 wxPyEndAllowThreads(__tstate);
17170 if (PyErr_Occurred()) SWIG_fail;
17171 }
17172 resultobj = SWIG_From_int((result));
17173 {
17174 if (temp2)
17175 delete arg2;
17176 }
17177 return resultobj;
17178 fail:
17179 {
17180 if (temp2)
17181 delete arg2;
17182 }
17183 return NULL;
17184 }
17185
17186
17187 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17188 PyObject *resultobj;
17189 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17190 wxString *arg2 = 0 ;
17191 wxString const &arg3_defvalue = wxPyEmptyString ;
17192 wxString *arg3 = (wxString *) &arg3_defvalue ;
17193 wxString result;
17194 bool temp2 = false ;
17195 bool temp3 = false ;
17196 PyObject * obj0 = 0 ;
17197 PyObject * obj1 = 0 ;
17198 PyObject * obj2 = 0 ;
17199 char *kwnames[] = {
17200 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17201 };
17202
17203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17205 if (SWIG_arg_fail(1)) SWIG_fail;
17206 {
17207 arg2 = wxString_in_helper(obj1);
17208 if (arg2 == NULL) SWIG_fail;
17209 temp2 = true;
17210 }
17211 if (obj2) {
17212 {
17213 arg3 = wxString_in_helper(obj2);
17214 if (arg3 == NULL) SWIG_fail;
17215 temp3 = true;
17216 }
17217 }
17218 {
17219 PyThreadState* __tstate = wxPyBeginAllowThreads();
17220 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17221
17222 wxPyEndAllowThreads(__tstate);
17223 if (PyErr_Occurred()) SWIG_fail;
17224 }
17225 {
17226 #if wxUSE_UNICODE
17227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17228 #else
17229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17230 #endif
17231 }
17232 {
17233 if (temp2)
17234 delete arg2;
17235 }
17236 {
17237 if (temp3)
17238 delete arg3;
17239 }
17240 return resultobj;
17241 fail:
17242 {
17243 if (temp2)
17244 delete arg2;
17245 }
17246 {
17247 if (temp3)
17248 delete arg3;
17249 }
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17257 wxString *arg2 = 0 ;
17258 long arg3 = (long) 0 ;
17259 long result;
17260 bool temp2 = false ;
17261 PyObject * obj0 = 0 ;
17262 PyObject * obj1 = 0 ;
17263 PyObject * obj2 = 0 ;
17264 char *kwnames[] = {
17265 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17266 };
17267
17268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17270 if (SWIG_arg_fail(1)) SWIG_fail;
17271 {
17272 arg2 = wxString_in_helper(obj1);
17273 if (arg2 == NULL) SWIG_fail;
17274 temp2 = true;
17275 }
17276 if (obj2) {
17277 {
17278 arg3 = (long)(SWIG_As_long(obj2));
17279 if (SWIG_arg_fail(3)) SWIG_fail;
17280 }
17281 }
17282 {
17283 PyThreadState* __tstate = wxPyBeginAllowThreads();
17284 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17285
17286 wxPyEndAllowThreads(__tstate);
17287 if (PyErr_Occurred()) SWIG_fail;
17288 }
17289 {
17290 resultobj = SWIG_From_long((long)(result));
17291 }
17292 {
17293 if (temp2)
17294 delete arg2;
17295 }
17296 return resultobj;
17297 fail:
17298 {
17299 if (temp2)
17300 delete arg2;
17301 }
17302 return NULL;
17303 }
17304
17305
17306 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17307 PyObject *resultobj;
17308 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17309 wxString *arg2 = 0 ;
17310 double arg3 = (double) 0.0 ;
17311 double result;
17312 bool temp2 = false ;
17313 PyObject * obj0 = 0 ;
17314 PyObject * obj1 = 0 ;
17315 PyObject * obj2 = 0 ;
17316 char *kwnames[] = {
17317 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17318 };
17319
17320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17322 if (SWIG_arg_fail(1)) SWIG_fail;
17323 {
17324 arg2 = wxString_in_helper(obj1);
17325 if (arg2 == NULL) SWIG_fail;
17326 temp2 = true;
17327 }
17328 if (obj2) {
17329 {
17330 arg3 = (double)(SWIG_As_double(obj2));
17331 if (SWIG_arg_fail(3)) SWIG_fail;
17332 }
17333 }
17334 {
17335 PyThreadState* __tstate = wxPyBeginAllowThreads();
17336 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17337
17338 wxPyEndAllowThreads(__tstate);
17339 if (PyErr_Occurred()) SWIG_fail;
17340 }
17341 {
17342 resultobj = SWIG_From_double((double)(result));
17343 }
17344 {
17345 if (temp2)
17346 delete arg2;
17347 }
17348 return resultobj;
17349 fail:
17350 {
17351 if (temp2)
17352 delete arg2;
17353 }
17354 return NULL;
17355 }
17356
17357
17358 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17359 PyObject *resultobj;
17360 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17361 wxString *arg2 = 0 ;
17362 bool arg3 = (bool) false ;
17363 bool result;
17364 bool temp2 = false ;
17365 PyObject * obj0 = 0 ;
17366 PyObject * obj1 = 0 ;
17367 PyObject * obj2 = 0 ;
17368 char *kwnames[] = {
17369 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17370 };
17371
17372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17374 if (SWIG_arg_fail(1)) SWIG_fail;
17375 {
17376 arg2 = wxString_in_helper(obj1);
17377 if (arg2 == NULL) SWIG_fail;
17378 temp2 = true;
17379 }
17380 if (obj2) {
17381 {
17382 arg3 = (bool)(SWIG_As_bool(obj2));
17383 if (SWIG_arg_fail(3)) SWIG_fail;
17384 }
17385 }
17386 {
17387 PyThreadState* __tstate = wxPyBeginAllowThreads();
17388 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17389
17390 wxPyEndAllowThreads(__tstate);
17391 if (PyErr_Occurred()) SWIG_fail;
17392 }
17393 {
17394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17395 }
17396 {
17397 if (temp2)
17398 delete arg2;
17399 }
17400 return resultobj;
17401 fail:
17402 {
17403 if (temp2)
17404 delete arg2;
17405 }
17406 return NULL;
17407 }
17408
17409
17410 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj;
17412 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17413 wxString *arg2 = 0 ;
17414 wxString *arg3 = 0 ;
17415 bool result;
17416 bool temp2 = false ;
17417 bool temp3 = false ;
17418 PyObject * obj0 = 0 ;
17419 PyObject * obj1 = 0 ;
17420 PyObject * obj2 = 0 ;
17421 char *kwnames[] = {
17422 (char *) "self",(char *) "key",(char *) "value", NULL
17423 };
17424
17425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17427 if (SWIG_arg_fail(1)) SWIG_fail;
17428 {
17429 arg2 = wxString_in_helper(obj1);
17430 if (arg2 == NULL) SWIG_fail;
17431 temp2 = true;
17432 }
17433 {
17434 arg3 = wxString_in_helper(obj2);
17435 if (arg3 == NULL) SWIG_fail;
17436 temp3 = true;
17437 }
17438 {
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17441
17442 wxPyEndAllowThreads(__tstate);
17443 if (PyErr_Occurred()) SWIG_fail;
17444 }
17445 {
17446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17447 }
17448 {
17449 if (temp2)
17450 delete arg2;
17451 }
17452 {
17453 if (temp3)
17454 delete arg3;
17455 }
17456 return resultobj;
17457 fail:
17458 {
17459 if (temp2)
17460 delete arg2;
17461 }
17462 {
17463 if (temp3)
17464 delete arg3;
17465 }
17466 return NULL;
17467 }
17468
17469
17470 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17471 PyObject *resultobj;
17472 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17473 wxString *arg2 = 0 ;
17474 long arg3 ;
17475 bool result;
17476 bool temp2 = false ;
17477 PyObject * obj0 = 0 ;
17478 PyObject * obj1 = 0 ;
17479 PyObject * obj2 = 0 ;
17480 char *kwnames[] = {
17481 (char *) "self",(char *) "key",(char *) "value", NULL
17482 };
17483
17484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17486 if (SWIG_arg_fail(1)) SWIG_fail;
17487 {
17488 arg2 = wxString_in_helper(obj1);
17489 if (arg2 == NULL) SWIG_fail;
17490 temp2 = true;
17491 }
17492 {
17493 arg3 = (long)(SWIG_As_long(obj2));
17494 if (SWIG_arg_fail(3)) SWIG_fail;
17495 }
17496 {
17497 PyThreadState* __tstate = wxPyBeginAllowThreads();
17498 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17499
17500 wxPyEndAllowThreads(__tstate);
17501 if (PyErr_Occurred()) SWIG_fail;
17502 }
17503 {
17504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17505 }
17506 {
17507 if (temp2)
17508 delete arg2;
17509 }
17510 return resultobj;
17511 fail:
17512 {
17513 if (temp2)
17514 delete arg2;
17515 }
17516 return NULL;
17517 }
17518
17519
17520 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17521 PyObject *resultobj;
17522 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17523 wxString *arg2 = 0 ;
17524 double arg3 ;
17525 bool result;
17526 bool temp2 = false ;
17527 PyObject * obj0 = 0 ;
17528 PyObject * obj1 = 0 ;
17529 PyObject * obj2 = 0 ;
17530 char *kwnames[] = {
17531 (char *) "self",(char *) "key",(char *) "value", NULL
17532 };
17533
17534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17536 if (SWIG_arg_fail(1)) SWIG_fail;
17537 {
17538 arg2 = wxString_in_helper(obj1);
17539 if (arg2 == NULL) SWIG_fail;
17540 temp2 = true;
17541 }
17542 {
17543 arg3 = (double)(SWIG_As_double(obj2));
17544 if (SWIG_arg_fail(3)) SWIG_fail;
17545 }
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17549
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 {
17554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17555 }
17556 {
17557 if (temp2)
17558 delete arg2;
17559 }
17560 return resultobj;
17561 fail:
17562 {
17563 if (temp2)
17564 delete arg2;
17565 }
17566 return NULL;
17567 }
17568
17569
17570 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17571 PyObject *resultobj;
17572 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17573 wxString *arg2 = 0 ;
17574 bool arg3 ;
17575 bool result;
17576 bool temp2 = false ;
17577 PyObject * obj0 = 0 ;
17578 PyObject * obj1 = 0 ;
17579 PyObject * obj2 = 0 ;
17580 char *kwnames[] = {
17581 (char *) "self",(char *) "key",(char *) "value", NULL
17582 };
17583
17584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17586 if (SWIG_arg_fail(1)) SWIG_fail;
17587 {
17588 arg2 = wxString_in_helper(obj1);
17589 if (arg2 == NULL) SWIG_fail;
17590 temp2 = true;
17591 }
17592 {
17593 arg3 = (bool)(SWIG_As_bool(obj2));
17594 if (SWIG_arg_fail(3)) SWIG_fail;
17595 }
17596 {
17597 PyThreadState* __tstate = wxPyBeginAllowThreads();
17598 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17599
17600 wxPyEndAllowThreads(__tstate);
17601 if (PyErr_Occurred()) SWIG_fail;
17602 }
17603 {
17604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17605 }
17606 {
17607 if (temp2)
17608 delete arg2;
17609 }
17610 return resultobj;
17611 fail:
17612 {
17613 if (temp2)
17614 delete arg2;
17615 }
17616 return NULL;
17617 }
17618
17619
17620 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17621 PyObject *resultobj;
17622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17623 bool arg2 = (bool) false ;
17624 bool result;
17625 PyObject * obj0 = 0 ;
17626 PyObject * obj1 = 0 ;
17627 char *kwnames[] = {
17628 (char *) "self",(char *) "currentOnly", NULL
17629 };
17630
17631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17633 if (SWIG_arg_fail(1)) SWIG_fail;
17634 if (obj1) {
17635 {
17636 arg2 = (bool)(SWIG_As_bool(obj1));
17637 if (SWIG_arg_fail(2)) SWIG_fail;
17638 }
17639 }
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (bool)(arg1)->Flush(arg2);
17643
17644 wxPyEndAllowThreads(__tstate);
17645 if (PyErr_Occurred()) SWIG_fail;
17646 }
17647 {
17648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17649 }
17650 return resultobj;
17651 fail:
17652 return NULL;
17653 }
17654
17655
17656 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17657 PyObject *resultobj;
17658 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17659 wxString *arg2 = 0 ;
17660 wxString *arg3 = 0 ;
17661 bool result;
17662 bool temp2 = false ;
17663 bool temp3 = false ;
17664 PyObject * obj0 = 0 ;
17665 PyObject * obj1 = 0 ;
17666 PyObject * obj2 = 0 ;
17667 char *kwnames[] = {
17668 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17669 };
17670
17671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17673 if (SWIG_arg_fail(1)) SWIG_fail;
17674 {
17675 arg2 = wxString_in_helper(obj1);
17676 if (arg2 == NULL) SWIG_fail;
17677 temp2 = true;
17678 }
17679 {
17680 arg3 = wxString_in_helper(obj2);
17681 if (arg3 == NULL) SWIG_fail;
17682 temp3 = true;
17683 }
17684 {
17685 PyThreadState* __tstate = wxPyBeginAllowThreads();
17686 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17687
17688 wxPyEndAllowThreads(__tstate);
17689 if (PyErr_Occurred()) SWIG_fail;
17690 }
17691 {
17692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17693 }
17694 {
17695 if (temp2)
17696 delete arg2;
17697 }
17698 {
17699 if (temp3)
17700 delete arg3;
17701 }
17702 return resultobj;
17703 fail:
17704 {
17705 if (temp2)
17706 delete arg2;
17707 }
17708 {
17709 if (temp3)
17710 delete arg3;
17711 }
17712 return NULL;
17713 }
17714
17715
17716 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17717 PyObject *resultobj;
17718 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17719 wxString *arg2 = 0 ;
17720 wxString *arg3 = 0 ;
17721 bool result;
17722 bool temp2 = false ;
17723 bool temp3 = false ;
17724 PyObject * obj0 = 0 ;
17725 PyObject * obj1 = 0 ;
17726 PyObject * obj2 = 0 ;
17727 char *kwnames[] = {
17728 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17729 };
17730
17731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17733 if (SWIG_arg_fail(1)) SWIG_fail;
17734 {
17735 arg2 = wxString_in_helper(obj1);
17736 if (arg2 == NULL) SWIG_fail;
17737 temp2 = true;
17738 }
17739 {
17740 arg3 = wxString_in_helper(obj2);
17741 if (arg3 == NULL) SWIG_fail;
17742 temp3 = true;
17743 }
17744 {
17745 PyThreadState* __tstate = wxPyBeginAllowThreads();
17746 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17747
17748 wxPyEndAllowThreads(__tstate);
17749 if (PyErr_Occurred()) SWIG_fail;
17750 }
17751 {
17752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17753 }
17754 {
17755 if (temp2)
17756 delete arg2;
17757 }
17758 {
17759 if (temp3)
17760 delete arg3;
17761 }
17762 return resultobj;
17763 fail:
17764 {
17765 if (temp2)
17766 delete arg2;
17767 }
17768 {
17769 if (temp3)
17770 delete arg3;
17771 }
17772 return NULL;
17773 }
17774
17775
17776 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17777 PyObject *resultobj;
17778 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17779 wxString *arg2 = 0 ;
17780 bool arg3 = (bool) true ;
17781 bool result;
17782 bool temp2 = false ;
17783 PyObject * obj0 = 0 ;
17784 PyObject * obj1 = 0 ;
17785 PyObject * obj2 = 0 ;
17786 char *kwnames[] = {
17787 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17788 };
17789
17790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17792 if (SWIG_arg_fail(1)) SWIG_fail;
17793 {
17794 arg2 = wxString_in_helper(obj1);
17795 if (arg2 == NULL) SWIG_fail;
17796 temp2 = true;
17797 }
17798 if (obj2) {
17799 {
17800 arg3 = (bool)(SWIG_As_bool(obj2));
17801 if (SWIG_arg_fail(3)) SWIG_fail;
17802 }
17803 }
17804 {
17805 PyThreadState* __tstate = wxPyBeginAllowThreads();
17806 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17807
17808 wxPyEndAllowThreads(__tstate);
17809 if (PyErr_Occurred()) SWIG_fail;
17810 }
17811 {
17812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17813 }
17814 {
17815 if (temp2)
17816 delete arg2;
17817 }
17818 return resultobj;
17819 fail:
17820 {
17821 if (temp2)
17822 delete arg2;
17823 }
17824 return NULL;
17825 }
17826
17827
17828 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17829 PyObject *resultobj;
17830 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17831 wxString *arg2 = 0 ;
17832 bool result;
17833 bool temp2 = false ;
17834 PyObject * obj0 = 0 ;
17835 PyObject * obj1 = 0 ;
17836 char *kwnames[] = {
17837 (char *) "self",(char *) "key", NULL
17838 };
17839
17840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17842 if (SWIG_arg_fail(1)) SWIG_fail;
17843 {
17844 arg2 = wxString_in_helper(obj1);
17845 if (arg2 == NULL) SWIG_fail;
17846 temp2 = true;
17847 }
17848 {
17849 PyThreadState* __tstate = wxPyBeginAllowThreads();
17850 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17851
17852 wxPyEndAllowThreads(__tstate);
17853 if (PyErr_Occurred()) SWIG_fail;
17854 }
17855 {
17856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17857 }
17858 {
17859 if (temp2)
17860 delete arg2;
17861 }
17862 return resultobj;
17863 fail:
17864 {
17865 if (temp2)
17866 delete arg2;
17867 }
17868 return NULL;
17869 }
17870
17871
17872 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17873 PyObject *resultobj;
17874 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17875 bool result;
17876 PyObject * obj0 = 0 ;
17877 char *kwnames[] = {
17878 (char *) "self", NULL
17879 };
17880
17881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17883 if (SWIG_arg_fail(1)) SWIG_fail;
17884 {
17885 PyThreadState* __tstate = wxPyBeginAllowThreads();
17886 result = (bool)(arg1)->DeleteAll();
17887
17888 wxPyEndAllowThreads(__tstate);
17889 if (PyErr_Occurred()) SWIG_fail;
17890 }
17891 {
17892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17893 }
17894 return resultobj;
17895 fail:
17896 return NULL;
17897 }
17898
17899
17900 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17901 PyObject *resultobj;
17902 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17903 bool arg2 = (bool) true ;
17904 PyObject * obj0 = 0 ;
17905 PyObject * obj1 = 0 ;
17906 char *kwnames[] = {
17907 (char *) "self",(char *) "doIt", NULL
17908 };
17909
17910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17912 if (SWIG_arg_fail(1)) SWIG_fail;
17913 if (obj1) {
17914 {
17915 arg2 = (bool)(SWIG_As_bool(obj1));
17916 if (SWIG_arg_fail(2)) SWIG_fail;
17917 }
17918 }
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 (arg1)->SetExpandEnvVars(arg2);
17922
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 Py_INCREF(Py_None); resultobj = Py_None;
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17934 PyObject *resultobj;
17935 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17936 bool result;
17937 PyObject * obj0 = 0 ;
17938 char *kwnames[] = {
17939 (char *) "self", NULL
17940 };
17941
17942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17944 if (SWIG_arg_fail(1)) SWIG_fail;
17945 {
17946 PyThreadState* __tstate = wxPyBeginAllowThreads();
17947 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17948
17949 wxPyEndAllowThreads(__tstate);
17950 if (PyErr_Occurred()) SWIG_fail;
17951 }
17952 {
17953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17954 }
17955 return resultobj;
17956 fail:
17957 return NULL;
17958 }
17959
17960
17961 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17962 PyObject *resultobj;
17963 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17964 bool arg2 = (bool) true ;
17965 PyObject * obj0 = 0 ;
17966 PyObject * obj1 = 0 ;
17967 char *kwnames[] = {
17968 (char *) "self",(char *) "doIt", NULL
17969 };
17970
17971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17973 if (SWIG_arg_fail(1)) SWIG_fail;
17974 if (obj1) {
17975 {
17976 arg2 = (bool)(SWIG_As_bool(obj1));
17977 if (SWIG_arg_fail(2)) SWIG_fail;
17978 }
17979 }
17980 {
17981 PyThreadState* __tstate = wxPyBeginAllowThreads();
17982 (arg1)->SetRecordDefaults(arg2);
17983
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 Py_INCREF(Py_None); resultobj = Py_None;
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17995 PyObject *resultobj;
17996 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17997 bool result;
17998 PyObject * obj0 = 0 ;
17999 char *kwnames[] = {
18000 (char *) "self", NULL
18001 };
18002
18003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18005 if (SWIG_arg_fail(1)) SWIG_fail;
18006 {
18007 PyThreadState* __tstate = wxPyBeginAllowThreads();
18008 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18009
18010 wxPyEndAllowThreads(__tstate);
18011 if (PyErr_Occurred()) SWIG_fail;
18012 }
18013 {
18014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18015 }
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18023 PyObject *resultobj;
18024 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18025 wxString *arg2 = 0 ;
18026 wxString result;
18027 bool temp2 = false ;
18028 PyObject * obj0 = 0 ;
18029 PyObject * obj1 = 0 ;
18030 char *kwnames[] = {
18031 (char *) "self",(char *) "str", NULL
18032 };
18033
18034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18036 if (SWIG_arg_fail(1)) SWIG_fail;
18037 {
18038 arg2 = wxString_in_helper(obj1);
18039 if (arg2 == NULL) SWIG_fail;
18040 temp2 = true;
18041 }
18042 {
18043 PyThreadState* __tstate = wxPyBeginAllowThreads();
18044 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18045
18046 wxPyEndAllowThreads(__tstate);
18047 if (PyErr_Occurred()) SWIG_fail;
18048 }
18049 {
18050 #if wxUSE_UNICODE
18051 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18052 #else
18053 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18054 #endif
18055 }
18056 {
18057 if (temp2)
18058 delete arg2;
18059 }
18060 return resultobj;
18061 fail:
18062 {
18063 if (temp2)
18064 delete arg2;
18065 }
18066 return NULL;
18067 }
18068
18069
18070 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18071 PyObject *resultobj;
18072 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18073 wxString result;
18074 PyObject * obj0 = 0 ;
18075 char *kwnames[] = {
18076 (char *) "self", NULL
18077 };
18078
18079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18081 if (SWIG_arg_fail(1)) SWIG_fail;
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = ((wxConfigBase const *)arg1)->GetAppName();
18085
18086 wxPyEndAllowThreads(__tstate);
18087 if (PyErr_Occurred()) SWIG_fail;
18088 }
18089 {
18090 #if wxUSE_UNICODE
18091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18092 #else
18093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18094 #endif
18095 }
18096 return resultobj;
18097 fail:
18098 return NULL;
18099 }
18100
18101
18102 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18103 PyObject *resultobj;
18104 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18105 wxString result;
18106 PyObject * obj0 = 0 ;
18107 char *kwnames[] = {
18108 (char *) "self", NULL
18109 };
18110
18111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18113 if (SWIG_arg_fail(1)) SWIG_fail;
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 result = ((wxConfigBase const *)arg1)->GetVendorName();
18117
18118 wxPyEndAllowThreads(__tstate);
18119 if (PyErr_Occurred()) SWIG_fail;
18120 }
18121 {
18122 #if wxUSE_UNICODE
18123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18124 #else
18125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18126 #endif
18127 }
18128 return resultobj;
18129 fail:
18130 return NULL;
18131 }
18132
18133
18134 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18135 PyObject *resultobj;
18136 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18137 wxString *arg2 = 0 ;
18138 bool temp2 = false ;
18139 PyObject * obj0 = 0 ;
18140 PyObject * obj1 = 0 ;
18141 char *kwnames[] = {
18142 (char *) "self",(char *) "appName", NULL
18143 };
18144
18145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18147 if (SWIG_arg_fail(1)) SWIG_fail;
18148 {
18149 arg2 = wxString_in_helper(obj1);
18150 if (arg2 == NULL) SWIG_fail;
18151 temp2 = true;
18152 }
18153 {
18154 PyThreadState* __tstate = wxPyBeginAllowThreads();
18155 (arg1)->SetAppName((wxString const &)*arg2);
18156
18157 wxPyEndAllowThreads(__tstate);
18158 if (PyErr_Occurred()) SWIG_fail;
18159 }
18160 Py_INCREF(Py_None); resultobj = Py_None;
18161 {
18162 if (temp2)
18163 delete arg2;
18164 }
18165 return resultobj;
18166 fail:
18167 {
18168 if (temp2)
18169 delete arg2;
18170 }
18171 return NULL;
18172 }
18173
18174
18175 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18176 PyObject *resultobj;
18177 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18178 wxString *arg2 = 0 ;
18179 bool temp2 = false ;
18180 PyObject * obj0 = 0 ;
18181 PyObject * obj1 = 0 ;
18182 char *kwnames[] = {
18183 (char *) "self",(char *) "vendorName", NULL
18184 };
18185
18186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18188 if (SWIG_arg_fail(1)) SWIG_fail;
18189 {
18190 arg2 = wxString_in_helper(obj1);
18191 if (arg2 == NULL) SWIG_fail;
18192 temp2 = true;
18193 }
18194 {
18195 PyThreadState* __tstate = wxPyBeginAllowThreads();
18196 (arg1)->SetVendorName((wxString const &)*arg2);
18197
18198 wxPyEndAllowThreads(__tstate);
18199 if (PyErr_Occurred()) SWIG_fail;
18200 }
18201 Py_INCREF(Py_None); resultobj = Py_None;
18202 {
18203 if (temp2)
18204 delete arg2;
18205 }
18206 return resultobj;
18207 fail:
18208 {
18209 if (temp2)
18210 delete arg2;
18211 }
18212 return NULL;
18213 }
18214
18215
18216 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18217 PyObject *resultobj;
18218 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18219 long arg2 ;
18220 PyObject * obj0 = 0 ;
18221 PyObject * obj1 = 0 ;
18222 char *kwnames[] = {
18223 (char *) "self",(char *) "style", NULL
18224 };
18225
18226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18228 if (SWIG_arg_fail(1)) SWIG_fail;
18229 {
18230 arg2 = (long)(SWIG_As_long(obj1));
18231 if (SWIG_arg_fail(2)) SWIG_fail;
18232 }
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 (arg1)->SetStyle(arg2);
18236
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 Py_INCREF(Py_None); resultobj = Py_None;
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18248 PyObject *resultobj;
18249 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18250 long result;
18251 PyObject * obj0 = 0 ;
18252 char *kwnames[] = {
18253 (char *) "self", NULL
18254 };
18255
18256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18258 if (SWIG_arg_fail(1)) SWIG_fail;
18259 {
18260 PyThreadState* __tstate = wxPyBeginAllowThreads();
18261 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18262
18263 wxPyEndAllowThreads(__tstate);
18264 if (PyErr_Occurred()) SWIG_fail;
18265 }
18266 {
18267 resultobj = SWIG_From_long((long)(result));
18268 }
18269 return resultobj;
18270 fail:
18271 return NULL;
18272 }
18273
18274
18275 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18276 PyObject *obj;
18277 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18278 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18279 Py_INCREF(obj);
18280 return Py_BuildValue((char *)"");
18281 }
18282 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18283 PyObject *resultobj;
18284 wxString const &arg1_defvalue = wxPyEmptyString ;
18285 wxString *arg1 = (wxString *) &arg1_defvalue ;
18286 wxString const &arg2_defvalue = wxPyEmptyString ;
18287 wxString *arg2 = (wxString *) &arg2_defvalue ;
18288 wxString const &arg3_defvalue = wxPyEmptyString ;
18289 wxString *arg3 = (wxString *) &arg3_defvalue ;
18290 wxString const &arg4_defvalue = wxPyEmptyString ;
18291 wxString *arg4 = (wxString *) &arg4_defvalue ;
18292 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18293 wxConfig *result;
18294 bool temp1 = false ;
18295 bool temp2 = false ;
18296 bool temp3 = false ;
18297 bool temp4 = false ;
18298 PyObject * obj0 = 0 ;
18299 PyObject * obj1 = 0 ;
18300 PyObject * obj2 = 0 ;
18301 PyObject * obj3 = 0 ;
18302 PyObject * obj4 = 0 ;
18303 char *kwnames[] = {
18304 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18305 };
18306
18307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18308 if (obj0) {
18309 {
18310 arg1 = wxString_in_helper(obj0);
18311 if (arg1 == NULL) SWIG_fail;
18312 temp1 = true;
18313 }
18314 }
18315 if (obj1) {
18316 {
18317 arg2 = wxString_in_helper(obj1);
18318 if (arg2 == NULL) SWIG_fail;
18319 temp2 = true;
18320 }
18321 }
18322 if (obj2) {
18323 {
18324 arg3 = wxString_in_helper(obj2);
18325 if (arg3 == NULL) SWIG_fail;
18326 temp3 = true;
18327 }
18328 }
18329 if (obj3) {
18330 {
18331 arg4 = wxString_in_helper(obj3);
18332 if (arg4 == NULL) SWIG_fail;
18333 temp4 = true;
18334 }
18335 }
18336 if (obj4) {
18337 {
18338 arg5 = (long)(SWIG_As_long(obj4));
18339 if (SWIG_arg_fail(5)) SWIG_fail;
18340 }
18341 }
18342 {
18343 PyThreadState* __tstate = wxPyBeginAllowThreads();
18344 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18345
18346 wxPyEndAllowThreads(__tstate);
18347 if (PyErr_Occurred()) SWIG_fail;
18348 }
18349 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18350 {
18351 if (temp1)
18352 delete arg1;
18353 }
18354 {
18355 if (temp2)
18356 delete arg2;
18357 }
18358 {
18359 if (temp3)
18360 delete arg3;
18361 }
18362 {
18363 if (temp4)
18364 delete arg4;
18365 }
18366 return resultobj;
18367 fail:
18368 {
18369 if (temp1)
18370 delete arg1;
18371 }
18372 {
18373 if (temp2)
18374 delete arg2;
18375 }
18376 {
18377 if (temp3)
18378 delete arg3;
18379 }
18380 {
18381 if (temp4)
18382 delete arg4;
18383 }
18384 return NULL;
18385 }
18386
18387
18388 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18389 PyObject *resultobj;
18390 wxConfig *arg1 = (wxConfig *) 0 ;
18391 PyObject * obj0 = 0 ;
18392 char *kwnames[] = {
18393 (char *) "self", NULL
18394 };
18395
18396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18398 if (SWIG_arg_fail(1)) SWIG_fail;
18399 {
18400 PyThreadState* __tstate = wxPyBeginAllowThreads();
18401 delete arg1;
18402
18403 wxPyEndAllowThreads(__tstate);
18404 if (PyErr_Occurred()) SWIG_fail;
18405 }
18406 Py_INCREF(Py_None); resultobj = Py_None;
18407 return resultobj;
18408 fail:
18409 return NULL;
18410 }
18411
18412
18413 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18414 PyObject *obj;
18415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18416 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18417 Py_INCREF(obj);
18418 return Py_BuildValue((char *)"");
18419 }
18420 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18421 PyObject *resultobj;
18422 wxString const &arg1_defvalue = wxPyEmptyString ;
18423 wxString *arg1 = (wxString *) &arg1_defvalue ;
18424 wxString const &arg2_defvalue = wxPyEmptyString ;
18425 wxString *arg2 = (wxString *) &arg2_defvalue ;
18426 wxString const &arg3_defvalue = wxPyEmptyString ;
18427 wxString *arg3 = (wxString *) &arg3_defvalue ;
18428 wxString const &arg4_defvalue = wxPyEmptyString ;
18429 wxString *arg4 = (wxString *) &arg4_defvalue ;
18430 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18431 wxFileConfig *result;
18432 bool temp1 = false ;
18433 bool temp2 = false ;
18434 bool temp3 = false ;
18435 bool temp4 = false ;
18436 PyObject * obj0 = 0 ;
18437 PyObject * obj1 = 0 ;
18438 PyObject * obj2 = 0 ;
18439 PyObject * obj3 = 0 ;
18440 PyObject * obj4 = 0 ;
18441 char *kwnames[] = {
18442 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18443 };
18444
18445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18446 if (obj0) {
18447 {
18448 arg1 = wxString_in_helper(obj0);
18449 if (arg1 == NULL) SWIG_fail;
18450 temp1 = true;
18451 }
18452 }
18453 if (obj1) {
18454 {
18455 arg2 = wxString_in_helper(obj1);
18456 if (arg2 == NULL) SWIG_fail;
18457 temp2 = true;
18458 }
18459 }
18460 if (obj2) {
18461 {
18462 arg3 = wxString_in_helper(obj2);
18463 if (arg3 == NULL) SWIG_fail;
18464 temp3 = true;
18465 }
18466 }
18467 if (obj3) {
18468 {
18469 arg4 = wxString_in_helper(obj3);
18470 if (arg4 == NULL) SWIG_fail;
18471 temp4 = true;
18472 }
18473 }
18474 if (obj4) {
18475 {
18476 arg5 = (long)(SWIG_As_long(obj4));
18477 if (SWIG_arg_fail(5)) SWIG_fail;
18478 }
18479 }
18480 {
18481 PyThreadState* __tstate = wxPyBeginAllowThreads();
18482 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18483
18484 wxPyEndAllowThreads(__tstate);
18485 if (PyErr_Occurred()) SWIG_fail;
18486 }
18487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18488 {
18489 if (temp1)
18490 delete arg1;
18491 }
18492 {
18493 if (temp2)
18494 delete arg2;
18495 }
18496 {
18497 if (temp3)
18498 delete arg3;
18499 }
18500 {
18501 if (temp4)
18502 delete arg4;
18503 }
18504 return resultobj;
18505 fail:
18506 {
18507 if (temp1)
18508 delete arg1;
18509 }
18510 {
18511 if (temp2)
18512 delete arg2;
18513 }
18514 {
18515 if (temp3)
18516 delete arg3;
18517 }
18518 {
18519 if (temp4)
18520 delete arg4;
18521 }
18522 return NULL;
18523 }
18524
18525
18526 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18527 PyObject *resultobj;
18528 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18529 PyObject * obj0 = 0 ;
18530 char *kwnames[] = {
18531 (char *) "self", NULL
18532 };
18533
18534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18536 if (SWIG_arg_fail(1)) SWIG_fail;
18537 {
18538 PyThreadState* __tstate = wxPyBeginAllowThreads();
18539 delete arg1;
18540
18541 wxPyEndAllowThreads(__tstate);
18542 if (PyErr_Occurred()) SWIG_fail;
18543 }
18544 Py_INCREF(Py_None); resultobj = Py_None;
18545 return resultobj;
18546 fail:
18547 return NULL;
18548 }
18549
18550
18551 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18552 PyObject *obj;
18553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18554 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18555 Py_INCREF(obj);
18556 return Py_BuildValue((char *)"");
18557 }
18558 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18559 PyObject *resultobj;
18560 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18561 wxString *arg2 = 0 ;
18562 wxConfigPathChanger *result;
18563 bool temp2 = false ;
18564 PyObject * obj0 = 0 ;
18565 PyObject * obj1 = 0 ;
18566 char *kwnames[] = {
18567 (char *) "config",(char *) "entry", NULL
18568 };
18569
18570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18572 if (SWIG_arg_fail(1)) SWIG_fail;
18573 {
18574 arg2 = wxString_in_helper(obj1);
18575 if (arg2 == NULL) SWIG_fail;
18576 temp2 = true;
18577 }
18578 {
18579 PyThreadState* __tstate = wxPyBeginAllowThreads();
18580 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18581
18582 wxPyEndAllowThreads(__tstate);
18583 if (PyErr_Occurred()) SWIG_fail;
18584 }
18585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18586 {
18587 if (temp2)
18588 delete arg2;
18589 }
18590 return resultobj;
18591 fail:
18592 {
18593 if (temp2)
18594 delete arg2;
18595 }
18596 return NULL;
18597 }
18598
18599
18600 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18601 PyObject *resultobj;
18602 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18603 PyObject * obj0 = 0 ;
18604 char *kwnames[] = {
18605 (char *) "self", NULL
18606 };
18607
18608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18610 if (SWIG_arg_fail(1)) SWIG_fail;
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 delete arg1;
18614
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 Py_INCREF(Py_None); resultobj = Py_None;
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18626 PyObject *resultobj;
18627 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18628 wxString *result;
18629 PyObject * obj0 = 0 ;
18630 char *kwnames[] = {
18631 (char *) "self", NULL
18632 };
18633
18634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18636 if (SWIG_arg_fail(1)) SWIG_fail;
18637 {
18638 PyThreadState* __tstate = wxPyBeginAllowThreads();
18639 {
18640 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18641 result = (wxString *) &_result_ref;
18642 }
18643
18644 wxPyEndAllowThreads(__tstate);
18645 if (PyErr_Occurred()) SWIG_fail;
18646 }
18647 {
18648 #if wxUSE_UNICODE
18649 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18650 #else
18651 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18652 #endif
18653 }
18654 return resultobj;
18655 fail:
18656 return NULL;
18657 }
18658
18659
18660 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18661 PyObject *obj;
18662 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18663 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18664 Py_INCREF(obj);
18665 return Py_BuildValue((char *)"");
18666 }
18667 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18668 PyObject *resultobj;
18669 wxString *arg1 = 0 ;
18670 wxString result;
18671 bool temp1 = false ;
18672 PyObject * obj0 = 0 ;
18673 char *kwnames[] = {
18674 (char *) "sz", NULL
18675 };
18676
18677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18678 {
18679 arg1 = wxString_in_helper(obj0);
18680 if (arg1 == NULL) SWIG_fail;
18681 temp1 = true;
18682 }
18683 {
18684 PyThreadState* __tstate = wxPyBeginAllowThreads();
18685 result = wxExpandEnvVars((wxString const &)*arg1);
18686
18687 wxPyEndAllowThreads(__tstate);
18688 if (PyErr_Occurred()) SWIG_fail;
18689 }
18690 {
18691 #if wxUSE_UNICODE
18692 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18693 #else
18694 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18695 #endif
18696 }
18697 {
18698 if (temp1)
18699 delete arg1;
18700 }
18701 return resultobj;
18702 fail:
18703 {
18704 if (temp1)
18705 delete arg1;
18706 }
18707 return NULL;
18708 }
18709
18710
18711 static int _wrap_DateFormatStr_set(PyObject *) {
18712 PyErr_SetString(PyExc_TypeError,"Variable DateFormatStr is read-only.");
18713 return 1;
18714 }
18715
18716
18717 static PyObject *_wrap_DateFormatStr_get(void) {
18718 PyObject *pyobj;
18719
18720 {
18721 #if wxUSE_UNICODE
18722 pyobj = PyUnicode_FromWideChar((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18723 #else
18724 pyobj = PyString_FromStringAndSize((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18725 #endif
18726 }
18727 return pyobj;
18728 }
18729
18730
18731 static int _wrap_TimeSpanFormatStr_set(PyObject *) {
18732 PyErr_SetString(PyExc_TypeError,"Variable TimeSpanFormatStr is read-only.");
18733 return 1;
18734 }
18735
18736
18737 static PyObject *_wrap_TimeSpanFormatStr_get(void) {
18738 PyObject *pyobj;
18739
18740 {
18741 #if wxUSE_UNICODE
18742 pyobj = PyUnicode_FromWideChar((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18743 #else
18744 pyobj = PyString_FromStringAndSize((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18745 #endif
18746 }
18747 return pyobj;
18748 }
18749
18750
18751 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18752 PyObject *resultobj;
18753 wxDateTime::Country arg1 ;
18754 PyObject * obj0 = 0 ;
18755 char *kwnames[] = {
18756 (char *) "country", NULL
18757 };
18758
18759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18760 {
18761 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18762 if (SWIG_arg_fail(1)) SWIG_fail;
18763 }
18764 {
18765 PyThreadState* __tstate = wxPyBeginAllowThreads();
18766 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18767
18768 wxPyEndAllowThreads(__tstate);
18769 if (PyErr_Occurred()) SWIG_fail;
18770 }
18771 Py_INCREF(Py_None); resultobj = Py_None;
18772 return resultobj;
18773 fail:
18774 return NULL;
18775 }
18776
18777
18778 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18779 PyObject *resultobj;
18780 wxDateTime::Country result;
18781 char *kwnames[] = {
18782 NULL
18783 };
18784
18785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18786 {
18787 PyThreadState* __tstate = wxPyBeginAllowThreads();
18788 result = (wxDateTime::Country)wxDateTime::GetCountry();
18789
18790 wxPyEndAllowThreads(__tstate);
18791 if (PyErr_Occurred()) SWIG_fail;
18792 }
18793 resultobj = SWIG_From_int((result));
18794 return resultobj;
18795 fail:
18796 return NULL;
18797 }
18798
18799
18800 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18801 PyObject *resultobj;
18802 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18803 bool result;
18804 PyObject * obj0 = 0 ;
18805 char *kwnames[] = {
18806 (char *) "country", NULL
18807 };
18808
18809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18810 if (obj0) {
18811 {
18812 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18813 if (SWIG_arg_fail(1)) SWIG_fail;
18814 }
18815 }
18816 {
18817 PyThreadState* __tstate = wxPyBeginAllowThreads();
18818 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18819
18820 wxPyEndAllowThreads(__tstate);
18821 if (PyErr_Occurred()) SWIG_fail;
18822 }
18823 {
18824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18825 }
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18833 PyObject *resultobj;
18834 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18835 int result;
18836 PyObject * obj0 = 0 ;
18837 char *kwnames[] = {
18838 (char *) "cal", NULL
18839 };
18840
18841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18842 if (obj0) {
18843 {
18844 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18845 if (SWIG_arg_fail(1)) SWIG_fail;
18846 }
18847 }
18848 {
18849 PyThreadState* __tstate = wxPyBeginAllowThreads();
18850 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18851
18852 wxPyEndAllowThreads(__tstate);
18853 if (PyErr_Occurred()) SWIG_fail;
18854 }
18855 {
18856 resultobj = SWIG_From_int((int)(result));
18857 }
18858 return resultobj;
18859 fail:
18860 return NULL;
18861 }
18862
18863
18864 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18865 PyObject *resultobj;
18866 int arg1 ;
18867 int result;
18868 PyObject * obj0 = 0 ;
18869 char *kwnames[] = {
18870 (char *) "year", NULL
18871 };
18872
18873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18874 {
18875 arg1 = (int)(SWIG_As_int(obj0));
18876 if (SWIG_arg_fail(1)) SWIG_fail;
18877 }
18878 {
18879 PyThreadState* __tstate = wxPyBeginAllowThreads();
18880 result = (int)wxDateTime::ConvertYearToBC(arg1);
18881
18882 wxPyEndAllowThreads(__tstate);
18883 if (PyErr_Occurred()) SWIG_fail;
18884 }
18885 {
18886 resultobj = SWIG_From_int((int)(result));
18887 }
18888 return resultobj;
18889 fail:
18890 return NULL;
18891 }
18892
18893
18894 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18895 PyObject *resultobj;
18896 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18897 wxDateTime::Month result;
18898 PyObject * obj0 = 0 ;
18899 char *kwnames[] = {
18900 (char *) "cal", NULL
18901 };
18902
18903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18904 if (obj0) {
18905 {
18906 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 }
18909 }
18910 {
18911 PyThreadState* __tstate = wxPyBeginAllowThreads();
18912 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18913
18914 wxPyEndAllowThreads(__tstate);
18915 if (PyErr_Occurred()) SWIG_fail;
18916 }
18917 resultobj = SWIG_From_int((result));
18918 return resultobj;
18919 fail:
18920 return NULL;
18921 }
18922
18923
18924 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18925 PyObject *resultobj;
18926 int arg1 = (int) wxDateTime::Inv_Year ;
18927 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18928 bool result;
18929 PyObject * obj0 = 0 ;
18930 PyObject * obj1 = 0 ;
18931 char *kwnames[] = {
18932 (char *) "year",(char *) "cal", NULL
18933 };
18934
18935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18936 if (obj0) {
18937 {
18938 arg1 = (int)(SWIG_As_int(obj0));
18939 if (SWIG_arg_fail(1)) SWIG_fail;
18940 }
18941 }
18942 if (obj1) {
18943 {
18944 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18945 if (SWIG_arg_fail(2)) SWIG_fail;
18946 }
18947 }
18948 {
18949 PyThreadState* __tstate = wxPyBeginAllowThreads();
18950 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18951
18952 wxPyEndAllowThreads(__tstate);
18953 if (PyErr_Occurred()) SWIG_fail;
18954 }
18955 {
18956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18957 }
18958 return resultobj;
18959 fail:
18960 return NULL;
18961 }
18962
18963
18964 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18965 PyObject *resultobj;
18966 int arg1 = (int) wxDateTime::Inv_Year ;
18967 int result;
18968 PyObject * obj0 = 0 ;
18969 char *kwnames[] = {
18970 (char *) "year", NULL
18971 };
18972
18973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18974 if (obj0) {
18975 {
18976 arg1 = (int)(SWIG_As_int(obj0));
18977 if (SWIG_arg_fail(1)) SWIG_fail;
18978 }
18979 }
18980 {
18981 PyThreadState* __tstate = wxPyBeginAllowThreads();
18982 result = (int)wxDateTime::GetCentury(arg1);
18983
18984 wxPyEndAllowThreads(__tstate);
18985 if (PyErr_Occurred()) SWIG_fail;
18986 }
18987 {
18988 resultobj = SWIG_From_int((int)(result));
18989 }
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
18997 PyObject *resultobj;
18998 int arg1 ;
18999 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19000 int result;
19001 PyObject * obj0 = 0 ;
19002 PyObject * obj1 = 0 ;
19003 char *kwnames[] = {
19004 (char *) "year",(char *) "cal", NULL
19005 };
19006
19007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19008 {
19009 arg1 = (int)(SWIG_As_int(obj0));
19010 if (SWIG_arg_fail(1)) SWIG_fail;
19011 }
19012 if (obj1) {
19013 {
19014 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19015 if (SWIG_arg_fail(2)) SWIG_fail;
19016 }
19017 }
19018 {
19019 PyThreadState* __tstate = wxPyBeginAllowThreads();
19020 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19021
19022 wxPyEndAllowThreads(__tstate);
19023 if (PyErr_Occurred()) SWIG_fail;
19024 }
19025 {
19026 resultobj = SWIG_From_int((int)(result));
19027 }
19028 return resultobj;
19029 fail:
19030 return NULL;
19031 }
19032
19033
19034 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj;
19036 wxDateTime::Month arg1 ;
19037 int arg2 = (int) wxDateTime::Inv_Year ;
19038 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19039 int result;
19040 PyObject * obj0 = 0 ;
19041 PyObject * obj1 = 0 ;
19042 PyObject * obj2 = 0 ;
19043 char *kwnames[] = {
19044 (char *) "month",(char *) "year",(char *) "cal", NULL
19045 };
19046
19047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19048 {
19049 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19050 if (SWIG_arg_fail(1)) SWIG_fail;
19051 }
19052 if (obj1) {
19053 {
19054 arg2 = (int)(SWIG_As_int(obj1));
19055 if (SWIG_arg_fail(2)) SWIG_fail;
19056 }
19057 }
19058 if (obj2) {
19059 {
19060 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19061 if (SWIG_arg_fail(3)) SWIG_fail;
19062 }
19063 }
19064 {
19065 PyThreadState* __tstate = wxPyBeginAllowThreads();
19066 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19067
19068 wxPyEndAllowThreads(__tstate);
19069 if (PyErr_Occurred()) SWIG_fail;
19070 }
19071 {
19072 resultobj = SWIG_From_int((int)(result));
19073 }
19074 return resultobj;
19075 fail:
19076 return NULL;
19077 }
19078
19079
19080 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19081 PyObject *resultobj;
19082 wxDateTime::Month arg1 ;
19083 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19084 wxString result;
19085 PyObject * obj0 = 0 ;
19086 PyObject * obj1 = 0 ;
19087 char *kwnames[] = {
19088 (char *) "month",(char *) "flags", NULL
19089 };
19090
19091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19092 {
19093 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19094 if (SWIG_arg_fail(1)) SWIG_fail;
19095 }
19096 if (obj1) {
19097 {
19098 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19099 if (SWIG_arg_fail(2)) SWIG_fail;
19100 }
19101 }
19102 {
19103 PyThreadState* __tstate = wxPyBeginAllowThreads();
19104 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19105
19106 wxPyEndAllowThreads(__tstate);
19107 if (PyErr_Occurred()) SWIG_fail;
19108 }
19109 {
19110 #if wxUSE_UNICODE
19111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19112 #else
19113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19114 #endif
19115 }
19116 return resultobj;
19117 fail:
19118 return NULL;
19119 }
19120
19121
19122 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19123 PyObject *resultobj;
19124 wxDateTime::WeekDay arg1 ;
19125 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19126 wxString result;
19127 PyObject * obj0 = 0 ;
19128 PyObject * obj1 = 0 ;
19129 char *kwnames[] = {
19130 (char *) "weekday",(char *) "flags", NULL
19131 };
19132
19133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19134 {
19135 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19136 if (SWIG_arg_fail(1)) SWIG_fail;
19137 }
19138 if (obj1) {
19139 {
19140 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19141 if (SWIG_arg_fail(2)) SWIG_fail;
19142 }
19143 }
19144 {
19145 PyThreadState* __tstate = wxPyBeginAllowThreads();
19146 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19147
19148 wxPyEndAllowThreads(__tstate);
19149 if (PyErr_Occurred()) SWIG_fail;
19150 }
19151 {
19152 #if wxUSE_UNICODE
19153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19154 #else
19155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19156 #endif
19157 }
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19165 PyObject *resultobj;
19166 wxString *arg1 = (wxString *) 0 ;
19167 wxString *arg2 = (wxString *) 0 ;
19168 bool temp1 = false ;
19169 bool temp2 = false ;
19170 PyObject * obj0 = 0 ;
19171 PyObject * obj1 = 0 ;
19172 char *kwnames[] = {
19173 (char *) "OUTPUT",(char *) "OUTPUT", NULL
19174 };
19175
19176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
19177 {
19178 arg1 = wxString_in_helper(obj0);
19179 if (arg1 == NULL) SWIG_fail;
19180 temp1 = true;
19181 }
19182 {
19183 arg2 = wxString_in_helper(obj1);
19184 if (arg2 == NULL) SWIG_fail;
19185 temp2 = true;
19186 }
19187 {
19188 PyThreadState* __tstate = wxPyBeginAllowThreads();
19189 wxDateTime::GetAmPmStrings(arg1,arg2);
19190
19191 wxPyEndAllowThreads(__tstate);
19192 if (PyErr_Occurred()) SWIG_fail;
19193 }
19194 Py_INCREF(Py_None); resultobj = Py_None;
19195 {
19196 if (temp1)
19197 delete arg1;
19198 }
19199 {
19200 if (temp2)
19201 delete arg2;
19202 }
19203 return resultobj;
19204 fail:
19205 {
19206 if (temp1)
19207 delete arg1;
19208 }
19209 {
19210 if (temp2)
19211 delete arg2;
19212 }
19213 return NULL;
19214 }
19215
19216
19217 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19218 PyObject *resultobj;
19219 int arg1 = (int) wxDateTime::Inv_Year ;
19220 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19221 bool result;
19222 PyObject * obj0 = 0 ;
19223 PyObject * obj1 = 0 ;
19224 char *kwnames[] = {
19225 (char *) "year",(char *) "country", NULL
19226 };
19227
19228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19229 if (obj0) {
19230 {
19231 arg1 = (int)(SWIG_As_int(obj0));
19232 if (SWIG_arg_fail(1)) SWIG_fail;
19233 }
19234 }
19235 if (obj1) {
19236 {
19237 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19238 if (SWIG_arg_fail(2)) SWIG_fail;
19239 }
19240 }
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19244
19245 wxPyEndAllowThreads(__tstate);
19246 if (PyErr_Occurred()) SWIG_fail;
19247 }
19248 {
19249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19250 }
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19258 PyObject *resultobj;
19259 int arg1 = (int) wxDateTime::Inv_Year ;
19260 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19261 wxDateTime result;
19262 PyObject * obj0 = 0 ;
19263 PyObject * obj1 = 0 ;
19264 char *kwnames[] = {
19265 (char *) "year",(char *) "country", NULL
19266 };
19267
19268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19269 if (obj0) {
19270 {
19271 arg1 = (int)(SWIG_As_int(obj0));
19272 if (SWIG_arg_fail(1)) SWIG_fail;
19273 }
19274 }
19275 if (obj1) {
19276 {
19277 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19278 if (SWIG_arg_fail(2)) SWIG_fail;
19279 }
19280 }
19281 {
19282 PyThreadState* __tstate = wxPyBeginAllowThreads();
19283 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19284
19285 wxPyEndAllowThreads(__tstate);
19286 if (PyErr_Occurred()) SWIG_fail;
19287 }
19288 {
19289 wxDateTime * resultptr;
19290 resultptr = new wxDateTime((wxDateTime &)(result));
19291 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19292 }
19293 return resultobj;
19294 fail:
19295 return NULL;
19296 }
19297
19298
19299 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19300 PyObject *resultobj;
19301 int arg1 = (int) wxDateTime::Inv_Year ;
19302 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19303 wxDateTime result;
19304 PyObject * obj0 = 0 ;
19305 PyObject * obj1 = 0 ;
19306 char *kwnames[] = {
19307 (char *) "year",(char *) "country", NULL
19308 };
19309
19310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19311 if (obj0) {
19312 {
19313 arg1 = (int)(SWIG_As_int(obj0));
19314 if (SWIG_arg_fail(1)) SWIG_fail;
19315 }
19316 }
19317 if (obj1) {
19318 {
19319 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19320 if (SWIG_arg_fail(2)) SWIG_fail;
19321 }
19322 }
19323 {
19324 PyThreadState* __tstate = wxPyBeginAllowThreads();
19325 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19326
19327 wxPyEndAllowThreads(__tstate);
19328 if (PyErr_Occurred()) SWIG_fail;
19329 }
19330 {
19331 wxDateTime * resultptr;
19332 resultptr = new wxDateTime((wxDateTime &)(result));
19333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19334 }
19335 return resultobj;
19336 fail:
19337 return NULL;
19338 }
19339
19340
19341 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19342 PyObject *resultobj;
19343 wxDateTime result;
19344 char *kwnames[] = {
19345 NULL
19346 };
19347
19348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19349 {
19350 PyThreadState* __tstate = wxPyBeginAllowThreads();
19351 result = wxDateTime::Now();
19352
19353 wxPyEndAllowThreads(__tstate);
19354 if (PyErr_Occurred()) SWIG_fail;
19355 }
19356 {
19357 wxDateTime * resultptr;
19358 resultptr = new wxDateTime((wxDateTime &)(result));
19359 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19360 }
19361 return resultobj;
19362 fail:
19363 return NULL;
19364 }
19365
19366
19367 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19368 PyObject *resultobj;
19369 wxDateTime result;
19370 char *kwnames[] = {
19371 NULL
19372 };
19373
19374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19375 {
19376 PyThreadState* __tstate = wxPyBeginAllowThreads();
19377 result = wxDateTime::UNow();
19378
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 {
19383 wxDateTime * resultptr;
19384 resultptr = new wxDateTime((wxDateTime &)(result));
19385 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19386 }
19387 return resultobj;
19388 fail:
19389 return NULL;
19390 }
19391
19392
19393 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19394 PyObject *resultobj;
19395 wxDateTime result;
19396 char *kwnames[] = {
19397 NULL
19398 };
19399
19400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19401 {
19402 PyThreadState* __tstate = wxPyBeginAllowThreads();
19403 result = wxDateTime::Today();
19404
19405 wxPyEndAllowThreads(__tstate);
19406 if (PyErr_Occurred()) SWIG_fail;
19407 }
19408 {
19409 wxDateTime * resultptr;
19410 resultptr = new wxDateTime((wxDateTime &)(result));
19411 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19412 }
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj;
19421 wxDateTime *result;
19422 char *kwnames[] = {
19423 NULL
19424 };
19425
19426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19427 {
19428 PyThreadState* __tstate = wxPyBeginAllowThreads();
19429 result = (wxDateTime *)new wxDateTime();
19430
19431 wxPyEndAllowThreads(__tstate);
19432 if (PyErr_Occurred()) SWIG_fail;
19433 }
19434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19435 return resultobj;
19436 fail:
19437 return NULL;
19438 }
19439
19440
19441 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19442 PyObject *resultobj;
19443 time_t arg1 ;
19444 wxDateTime *result;
19445 PyObject * obj0 = 0 ;
19446 char *kwnames[] = {
19447 (char *) "timet", NULL
19448 };
19449
19450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19451 {
19452 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19453 if (SWIG_arg_fail(1)) SWIG_fail;
19454 }
19455 {
19456 PyThreadState* __tstate = wxPyBeginAllowThreads();
19457 result = (wxDateTime *)new wxDateTime(arg1);
19458
19459 wxPyEndAllowThreads(__tstate);
19460 if (PyErr_Occurred()) SWIG_fail;
19461 }
19462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19463 return resultobj;
19464 fail:
19465 return NULL;
19466 }
19467
19468
19469 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19470 PyObject *resultobj;
19471 double arg1 ;
19472 wxDateTime *result;
19473 PyObject * obj0 = 0 ;
19474 char *kwnames[] = {
19475 (char *) "jdn", NULL
19476 };
19477
19478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19479 {
19480 arg1 = (double)(SWIG_As_double(obj0));
19481 if (SWIG_arg_fail(1)) SWIG_fail;
19482 }
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 result = (wxDateTime *)new wxDateTime(arg1);
19486
19487 wxPyEndAllowThreads(__tstate);
19488 if (PyErr_Occurred()) SWIG_fail;
19489 }
19490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19491 return resultobj;
19492 fail:
19493 return NULL;
19494 }
19495
19496
19497 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19498 PyObject *resultobj;
19499 int arg1 ;
19500 int arg2 = (int) 0 ;
19501 int arg3 = (int) 0 ;
19502 int arg4 = (int) 0 ;
19503 wxDateTime *result;
19504 PyObject * obj0 = 0 ;
19505 PyObject * obj1 = 0 ;
19506 PyObject * obj2 = 0 ;
19507 PyObject * obj3 = 0 ;
19508 char *kwnames[] = {
19509 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19510 };
19511
19512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19513 {
19514 arg1 = (int)(SWIG_As_int(obj0));
19515 if (SWIG_arg_fail(1)) SWIG_fail;
19516 }
19517 if (obj1) {
19518 {
19519 arg2 = (int)(SWIG_As_int(obj1));
19520 if (SWIG_arg_fail(2)) SWIG_fail;
19521 }
19522 }
19523 if (obj2) {
19524 {
19525 arg3 = (int)(SWIG_As_int(obj2));
19526 if (SWIG_arg_fail(3)) SWIG_fail;
19527 }
19528 }
19529 if (obj3) {
19530 {
19531 arg4 = (int)(SWIG_As_int(obj3));
19532 if (SWIG_arg_fail(4)) SWIG_fail;
19533 }
19534 }
19535 {
19536 PyThreadState* __tstate = wxPyBeginAllowThreads();
19537 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19538
19539 wxPyEndAllowThreads(__tstate);
19540 if (PyErr_Occurred()) SWIG_fail;
19541 }
19542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19543 return resultobj;
19544 fail:
19545 return NULL;
19546 }
19547
19548
19549 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19550 PyObject *resultobj;
19551 int arg1 ;
19552 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19553 int arg3 = (int) wxDateTime::Inv_Year ;
19554 int arg4 = (int) 0 ;
19555 int arg5 = (int) 0 ;
19556 int arg6 = (int) 0 ;
19557 int arg7 = (int) 0 ;
19558 wxDateTime *result;
19559 PyObject * obj0 = 0 ;
19560 PyObject * obj1 = 0 ;
19561 PyObject * obj2 = 0 ;
19562 PyObject * obj3 = 0 ;
19563 PyObject * obj4 = 0 ;
19564 PyObject * obj5 = 0 ;
19565 PyObject * obj6 = 0 ;
19566 char *kwnames[] = {
19567 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19568 };
19569
19570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19571 {
19572 arg1 = (int)(SWIG_As_int(obj0));
19573 if (SWIG_arg_fail(1)) SWIG_fail;
19574 }
19575 if (obj1) {
19576 {
19577 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19578 if (SWIG_arg_fail(2)) SWIG_fail;
19579 }
19580 }
19581 if (obj2) {
19582 {
19583 arg3 = (int)(SWIG_As_int(obj2));
19584 if (SWIG_arg_fail(3)) SWIG_fail;
19585 }
19586 }
19587 if (obj3) {
19588 {
19589 arg4 = (int)(SWIG_As_int(obj3));
19590 if (SWIG_arg_fail(4)) SWIG_fail;
19591 }
19592 }
19593 if (obj4) {
19594 {
19595 arg5 = (int)(SWIG_As_int(obj4));
19596 if (SWIG_arg_fail(5)) SWIG_fail;
19597 }
19598 }
19599 if (obj5) {
19600 {
19601 arg6 = (int)(SWIG_As_int(obj5));
19602 if (SWIG_arg_fail(6)) SWIG_fail;
19603 }
19604 }
19605 if (obj6) {
19606 {
19607 arg7 = (int)(SWIG_As_int(obj6));
19608 if (SWIG_arg_fail(7)) SWIG_fail;
19609 }
19610 }
19611 {
19612 PyThreadState* __tstate = wxPyBeginAllowThreads();
19613 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19614
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj;
19627 wxDateTime *arg1 = (wxDateTime *) 0 ;
19628 PyObject * obj0 = 0 ;
19629 char *kwnames[] = {
19630 (char *) "self", NULL
19631 };
19632
19633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19635 if (SWIG_arg_fail(1)) SWIG_fail;
19636 {
19637 PyThreadState* __tstate = wxPyBeginAllowThreads();
19638 delete arg1;
19639
19640 wxPyEndAllowThreads(__tstate);
19641 if (PyErr_Occurred()) SWIG_fail;
19642 }
19643 Py_INCREF(Py_None); resultobj = Py_None;
19644 return resultobj;
19645 fail:
19646 return NULL;
19647 }
19648
19649
19650 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19651 PyObject *resultobj;
19652 wxDateTime *arg1 = (wxDateTime *) 0 ;
19653 wxDateTime *result;
19654 PyObject * obj0 = 0 ;
19655 char *kwnames[] = {
19656 (char *) "self", NULL
19657 };
19658
19659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19661 if (SWIG_arg_fail(1)) SWIG_fail;
19662 {
19663 PyThreadState* __tstate = wxPyBeginAllowThreads();
19664 {
19665 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19666 result = (wxDateTime *) &_result_ref;
19667 }
19668
19669 wxPyEndAllowThreads(__tstate);
19670 if (PyErr_Occurred()) SWIG_fail;
19671 }
19672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19673 return resultobj;
19674 fail:
19675 return NULL;
19676 }
19677
19678
19679 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19680 PyObject *resultobj;
19681 wxDateTime *arg1 = (wxDateTime *) 0 ;
19682 time_t arg2 ;
19683 wxDateTime *result;
19684 PyObject * obj0 = 0 ;
19685 PyObject * obj1 = 0 ;
19686 char *kwnames[] = {
19687 (char *) "self",(char *) "timet", NULL
19688 };
19689
19690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19692 if (SWIG_arg_fail(1)) SWIG_fail;
19693 {
19694 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19695 if (SWIG_arg_fail(2)) SWIG_fail;
19696 }
19697 {
19698 PyThreadState* __tstate = wxPyBeginAllowThreads();
19699 {
19700 wxDateTime &_result_ref = (arg1)->Set(arg2);
19701 result = (wxDateTime *) &_result_ref;
19702 }
19703
19704 wxPyEndAllowThreads(__tstate);
19705 if (PyErr_Occurred()) SWIG_fail;
19706 }
19707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19708 return resultobj;
19709 fail:
19710 return NULL;
19711 }
19712
19713
19714 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19715 PyObject *resultobj;
19716 wxDateTime *arg1 = (wxDateTime *) 0 ;
19717 double arg2 ;
19718 wxDateTime *result;
19719 PyObject * obj0 = 0 ;
19720 PyObject * obj1 = 0 ;
19721 char *kwnames[] = {
19722 (char *) "self",(char *) "jdn", NULL
19723 };
19724
19725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19727 if (SWIG_arg_fail(1)) SWIG_fail;
19728 {
19729 arg2 = (double)(SWIG_As_double(obj1));
19730 if (SWIG_arg_fail(2)) SWIG_fail;
19731 }
19732 {
19733 PyThreadState* __tstate = wxPyBeginAllowThreads();
19734 {
19735 wxDateTime &_result_ref = (arg1)->Set(arg2);
19736 result = (wxDateTime *) &_result_ref;
19737 }
19738
19739 wxPyEndAllowThreads(__tstate);
19740 if (PyErr_Occurred()) SWIG_fail;
19741 }
19742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19743 return resultobj;
19744 fail:
19745 return NULL;
19746 }
19747
19748
19749 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19750 PyObject *resultobj;
19751 wxDateTime *arg1 = (wxDateTime *) 0 ;
19752 int arg2 ;
19753 int arg3 = (int) 0 ;
19754 int arg4 = (int) 0 ;
19755 int arg5 = (int) 0 ;
19756 wxDateTime *result;
19757 PyObject * obj0 = 0 ;
19758 PyObject * obj1 = 0 ;
19759 PyObject * obj2 = 0 ;
19760 PyObject * obj3 = 0 ;
19761 PyObject * obj4 = 0 ;
19762 char *kwnames[] = {
19763 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19764 };
19765
19766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19768 if (SWIG_arg_fail(1)) SWIG_fail;
19769 {
19770 arg2 = (int)(SWIG_As_int(obj1));
19771 if (SWIG_arg_fail(2)) SWIG_fail;
19772 }
19773 if (obj2) {
19774 {
19775 arg3 = (int)(SWIG_As_int(obj2));
19776 if (SWIG_arg_fail(3)) SWIG_fail;
19777 }
19778 }
19779 if (obj3) {
19780 {
19781 arg4 = (int)(SWIG_As_int(obj3));
19782 if (SWIG_arg_fail(4)) SWIG_fail;
19783 }
19784 }
19785 if (obj4) {
19786 {
19787 arg5 = (int)(SWIG_As_int(obj4));
19788 if (SWIG_arg_fail(5)) SWIG_fail;
19789 }
19790 }
19791 {
19792 PyThreadState* __tstate = wxPyBeginAllowThreads();
19793 {
19794 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19795 result = (wxDateTime *) &_result_ref;
19796 }
19797
19798 wxPyEndAllowThreads(__tstate);
19799 if (PyErr_Occurred()) SWIG_fail;
19800 }
19801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19802 return resultobj;
19803 fail:
19804 return NULL;
19805 }
19806
19807
19808 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19809 PyObject *resultobj;
19810 wxDateTime *arg1 = (wxDateTime *) 0 ;
19811 int arg2 ;
19812 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19813 int arg4 = (int) wxDateTime::Inv_Year ;
19814 int arg5 = (int) 0 ;
19815 int arg6 = (int) 0 ;
19816 int arg7 = (int) 0 ;
19817 int arg8 = (int) 0 ;
19818 wxDateTime *result;
19819 PyObject * obj0 = 0 ;
19820 PyObject * obj1 = 0 ;
19821 PyObject * obj2 = 0 ;
19822 PyObject * obj3 = 0 ;
19823 PyObject * obj4 = 0 ;
19824 PyObject * obj5 = 0 ;
19825 PyObject * obj6 = 0 ;
19826 PyObject * obj7 = 0 ;
19827 char *kwnames[] = {
19828 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19829 };
19830
19831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19833 if (SWIG_arg_fail(1)) SWIG_fail;
19834 {
19835 arg2 = (int)(SWIG_As_int(obj1));
19836 if (SWIG_arg_fail(2)) SWIG_fail;
19837 }
19838 if (obj2) {
19839 {
19840 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19841 if (SWIG_arg_fail(3)) SWIG_fail;
19842 }
19843 }
19844 if (obj3) {
19845 {
19846 arg4 = (int)(SWIG_As_int(obj3));
19847 if (SWIG_arg_fail(4)) SWIG_fail;
19848 }
19849 }
19850 if (obj4) {
19851 {
19852 arg5 = (int)(SWIG_As_int(obj4));
19853 if (SWIG_arg_fail(5)) SWIG_fail;
19854 }
19855 }
19856 if (obj5) {
19857 {
19858 arg6 = (int)(SWIG_As_int(obj5));
19859 if (SWIG_arg_fail(6)) SWIG_fail;
19860 }
19861 }
19862 if (obj6) {
19863 {
19864 arg7 = (int)(SWIG_As_int(obj6));
19865 if (SWIG_arg_fail(7)) SWIG_fail;
19866 }
19867 }
19868 if (obj7) {
19869 {
19870 arg8 = (int)(SWIG_As_int(obj7));
19871 if (SWIG_arg_fail(8)) SWIG_fail;
19872 }
19873 }
19874 {
19875 PyThreadState* __tstate = wxPyBeginAllowThreads();
19876 {
19877 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19878 result = (wxDateTime *) &_result_ref;
19879 }
19880
19881 wxPyEndAllowThreads(__tstate);
19882 if (PyErr_Occurred()) SWIG_fail;
19883 }
19884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19885 return resultobj;
19886 fail:
19887 return NULL;
19888 }
19889
19890
19891 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19892 PyObject *resultobj;
19893 wxDateTime *arg1 = (wxDateTime *) 0 ;
19894 wxDateTime *result;
19895 PyObject * obj0 = 0 ;
19896 char *kwnames[] = {
19897 (char *) "self", NULL
19898 };
19899
19900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19902 if (SWIG_arg_fail(1)) SWIG_fail;
19903 {
19904 PyThreadState* __tstate = wxPyBeginAllowThreads();
19905 {
19906 wxDateTime &_result_ref = (arg1)->ResetTime();
19907 result = (wxDateTime *) &_result_ref;
19908 }
19909
19910 wxPyEndAllowThreads(__tstate);
19911 if (PyErr_Occurred()) SWIG_fail;
19912 }
19913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19914 return resultobj;
19915 fail:
19916 return NULL;
19917 }
19918
19919
19920 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19921 PyObject *resultobj;
19922 wxDateTime *arg1 = (wxDateTime *) 0 ;
19923 int arg2 ;
19924 wxDateTime *result;
19925 PyObject * obj0 = 0 ;
19926 PyObject * obj1 = 0 ;
19927 char *kwnames[] = {
19928 (char *) "self",(char *) "year", NULL
19929 };
19930
19931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19933 if (SWIG_arg_fail(1)) SWIG_fail;
19934 {
19935 arg2 = (int)(SWIG_As_int(obj1));
19936 if (SWIG_arg_fail(2)) SWIG_fail;
19937 }
19938 {
19939 PyThreadState* __tstate = wxPyBeginAllowThreads();
19940 {
19941 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19942 result = (wxDateTime *) &_result_ref;
19943 }
19944
19945 wxPyEndAllowThreads(__tstate);
19946 if (PyErr_Occurred()) SWIG_fail;
19947 }
19948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19949 return resultobj;
19950 fail:
19951 return NULL;
19952 }
19953
19954
19955 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19956 PyObject *resultobj;
19957 wxDateTime *arg1 = (wxDateTime *) 0 ;
19958 wxDateTime::Month arg2 ;
19959 wxDateTime *result;
19960 PyObject * obj0 = 0 ;
19961 PyObject * obj1 = 0 ;
19962 char *kwnames[] = {
19963 (char *) "self",(char *) "month", NULL
19964 };
19965
19966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19968 if (SWIG_arg_fail(1)) SWIG_fail;
19969 {
19970 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19971 if (SWIG_arg_fail(2)) SWIG_fail;
19972 }
19973 {
19974 PyThreadState* __tstate = wxPyBeginAllowThreads();
19975 {
19976 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19977 result = (wxDateTime *) &_result_ref;
19978 }
19979
19980 wxPyEndAllowThreads(__tstate);
19981 if (PyErr_Occurred()) SWIG_fail;
19982 }
19983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19984 return resultobj;
19985 fail:
19986 return NULL;
19987 }
19988
19989
19990 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
19991 PyObject *resultobj;
19992 wxDateTime *arg1 = (wxDateTime *) 0 ;
19993 int arg2 ;
19994 wxDateTime *result;
19995 PyObject * obj0 = 0 ;
19996 PyObject * obj1 = 0 ;
19997 char *kwnames[] = {
19998 (char *) "self",(char *) "day", NULL
19999 };
20000
20001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20003 if (SWIG_arg_fail(1)) SWIG_fail;
20004 {
20005 arg2 = (int)(SWIG_As_int(obj1));
20006 if (SWIG_arg_fail(2)) SWIG_fail;
20007 }
20008 {
20009 PyThreadState* __tstate = wxPyBeginAllowThreads();
20010 {
20011 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20012 result = (wxDateTime *) &_result_ref;
20013 }
20014
20015 wxPyEndAllowThreads(__tstate);
20016 if (PyErr_Occurred()) SWIG_fail;
20017 }
20018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20019 return resultobj;
20020 fail:
20021 return NULL;
20022 }
20023
20024
20025 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20026 PyObject *resultobj;
20027 wxDateTime *arg1 = (wxDateTime *) 0 ;
20028 int arg2 ;
20029 wxDateTime *result;
20030 PyObject * obj0 = 0 ;
20031 PyObject * obj1 = 0 ;
20032 char *kwnames[] = {
20033 (char *) "self",(char *) "hour", NULL
20034 };
20035
20036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20038 if (SWIG_arg_fail(1)) SWIG_fail;
20039 {
20040 arg2 = (int)(SWIG_As_int(obj1));
20041 if (SWIG_arg_fail(2)) SWIG_fail;
20042 }
20043 {
20044 PyThreadState* __tstate = wxPyBeginAllowThreads();
20045 {
20046 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20047 result = (wxDateTime *) &_result_ref;
20048 }
20049
20050 wxPyEndAllowThreads(__tstate);
20051 if (PyErr_Occurred()) SWIG_fail;
20052 }
20053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20054 return resultobj;
20055 fail:
20056 return NULL;
20057 }
20058
20059
20060 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20061 PyObject *resultobj;
20062 wxDateTime *arg1 = (wxDateTime *) 0 ;
20063 int arg2 ;
20064 wxDateTime *result;
20065 PyObject * obj0 = 0 ;
20066 PyObject * obj1 = 0 ;
20067 char *kwnames[] = {
20068 (char *) "self",(char *) "minute", NULL
20069 };
20070
20071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20073 if (SWIG_arg_fail(1)) SWIG_fail;
20074 {
20075 arg2 = (int)(SWIG_As_int(obj1));
20076 if (SWIG_arg_fail(2)) SWIG_fail;
20077 }
20078 {
20079 PyThreadState* __tstate = wxPyBeginAllowThreads();
20080 {
20081 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20082 result = (wxDateTime *) &_result_ref;
20083 }
20084
20085 wxPyEndAllowThreads(__tstate);
20086 if (PyErr_Occurred()) SWIG_fail;
20087 }
20088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20089 return resultobj;
20090 fail:
20091 return NULL;
20092 }
20093
20094
20095 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20096 PyObject *resultobj;
20097 wxDateTime *arg1 = (wxDateTime *) 0 ;
20098 int arg2 ;
20099 wxDateTime *result;
20100 PyObject * obj0 = 0 ;
20101 PyObject * obj1 = 0 ;
20102 char *kwnames[] = {
20103 (char *) "self",(char *) "second", NULL
20104 };
20105
20106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20108 if (SWIG_arg_fail(1)) SWIG_fail;
20109 {
20110 arg2 = (int)(SWIG_As_int(obj1));
20111 if (SWIG_arg_fail(2)) SWIG_fail;
20112 }
20113 {
20114 PyThreadState* __tstate = wxPyBeginAllowThreads();
20115 {
20116 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20117 result = (wxDateTime *) &_result_ref;
20118 }
20119
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20124 return resultobj;
20125 fail:
20126 return NULL;
20127 }
20128
20129
20130 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20131 PyObject *resultobj;
20132 wxDateTime *arg1 = (wxDateTime *) 0 ;
20133 int arg2 ;
20134 wxDateTime *result;
20135 PyObject * obj0 = 0 ;
20136 PyObject * obj1 = 0 ;
20137 char *kwnames[] = {
20138 (char *) "self",(char *) "millisecond", NULL
20139 };
20140
20141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20143 if (SWIG_arg_fail(1)) SWIG_fail;
20144 {
20145 arg2 = (int)(SWIG_As_int(obj1));
20146 if (SWIG_arg_fail(2)) SWIG_fail;
20147 }
20148 {
20149 PyThreadState* __tstate = wxPyBeginAllowThreads();
20150 {
20151 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20152 result = (wxDateTime *) &_result_ref;
20153 }
20154
20155 wxPyEndAllowThreads(__tstate);
20156 if (PyErr_Occurred()) SWIG_fail;
20157 }
20158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20159 return resultobj;
20160 fail:
20161 return NULL;
20162 }
20163
20164
20165 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20166 PyObject *resultobj;
20167 wxDateTime *arg1 = (wxDateTime *) 0 ;
20168 wxDateTime::WeekDay arg2 ;
20169 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20170 wxDateTime *result;
20171 PyObject * obj0 = 0 ;
20172 PyObject * obj1 = 0 ;
20173 PyObject * obj2 = 0 ;
20174 char *kwnames[] = {
20175 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20176 };
20177
20178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20180 if (SWIG_arg_fail(1)) SWIG_fail;
20181 {
20182 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20183 if (SWIG_arg_fail(2)) SWIG_fail;
20184 }
20185 if (obj2) {
20186 {
20187 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20188 if (SWIG_arg_fail(3)) SWIG_fail;
20189 }
20190 }
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 {
20194 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20195 result = (wxDateTime *) &_result_ref;
20196 }
20197
20198 wxPyEndAllowThreads(__tstate);
20199 if (PyErr_Occurred()) SWIG_fail;
20200 }
20201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20202 return resultobj;
20203 fail:
20204 return NULL;
20205 }
20206
20207
20208 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20209 PyObject *resultobj;
20210 wxDateTime *arg1 = (wxDateTime *) 0 ;
20211 wxDateTime::WeekDay arg2 ;
20212 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20213 wxDateTime result;
20214 PyObject * obj0 = 0 ;
20215 PyObject * obj1 = 0 ;
20216 PyObject * obj2 = 0 ;
20217 char *kwnames[] = {
20218 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20219 };
20220
20221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20223 if (SWIG_arg_fail(1)) SWIG_fail;
20224 {
20225 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20226 if (SWIG_arg_fail(2)) SWIG_fail;
20227 }
20228 if (obj2) {
20229 {
20230 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20231 if (SWIG_arg_fail(3)) SWIG_fail;
20232 }
20233 }
20234 {
20235 PyThreadState* __tstate = wxPyBeginAllowThreads();
20236 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20237
20238 wxPyEndAllowThreads(__tstate);
20239 if (PyErr_Occurred()) SWIG_fail;
20240 }
20241 {
20242 wxDateTime * resultptr;
20243 resultptr = new wxDateTime((wxDateTime &)(result));
20244 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20245 }
20246 return resultobj;
20247 fail:
20248 return NULL;
20249 }
20250
20251
20252 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20253 PyObject *resultobj;
20254 wxDateTime *arg1 = (wxDateTime *) 0 ;
20255 wxDateTime::WeekDay arg2 ;
20256 wxDateTime *result;
20257 PyObject * obj0 = 0 ;
20258 PyObject * obj1 = 0 ;
20259 char *kwnames[] = {
20260 (char *) "self",(char *) "weekday", NULL
20261 };
20262
20263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20265 if (SWIG_arg_fail(1)) SWIG_fail;
20266 {
20267 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20268 if (SWIG_arg_fail(2)) SWIG_fail;
20269 }
20270 {
20271 PyThreadState* __tstate = wxPyBeginAllowThreads();
20272 {
20273 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20274 result = (wxDateTime *) &_result_ref;
20275 }
20276
20277 wxPyEndAllowThreads(__tstate);
20278 if (PyErr_Occurred()) SWIG_fail;
20279 }
20280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20281 return resultobj;
20282 fail:
20283 return NULL;
20284 }
20285
20286
20287 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20288 PyObject *resultobj;
20289 wxDateTime *arg1 = (wxDateTime *) 0 ;
20290 wxDateTime::WeekDay arg2 ;
20291 wxDateTime result;
20292 PyObject * obj0 = 0 ;
20293 PyObject * obj1 = 0 ;
20294 char *kwnames[] = {
20295 (char *) "self",(char *) "weekday", NULL
20296 };
20297
20298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20300 if (SWIG_arg_fail(1)) SWIG_fail;
20301 {
20302 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20303 if (SWIG_arg_fail(2)) SWIG_fail;
20304 }
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20308
20309 wxPyEndAllowThreads(__tstate);
20310 if (PyErr_Occurred()) SWIG_fail;
20311 }
20312 {
20313 wxDateTime * resultptr;
20314 resultptr = new wxDateTime((wxDateTime &)(result));
20315 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20316 }
20317 return resultobj;
20318 fail:
20319 return NULL;
20320 }
20321
20322
20323 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20324 PyObject *resultobj;
20325 wxDateTime *arg1 = (wxDateTime *) 0 ;
20326 wxDateTime::WeekDay arg2 ;
20327 wxDateTime *result;
20328 PyObject * obj0 = 0 ;
20329 PyObject * obj1 = 0 ;
20330 char *kwnames[] = {
20331 (char *) "self",(char *) "weekday", NULL
20332 };
20333
20334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20336 if (SWIG_arg_fail(1)) SWIG_fail;
20337 {
20338 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20339 if (SWIG_arg_fail(2)) SWIG_fail;
20340 }
20341 {
20342 PyThreadState* __tstate = wxPyBeginAllowThreads();
20343 {
20344 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20345 result = (wxDateTime *) &_result_ref;
20346 }
20347
20348 wxPyEndAllowThreads(__tstate);
20349 if (PyErr_Occurred()) SWIG_fail;
20350 }
20351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20352 return resultobj;
20353 fail:
20354 return NULL;
20355 }
20356
20357
20358 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20359 PyObject *resultobj;
20360 wxDateTime *arg1 = (wxDateTime *) 0 ;
20361 wxDateTime::WeekDay arg2 ;
20362 wxDateTime result;
20363 PyObject * obj0 = 0 ;
20364 PyObject * obj1 = 0 ;
20365 char *kwnames[] = {
20366 (char *) "self",(char *) "weekday", NULL
20367 };
20368
20369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20371 if (SWIG_arg_fail(1)) SWIG_fail;
20372 {
20373 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20374 if (SWIG_arg_fail(2)) SWIG_fail;
20375 }
20376 {
20377 PyThreadState* __tstate = wxPyBeginAllowThreads();
20378 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20379
20380 wxPyEndAllowThreads(__tstate);
20381 if (PyErr_Occurred()) SWIG_fail;
20382 }
20383 {
20384 wxDateTime * resultptr;
20385 resultptr = new wxDateTime((wxDateTime &)(result));
20386 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20387 }
20388 return resultobj;
20389 fail:
20390 return NULL;
20391 }
20392
20393
20394 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20395 PyObject *resultobj;
20396 wxDateTime *arg1 = (wxDateTime *) 0 ;
20397 wxDateTime::WeekDay arg2 ;
20398 int arg3 = (int) 1 ;
20399 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20400 int arg5 = (int) wxDateTime::Inv_Year ;
20401 bool result;
20402 PyObject * obj0 = 0 ;
20403 PyObject * obj1 = 0 ;
20404 PyObject * obj2 = 0 ;
20405 PyObject * obj3 = 0 ;
20406 PyObject * obj4 = 0 ;
20407 char *kwnames[] = {
20408 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20409 };
20410
20411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20413 if (SWIG_arg_fail(1)) SWIG_fail;
20414 {
20415 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20416 if (SWIG_arg_fail(2)) SWIG_fail;
20417 }
20418 if (obj2) {
20419 {
20420 arg3 = (int)(SWIG_As_int(obj2));
20421 if (SWIG_arg_fail(3)) SWIG_fail;
20422 }
20423 }
20424 if (obj3) {
20425 {
20426 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20427 if (SWIG_arg_fail(4)) SWIG_fail;
20428 }
20429 }
20430 if (obj4) {
20431 {
20432 arg5 = (int)(SWIG_As_int(obj4));
20433 if (SWIG_arg_fail(5)) SWIG_fail;
20434 }
20435 }
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20439
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 {
20444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20445 }
20446 return resultobj;
20447 fail:
20448 return NULL;
20449 }
20450
20451
20452 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20453 PyObject *resultobj;
20454 wxDateTime *arg1 = (wxDateTime *) 0 ;
20455 wxDateTime::WeekDay arg2 ;
20456 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20457 int arg4 = (int) wxDateTime::Inv_Year ;
20458 bool result;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 PyObject * obj2 = 0 ;
20462 PyObject * obj3 = 0 ;
20463 char *kwnames[] = {
20464 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20465 };
20466
20467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20469 if (SWIG_arg_fail(1)) SWIG_fail;
20470 {
20471 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20472 if (SWIG_arg_fail(2)) SWIG_fail;
20473 }
20474 if (obj2) {
20475 {
20476 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20477 if (SWIG_arg_fail(3)) SWIG_fail;
20478 }
20479 }
20480 if (obj3) {
20481 {
20482 arg4 = (int)(SWIG_As_int(obj3));
20483 if (SWIG_arg_fail(4)) SWIG_fail;
20484 }
20485 }
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20489
20490 wxPyEndAllowThreads(__tstate);
20491 if (PyErr_Occurred()) SWIG_fail;
20492 }
20493 {
20494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20495 }
20496 return resultobj;
20497 fail:
20498 return NULL;
20499 }
20500
20501
20502 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20503 PyObject *resultobj;
20504 wxDateTime *arg1 = (wxDateTime *) 0 ;
20505 wxDateTime::WeekDay arg2 ;
20506 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20507 int arg4 = (int) wxDateTime::Inv_Year ;
20508 wxDateTime result;
20509 PyObject * obj0 = 0 ;
20510 PyObject * obj1 = 0 ;
20511 PyObject * obj2 = 0 ;
20512 PyObject * obj3 = 0 ;
20513 char *kwnames[] = {
20514 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20515 };
20516
20517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20519 if (SWIG_arg_fail(1)) SWIG_fail;
20520 {
20521 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20522 if (SWIG_arg_fail(2)) SWIG_fail;
20523 }
20524 if (obj2) {
20525 {
20526 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20527 if (SWIG_arg_fail(3)) SWIG_fail;
20528 }
20529 }
20530 if (obj3) {
20531 {
20532 arg4 = (int)(SWIG_As_int(obj3));
20533 if (SWIG_arg_fail(4)) SWIG_fail;
20534 }
20535 }
20536 {
20537 PyThreadState* __tstate = wxPyBeginAllowThreads();
20538 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20539
20540 wxPyEndAllowThreads(__tstate);
20541 if (PyErr_Occurred()) SWIG_fail;
20542 }
20543 {
20544 wxDateTime * resultptr;
20545 resultptr = new wxDateTime((wxDateTime &)(result));
20546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20547 }
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20555 PyObject *resultobj;
20556 wxDateTime *arg1 = (wxDateTime *) 0 ;
20557 int arg2 ;
20558 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20559 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20560 bool result;
20561 PyObject * obj0 = 0 ;
20562 PyObject * obj1 = 0 ;
20563 PyObject * obj2 = 0 ;
20564 PyObject * obj3 = 0 ;
20565 char *kwnames[] = {
20566 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20567 };
20568
20569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20571 if (SWIG_arg_fail(1)) SWIG_fail;
20572 {
20573 arg2 = (int)(SWIG_As_int(obj1));
20574 if (SWIG_arg_fail(2)) SWIG_fail;
20575 }
20576 if (obj2) {
20577 {
20578 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20579 if (SWIG_arg_fail(3)) SWIG_fail;
20580 }
20581 }
20582 if (obj3) {
20583 {
20584 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20585 if (SWIG_arg_fail(4)) SWIG_fail;
20586 }
20587 }
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20591
20592 wxPyEndAllowThreads(__tstate);
20593 if (PyErr_Occurred()) SWIG_fail;
20594 }
20595 {
20596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20597 }
20598 return resultobj;
20599 fail:
20600 return NULL;
20601 }
20602
20603
20604 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20605 PyObject *resultobj;
20606 wxDateTime *arg1 = (wxDateTime *) 0 ;
20607 int arg2 ;
20608 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20609 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20610 wxDateTime result;
20611 PyObject * obj0 = 0 ;
20612 PyObject * obj1 = 0 ;
20613 PyObject * obj2 = 0 ;
20614 PyObject * obj3 = 0 ;
20615 char *kwnames[] = {
20616 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20617 };
20618
20619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20621 if (SWIG_arg_fail(1)) SWIG_fail;
20622 {
20623 arg2 = (int)(SWIG_As_int(obj1));
20624 if (SWIG_arg_fail(2)) SWIG_fail;
20625 }
20626 if (obj2) {
20627 {
20628 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20629 if (SWIG_arg_fail(3)) SWIG_fail;
20630 }
20631 }
20632 if (obj3) {
20633 {
20634 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20635 if (SWIG_arg_fail(4)) SWIG_fail;
20636 }
20637 }
20638 {
20639 PyThreadState* __tstate = wxPyBeginAllowThreads();
20640 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20641
20642 wxPyEndAllowThreads(__tstate);
20643 if (PyErr_Occurred()) SWIG_fail;
20644 }
20645 {
20646 wxDateTime * resultptr;
20647 resultptr = new wxDateTime((wxDateTime &)(result));
20648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20649 }
20650 return resultobj;
20651 fail:
20652 return NULL;
20653 }
20654
20655
20656 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20657 PyObject *resultobj;
20658 int arg1 ;
20659 int arg2 ;
20660 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20661 wxDateTime result;
20662 PyObject * obj0 = 0 ;
20663 PyObject * obj1 = 0 ;
20664 PyObject * obj2 = 0 ;
20665 char *kwnames[] = {
20666 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20667 };
20668
20669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20670 {
20671 arg1 = (int)(SWIG_As_int(obj0));
20672 if (SWIG_arg_fail(1)) SWIG_fail;
20673 }
20674 {
20675 arg2 = (int)(SWIG_As_int(obj1));
20676 if (SWIG_arg_fail(2)) SWIG_fail;
20677 }
20678 if (obj2) {
20679 {
20680 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20681 if (SWIG_arg_fail(3)) SWIG_fail;
20682 }
20683 }
20684 {
20685 PyThreadState* __tstate = wxPyBeginAllowThreads();
20686 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20687
20688 wxPyEndAllowThreads(__tstate);
20689 if (PyErr_Occurred()) SWIG_fail;
20690 }
20691 {
20692 wxDateTime * resultptr;
20693 resultptr = new wxDateTime((wxDateTime &)(result));
20694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20695 }
20696 return resultobj;
20697 fail:
20698 return NULL;
20699 }
20700
20701
20702 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20703 PyObject *resultobj;
20704 wxDateTime *arg1 = (wxDateTime *) 0 ;
20705 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20706 int arg3 = (int) wxDateTime::Inv_Year ;
20707 wxDateTime *result;
20708 PyObject * obj0 = 0 ;
20709 PyObject * obj1 = 0 ;
20710 PyObject * obj2 = 0 ;
20711 char *kwnames[] = {
20712 (char *) "self",(char *) "month",(char *) "year", NULL
20713 };
20714
20715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20717 if (SWIG_arg_fail(1)) SWIG_fail;
20718 if (obj1) {
20719 {
20720 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20721 if (SWIG_arg_fail(2)) SWIG_fail;
20722 }
20723 }
20724 if (obj2) {
20725 {
20726 arg3 = (int)(SWIG_As_int(obj2));
20727 if (SWIG_arg_fail(3)) SWIG_fail;
20728 }
20729 }
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 {
20733 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20734 result = (wxDateTime *) &_result_ref;
20735 }
20736
20737 wxPyEndAllowThreads(__tstate);
20738 if (PyErr_Occurred()) SWIG_fail;
20739 }
20740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20741 return resultobj;
20742 fail:
20743 return NULL;
20744 }
20745
20746
20747 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20748 PyObject *resultobj;
20749 wxDateTime *arg1 = (wxDateTime *) 0 ;
20750 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20751 int arg3 = (int) wxDateTime::Inv_Year ;
20752 wxDateTime result;
20753 PyObject * obj0 = 0 ;
20754 PyObject * obj1 = 0 ;
20755 PyObject * obj2 = 0 ;
20756 char *kwnames[] = {
20757 (char *) "self",(char *) "month",(char *) "year", NULL
20758 };
20759
20760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20762 if (SWIG_arg_fail(1)) SWIG_fail;
20763 if (obj1) {
20764 {
20765 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20766 if (SWIG_arg_fail(2)) SWIG_fail;
20767 }
20768 }
20769 if (obj2) {
20770 {
20771 arg3 = (int)(SWIG_As_int(obj2));
20772 if (SWIG_arg_fail(3)) SWIG_fail;
20773 }
20774 }
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20778
20779 wxPyEndAllowThreads(__tstate);
20780 if (PyErr_Occurred()) SWIG_fail;
20781 }
20782 {
20783 wxDateTime * resultptr;
20784 resultptr = new wxDateTime((wxDateTime &)(result));
20785 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20786 }
20787 return resultobj;
20788 fail:
20789 return NULL;
20790 }
20791
20792
20793 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20794 PyObject *resultobj;
20795 wxDateTime *arg1 = (wxDateTime *) 0 ;
20796 int arg2 ;
20797 wxDateTime *result;
20798 PyObject * obj0 = 0 ;
20799 PyObject * obj1 = 0 ;
20800 char *kwnames[] = {
20801 (char *) "self",(char *) "yday", NULL
20802 };
20803
20804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20806 if (SWIG_arg_fail(1)) SWIG_fail;
20807 {
20808 arg2 = (int)(SWIG_As_int(obj1));
20809 if (SWIG_arg_fail(2)) SWIG_fail;
20810 }
20811 {
20812 PyThreadState* __tstate = wxPyBeginAllowThreads();
20813 {
20814 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20815 result = (wxDateTime *) &_result_ref;
20816 }
20817
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20829 PyObject *resultobj;
20830 wxDateTime *arg1 = (wxDateTime *) 0 ;
20831 int arg2 ;
20832 wxDateTime result;
20833 PyObject * obj0 = 0 ;
20834 PyObject * obj1 = 0 ;
20835 char *kwnames[] = {
20836 (char *) "self",(char *) "yday", NULL
20837 };
20838
20839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20841 if (SWIG_arg_fail(1)) SWIG_fail;
20842 {
20843 arg2 = (int)(SWIG_As_int(obj1));
20844 if (SWIG_arg_fail(2)) SWIG_fail;
20845 }
20846 {
20847 PyThreadState* __tstate = wxPyBeginAllowThreads();
20848 result = (arg1)->GetYearDay(arg2);
20849
20850 wxPyEndAllowThreads(__tstate);
20851 if (PyErr_Occurred()) SWIG_fail;
20852 }
20853 {
20854 wxDateTime * resultptr;
20855 resultptr = new wxDateTime((wxDateTime &)(result));
20856 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20857 }
20858 return resultobj;
20859 fail:
20860 return NULL;
20861 }
20862
20863
20864 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20865 PyObject *resultobj;
20866 wxDateTime *arg1 = (wxDateTime *) 0 ;
20867 double result;
20868 PyObject * obj0 = 0 ;
20869 char *kwnames[] = {
20870 (char *) "self", NULL
20871 };
20872
20873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20875 if (SWIG_arg_fail(1)) SWIG_fail;
20876 {
20877 PyThreadState* __tstate = wxPyBeginAllowThreads();
20878 result = (double)(arg1)->GetJulianDayNumber();
20879
20880 wxPyEndAllowThreads(__tstate);
20881 if (PyErr_Occurred()) SWIG_fail;
20882 }
20883 {
20884 resultobj = SWIG_From_double((double)(result));
20885 }
20886 return resultobj;
20887 fail:
20888 return NULL;
20889 }
20890
20891
20892 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20893 PyObject *resultobj;
20894 wxDateTime *arg1 = (wxDateTime *) 0 ;
20895 double result;
20896 PyObject * obj0 = 0 ;
20897 char *kwnames[] = {
20898 (char *) "self", NULL
20899 };
20900
20901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20903 if (SWIG_arg_fail(1)) SWIG_fail;
20904 {
20905 PyThreadState* __tstate = wxPyBeginAllowThreads();
20906 result = (double)(arg1)->GetJDN();
20907
20908 wxPyEndAllowThreads(__tstate);
20909 if (PyErr_Occurred()) SWIG_fail;
20910 }
20911 {
20912 resultobj = SWIG_From_double((double)(result));
20913 }
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20921 PyObject *resultobj;
20922 wxDateTime *arg1 = (wxDateTime *) 0 ;
20923 double result;
20924 PyObject * obj0 = 0 ;
20925 char *kwnames[] = {
20926 (char *) "self", NULL
20927 };
20928
20929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20931 if (SWIG_arg_fail(1)) SWIG_fail;
20932 {
20933 PyThreadState* __tstate = wxPyBeginAllowThreads();
20934 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20935
20936 wxPyEndAllowThreads(__tstate);
20937 if (PyErr_Occurred()) SWIG_fail;
20938 }
20939 {
20940 resultobj = SWIG_From_double((double)(result));
20941 }
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20949 PyObject *resultobj;
20950 wxDateTime *arg1 = (wxDateTime *) 0 ;
20951 double result;
20952 PyObject * obj0 = 0 ;
20953 char *kwnames[] = {
20954 (char *) "self", NULL
20955 };
20956
20957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20959 if (SWIG_arg_fail(1)) SWIG_fail;
20960 {
20961 PyThreadState* __tstate = wxPyBeginAllowThreads();
20962 result = (double)(arg1)->GetMJD();
20963
20964 wxPyEndAllowThreads(__tstate);
20965 if (PyErr_Occurred()) SWIG_fail;
20966 }
20967 {
20968 resultobj = SWIG_From_double((double)(result));
20969 }
20970 return resultobj;
20971 fail:
20972 return NULL;
20973 }
20974
20975
20976 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20977 PyObject *resultobj;
20978 wxDateTime *arg1 = (wxDateTime *) 0 ;
20979 double result;
20980 PyObject * obj0 = 0 ;
20981 char *kwnames[] = {
20982 (char *) "self", NULL
20983 };
20984
20985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20987 if (SWIG_arg_fail(1)) SWIG_fail;
20988 {
20989 PyThreadState* __tstate = wxPyBeginAllowThreads();
20990 result = (double)(arg1)->GetRataDie();
20991
20992 wxPyEndAllowThreads(__tstate);
20993 if (PyErr_Occurred()) SWIG_fail;
20994 }
20995 {
20996 resultobj = SWIG_From_double((double)(result));
20997 }
20998 return resultobj;
20999 fail:
21000 return NULL;
21001 }
21002
21003
21004 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21005 PyObject *resultobj;
21006 wxDateTime *arg1 = (wxDateTime *) 0 ;
21007 wxDateTime::TimeZone *arg2 = 0 ;
21008 bool arg3 = (bool) false ;
21009 wxDateTime result;
21010 bool temp2 = false ;
21011 PyObject * obj0 = 0 ;
21012 PyObject * obj1 = 0 ;
21013 PyObject * obj2 = 0 ;
21014 char *kwnames[] = {
21015 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21016 };
21017
21018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21020 if (SWIG_arg_fail(1)) SWIG_fail;
21021 {
21022 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21023 temp2 = true;
21024 }
21025 if (obj2) {
21026 {
21027 arg3 = (bool)(SWIG_As_bool(obj2));
21028 if (SWIG_arg_fail(3)) SWIG_fail;
21029 }
21030 }
21031 {
21032 PyThreadState* __tstate = wxPyBeginAllowThreads();
21033 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21034
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 {
21039 wxDateTime * resultptr;
21040 resultptr = new wxDateTime((wxDateTime &)(result));
21041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21042 }
21043 {
21044 if (temp2) delete arg2;
21045 }
21046 return resultobj;
21047 fail:
21048 {
21049 if (temp2) delete arg2;
21050 }
21051 return NULL;
21052 }
21053
21054
21055 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21056 PyObject *resultobj;
21057 wxDateTime *arg1 = (wxDateTime *) 0 ;
21058 wxDateTime::TimeZone *arg2 = 0 ;
21059 bool arg3 = (bool) false ;
21060 wxDateTime *result;
21061 bool temp2 = false ;
21062 PyObject * obj0 = 0 ;
21063 PyObject * obj1 = 0 ;
21064 PyObject * obj2 = 0 ;
21065 char *kwnames[] = {
21066 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21067 };
21068
21069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21071 if (SWIG_arg_fail(1)) SWIG_fail;
21072 {
21073 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21074 temp2 = true;
21075 }
21076 if (obj2) {
21077 {
21078 arg3 = (bool)(SWIG_As_bool(obj2));
21079 if (SWIG_arg_fail(3)) SWIG_fail;
21080 }
21081 }
21082 {
21083 PyThreadState* __tstate = wxPyBeginAllowThreads();
21084 {
21085 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21086 result = (wxDateTime *) &_result_ref;
21087 }
21088
21089 wxPyEndAllowThreads(__tstate);
21090 if (PyErr_Occurred()) SWIG_fail;
21091 }
21092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21093 {
21094 if (temp2) delete arg2;
21095 }
21096 return resultobj;
21097 fail:
21098 {
21099 if (temp2) delete arg2;
21100 }
21101 return NULL;
21102 }
21103
21104
21105 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21106 PyObject *resultobj;
21107 wxDateTime *arg1 = (wxDateTime *) 0 ;
21108 bool arg2 = (bool) false ;
21109 wxDateTime result;
21110 PyObject * obj0 = 0 ;
21111 PyObject * obj1 = 0 ;
21112 char *kwnames[] = {
21113 (char *) "self",(char *) "noDST", NULL
21114 };
21115
21116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21118 if (SWIG_arg_fail(1)) SWIG_fail;
21119 if (obj1) {
21120 {
21121 arg2 = (bool)(SWIG_As_bool(obj1));
21122 if (SWIG_arg_fail(2)) SWIG_fail;
21123 }
21124 }
21125 {
21126 PyThreadState* __tstate = wxPyBeginAllowThreads();
21127 result = (arg1)->ToGMT(arg2);
21128
21129 wxPyEndAllowThreads(__tstate);
21130 if (PyErr_Occurred()) SWIG_fail;
21131 }
21132 {
21133 wxDateTime * resultptr;
21134 resultptr = new wxDateTime((wxDateTime &)(result));
21135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21136 }
21137 return resultobj;
21138 fail:
21139 return NULL;
21140 }
21141
21142
21143 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21144 PyObject *resultobj;
21145 wxDateTime *arg1 = (wxDateTime *) 0 ;
21146 bool arg2 = (bool) false ;
21147 wxDateTime *result;
21148 PyObject * obj0 = 0 ;
21149 PyObject * obj1 = 0 ;
21150 char *kwnames[] = {
21151 (char *) "self",(char *) "noDST", NULL
21152 };
21153
21154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21156 if (SWIG_arg_fail(1)) SWIG_fail;
21157 if (obj1) {
21158 {
21159 arg2 = (bool)(SWIG_As_bool(obj1));
21160 if (SWIG_arg_fail(2)) SWIG_fail;
21161 }
21162 }
21163 {
21164 PyThreadState* __tstate = wxPyBeginAllowThreads();
21165 {
21166 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21167 result = (wxDateTime *) &_result_ref;
21168 }
21169
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21181 PyObject *resultobj;
21182 wxDateTime *arg1 = (wxDateTime *) 0 ;
21183 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21184 int result;
21185 PyObject * obj0 = 0 ;
21186 PyObject * obj1 = 0 ;
21187 char *kwnames[] = {
21188 (char *) "self",(char *) "country", NULL
21189 };
21190
21191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21193 if (SWIG_arg_fail(1)) SWIG_fail;
21194 if (obj1) {
21195 {
21196 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21197 if (SWIG_arg_fail(2)) SWIG_fail;
21198 }
21199 }
21200 {
21201 PyThreadState* __tstate = wxPyBeginAllowThreads();
21202 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21203
21204 wxPyEndAllowThreads(__tstate);
21205 if (PyErr_Occurred()) SWIG_fail;
21206 }
21207 {
21208 resultobj = SWIG_From_int((int)(result));
21209 }
21210 return resultobj;
21211 fail:
21212 return NULL;
21213 }
21214
21215
21216 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21217 PyObject *resultobj;
21218 wxDateTime *arg1 = (wxDateTime *) 0 ;
21219 bool result;
21220 PyObject * obj0 = 0 ;
21221 char *kwnames[] = {
21222 (char *) "self", NULL
21223 };
21224
21225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21227 if (SWIG_arg_fail(1)) SWIG_fail;
21228 {
21229 PyThreadState* __tstate = wxPyBeginAllowThreads();
21230 result = (bool)((wxDateTime const *)arg1)->IsValid();
21231
21232 wxPyEndAllowThreads(__tstate);
21233 if (PyErr_Occurred()) SWIG_fail;
21234 }
21235 {
21236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21237 }
21238 return resultobj;
21239 fail:
21240 return NULL;
21241 }
21242
21243
21244 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21245 PyObject *resultobj;
21246 wxDateTime *arg1 = (wxDateTime *) 0 ;
21247 time_t result;
21248 PyObject * obj0 = 0 ;
21249 char *kwnames[] = {
21250 (char *) "self", NULL
21251 };
21252
21253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21255 if (SWIG_arg_fail(1)) SWIG_fail;
21256 {
21257 PyThreadState* __tstate = wxPyBeginAllowThreads();
21258 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21259
21260 wxPyEndAllowThreads(__tstate);
21261 if (PyErr_Occurred()) SWIG_fail;
21262 }
21263 {
21264 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21265 }
21266 return resultobj;
21267 fail:
21268 return NULL;
21269 }
21270
21271
21272 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21273 PyObject *resultobj;
21274 wxDateTime *arg1 = (wxDateTime *) 0 ;
21275 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21276 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21277 int result;
21278 bool temp2 = false ;
21279 PyObject * obj0 = 0 ;
21280 PyObject * obj1 = 0 ;
21281 char *kwnames[] = {
21282 (char *) "self",(char *) "tz", NULL
21283 };
21284
21285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21287 if (SWIG_arg_fail(1)) SWIG_fail;
21288 if (obj1) {
21289 {
21290 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21291 temp2 = true;
21292 }
21293 }
21294 {
21295 PyThreadState* __tstate = wxPyBeginAllowThreads();
21296 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21297
21298 wxPyEndAllowThreads(__tstate);
21299 if (PyErr_Occurred()) SWIG_fail;
21300 }
21301 {
21302 resultobj = SWIG_From_int((int)(result));
21303 }
21304 {
21305 if (temp2) delete arg2;
21306 }
21307 return resultobj;
21308 fail:
21309 {
21310 if (temp2) delete arg2;
21311 }
21312 return NULL;
21313 }
21314
21315
21316 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21317 PyObject *resultobj;
21318 wxDateTime *arg1 = (wxDateTime *) 0 ;
21319 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21320 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21321 wxDateTime::Month result;
21322 bool temp2 = false ;
21323 PyObject * obj0 = 0 ;
21324 PyObject * obj1 = 0 ;
21325 char *kwnames[] = {
21326 (char *) "self",(char *) "tz", NULL
21327 };
21328
21329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21331 if (SWIG_arg_fail(1)) SWIG_fail;
21332 if (obj1) {
21333 {
21334 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21335 temp2 = true;
21336 }
21337 }
21338 {
21339 PyThreadState* __tstate = wxPyBeginAllowThreads();
21340 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21341
21342 wxPyEndAllowThreads(__tstate);
21343 if (PyErr_Occurred()) SWIG_fail;
21344 }
21345 resultobj = SWIG_From_int((result));
21346 {
21347 if (temp2) delete arg2;
21348 }
21349 return resultobj;
21350 fail:
21351 {
21352 if (temp2) delete arg2;
21353 }
21354 return NULL;
21355 }
21356
21357
21358 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21359 PyObject *resultobj;
21360 wxDateTime *arg1 = (wxDateTime *) 0 ;
21361 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21362 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21363 int result;
21364 bool temp2 = false ;
21365 PyObject * obj0 = 0 ;
21366 PyObject * obj1 = 0 ;
21367 char *kwnames[] = {
21368 (char *) "self",(char *) "tz", NULL
21369 };
21370
21371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21373 if (SWIG_arg_fail(1)) SWIG_fail;
21374 if (obj1) {
21375 {
21376 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21377 temp2 = true;
21378 }
21379 }
21380 {
21381 PyThreadState* __tstate = wxPyBeginAllowThreads();
21382 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21383
21384 wxPyEndAllowThreads(__tstate);
21385 if (PyErr_Occurred()) SWIG_fail;
21386 }
21387 {
21388 resultobj = SWIG_From_int((int)(result));
21389 }
21390 {
21391 if (temp2) delete arg2;
21392 }
21393 return resultobj;
21394 fail:
21395 {
21396 if (temp2) delete arg2;
21397 }
21398 return NULL;
21399 }
21400
21401
21402 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21403 PyObject *resultobj;
21404 wxDateTime *arg1 = (wxDateTime *) 0 ;
21405 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21406 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21407 wxDateTime::WeekDay result;
21408 bool temp2 = false ;
21409 PyObject * obj0 = 0 ;
21410 PyObject * obj1 = 0 ;
21411 char *kwnames[] = {
21412 (char *) "self",(char *) "tz", NULL
21413 };
21414
21415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21417 if (SWIG_arg_fail(1)) SWIG_fail;
21418 if (obj1) {
21419 {
21420 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21421 temp2 = true;
21422 }
21423 }
21424 {
21425 PyThreadState* __tstate = wxPyBeginAllowThreads();
21426 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21427
21428 wxPyEndAllowThreads(__tstate);
21429 if (PyErr_Occurred()) SWIG_fail;
21430 }
21431 resultobj = SWIG_From_int((result));
21432 {
21433 if (temp2) delete arg2;
21434 }
21435 return resultobj;
21436 fail:
21437 {
21438 if (temp2) delete arg2;
21439 }
21440 return NULL;
21441 }
21442
21443
21444 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21445 PyObject *resultobj;
21446 wxDateTime *arg1 = (wxDateTime *) 0 ;
21447 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21448 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21449 int result;
21450 bool temp2 = false ;
21451 PyObject * obj0 = 0 ;
21452 PyObject * obj1 = 0 ;
21453 char *kwnames[] = {
21454 (char *) "self",(char *) "tz", NULL
21455 };
21456
21457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21459 if (SWIG_arg_fail(1)) SWIG_fail;
21460 if (obj1) {
21461 {
21462 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21463 temp2 = true;
21464 }
21465 }
21466 {
21467 PyThreadState* __tstate = wxPyBeginAllowThreads();
21468 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21469
21470 wxPyEndAllowThreads(__tstate);
21471 if (PyErr_Occurred()) SWIG_fail;
21472 }
21473 {
21474 resultobj = SWIG_From_int((int)(result));
21475 }
21476 {
21477 if (temp2) delete arg2;
21478 }
21479 return resultobj;
21480 fail:
21481 {
21482 if (temp2) delete arg2;
21483 }
21484 return NULL;
21485 }
21486
21487
21488 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21489 PyObject *resultobj;
21490 wxDateTime *arg1 = (wxDateTime *) 0 ;
21491 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21492 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21493 int result;
21494 bool temp2 = false ;
21495 PyObject * obj0 = 0 ;
21496 PyObject * obj1 = 0 ;
21497 char *kwnames[] = {
21498 (char *) "self",(char *) "tz", NULL
21499 };
21500
21501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21503 if (SWIG_arg_fail(1)) SWIG_fail;
21504 if (obj1) {
21505 {
21506 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21507 temp2 = true;
21508 }
21509 }
21510 {
21511 PyThreadState* __tstate = wxPyBeginAllowThreads();
21512 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21513
21514 wxPyEndAllowThreads(__tstate);
21515 if (PyErr_Occurred()) SWIG_fail;
21516 }
21517 {
21518 resultobj = SWIG_From_int((int)(result));
21519 }
21520 {
21521 if (temp2) delete arg2;
21522 }
21523 return resultobj;
21524 fail:
21525 {
21526 if (temp2) delete arg2;
21527 }
21528 return NULL;
21529 }
21530
21531
21532 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21533 PyObject *resultobj;
21534 wxDateTime *arg1 = (wxDateTime *) 0 ;
21535 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21536 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21537 int result;
21538 bool temp2 = false ;
21539 PyObject * obj0 = 0 ;
21540 PyObject * obj1 = 0 ;
21541 char *kwnames[] = {
21542 (char *) "self",(char *) "tz", NULL
21543 };
21544
21545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21547 if (SWIG_arg_fail(1)) SWIG_fail;
21548 if (obj1) {
21549 {
21550 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21551 temp2 = true;
21552 }
21553 }
21554 {
21555 PyThreadState* __tstate = wxPyBeginAllowThreads();
21556 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21557
21558 wxPyEndAllowThreads(__tstate);
21559 if (PyErr_Occurred()) SWIG_fail;
21560 }
21561 {
21562 resultobj = SWIG_From_int((int)(result));
21563 }
21564 {
21565 if (temp2) delete arg2;
21566 }
21567 return resultobj;
21568 fail:
21569 {
21570 if (temp2) delete arg2;
21571 }
21572 return NULL;
21573 }
21574
21575
21576 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21577 PyObject *resultobj;
21578 wxDateTime *arg1 = (wxDateTime *) 0 ;
21579 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21580 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21581 int result;
21582 bool temp2 = false ;
21583 PyObject * obj0 = 0 ;
21584 PyObject * obj1 = 0 ;
21585 char *kwnames[] = {
21586 (char *) "self",(char *) "tz", NULL
21587 };
21588
21589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21591 if (SWIG_arg_fail(1)) SWIG_fail;
21592 if (obj1) {
21593 {
21594 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21595 temp2 = true;
21596 }
21597 }
21598 {
21599 PyThreadState* __tstate = wxPyBeginAllowThreads();
21600 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21601
21602 wxPyEndAllowThreads(__tstate);
21603 if (PyErr_Occurred()) SWIG_fail;
21604 }
21605 {
21606 resultobj = SWIG_From_int((int)(result));
21607 }
21608 {
21609 if (temp2) delete arg2;
21610 }
21611 return resultobj;
21612 fail:
21613 {
21614 if (temp2) delete arg2;
21615 }
21616 return NULL;
21617 }
21618
21619
21620 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21621 PyObject *resultobj;
21622 wxDateTime *arg1 = (wxDateTime *) 0 ;
21623 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21624 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21625 int result;
21626 bool temp2 = false ;
21627 PyObject * obj0 = 0 ;
21628 PyObject * obj1 = 0 ;
21629 char *kwnames[] = {
21630 (char *) "self",(char *) "tz", NULL
21631 };
21632
21633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21635 if (SWIG_arg_fail(1)) SWIG_fail;
21636 if (obj1) {
21637 {
21638 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21639 temp2 = true;
21640 }
21641 }
21642 {
21643 PyThreadState* __tstate = wxPyBeginAllowThreads();
21644 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21645
21646 wxPyEndAllowThreads(__tstate);
21647 if (PyErr_Occurred()) SWIG_fail;
21648 }
21649 {
21650 resultobj = SWIG_From_int((int)(result));
21651 }
21652 {
21653 if (temp2) delete arg2;
21654 }
21655 return resultobj;
21656 fail:
21657 {
21658 if (temp2) delete arg2;
21659 }
21660 return NULL;
21661 }
21662
21663
21664 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21665 PyObject *resultobj;
21666 wxDateTime *arg1 = (wxDateTime *) 0 ;
21667 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21668 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21669 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21670 int result;
21671 bool temp3 = false ;
21672 PyObject * obj0 = 0 ;
21673 PyObject * obj1 = 0 ;
21674 PyObject * obj2 = 0 ;
21675 char *kwnames[] = {
21676 (char *) "self",(char *) "flags",(char *) "tz", NULL
21677 };
21678
21679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21681 if (SWIG_arg_fail(1)) SWIG_fail;
21682 if (obj1) {
21683 {
21684 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21685 if (SWIG_arg_fail(2)) SWIG_fail;
21686 }
21687 }
21688 if (obj2) {
21689 {
21690 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21691 temp3 = true;
21692 }
21693 }
21694 {
21695 PyThreadState* __tstate = wxPyBeginAllowThreads();
21696 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21697
21698 wxPyEndAllowThreads(__tstate);
21699 if (PyErr_Occurred()) SWIG_fail;
21700 }
21701 {
21702 resultobj = SWIG_From_int((int)(result));
21703 }
21704 {
21705 if (temp3) delete arg3;
21706 }
21707 return resultobj;
21708 fail:
21709 {
21710 if (temp3) delete arg3;
21711 }
21712 return NULL;
21713 }
21714
21715
21716 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj;
21718 wxDateTime *arg1 = (wxDateTime *) 0 ;
21719 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21720 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21721 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21722 int result;
21723 bool temp3 = false ;
21724 PyObject * obj0 = 0 ;
21725 PyObject * obj1 = 0 ;
21726 PyObject * obj2 = 0 ;
21727 char *kwnames[] = {
21728 (char *) "self",(char *) "flags",(char *) "tz", NULL
21729 };
21730
21731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21733 if (SWIG_arg_fail(1)) SWIG_fail;
21734 if (obj1) {
21735 {
21736 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21737 if (SWIG_arg_fail(2)) SWIG_fail;
21738 }
21739 }
21740 if (obj2) {
21741 {
21742 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21743 temp3 = true;
21744 }
21745 }
21746 {
21747 PyThreadState* __tstate = wxPyBeginAllowThreads();
21748 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21749
21750 wxPyEndAllowThreads(__tstate);
21751 if (PyErr_Occurred()) SWIG_fail;
21752 }
21753 {
21754 resultobj = SWIG_From_int((int)(result));
21755 }
21756 {
21757 if (temp3) delete arg3;
21758 }
21759 return resultobj;
21760 fail:
21761 {
21762 if (temp3) delete arg3;
21763 }
21764 return NULL;
21765 }
21766
21767
21768 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21769 PyObject *resultobj;
21770 wxDateTime *arg1 = (wxDateTime *) 0 ;
21771 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21772 bool result;
21773 PyObject * obj0 = 0 ;
21774 PyObject * obj1 = 0 ;
21775 char *kwnames[] = {
21776 (char *) "self",(char *) "country", NULL
21777 };
21778
21779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21781 if (SWIG_arg_fail(1)) SWIG_fail;
21782 if (obj1) {
21783 {
21784 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21785 if (SWIG_arg_fail(2)) SWIG_fail;
21786 }
21787 }
21788 {
21789 PyThreadState* __tstate = wxPyBeginAllowThreads();
21790 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21791
21792 wxPyEndAllowThreads(__tstate);
21793 if (PyErr_Occurred()) SWIG_fail;
21794 }
21795 {
21796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21797 }
21798 return resultobj;
21799 fail:
21800 return NULL;
21801 }
21802
21803
21804 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21805 PyObject *resultobj;
21806 wxDateTime *arg1 = (wxDateTime *) 0 ;
21807 wxDateTime *arg2 = 0 ;
21808 bool result;
21809 PyObject * obj0 = 0 ;
21810 PyObject * obj1 = 0 ;
21811 char *kwnames[] = {
21812 (char *) "self",(char *) "datetime", NULL
21813 };
21814
21815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21817 if (SWIG_arg_fail(1)) SWIG_fail;
21818 {
21819 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21820 if (SWIG_arg_fail(2)) SWIG_fail;
21821 if (arg2 == NULL) {
21822 SWIG_null_ref("wxDateTime");
21823 }
21824 if (SWIG_arg_fail(2)) SWIG_fail;
21825 }
21826 {
21827 PyThreadState* __tstate = wxPyBeginAllowThreads();
21828 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21829
21830 wxPyEndAllowThreads(__tstate);
21831 if (PyErr_Occurred()) SWIG_fail;
21832 }
21833 {
21834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21835 }
21836 return resultobj;
21837 fail:
21838 return NULL;
21839 }
21840
21841
21842 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21843 PyObject *resultobj;
21844 wxDateTime *arg1 = (wxDateTime *) 0 ;
21845 wxDateTime *arg2 = 0 ;
21846 bool result;
21847 PyObject * obj0 = 0 ;
21848 PyObject * obj1 = 0 ;
21849 char *kwnames[] = {
21850 (char *) "self",(char *) "datetime", NULL
21851 };
21852
21853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21855 if (SWIG_arg_fail(1)) SWIG_fail;
21856 {
21857 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21858 if (SWIG_arg_fail(2)) SWIG_fail;
21859 if (arg2 == NULL) {
21860 SWIG_null_ref("wxDateTime");
21861 }
21862 if (SWIG_arg_fail(2)) SWIG_fail;
21863 }
21864 {
21865 PyThreadState* __tstate = wxPyBeginAllowThreads();
21866 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21867
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 {
21872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21873 }
21874 return resultobj;
21875 fail:
21876 return NULL;
21877 }
21878
21879
21880 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21881 PyObject *resultobj;
21882 wxDateTime *arg1 = (wxDateTime *) 0 ;
21883 wxDateTime *arg2 = 0 ;
21884 bool result;
21885 PyObject * obj0 = 0 ;
21886 PyObject * obj1 = 0 ;
21887 char *kwnames[] = {
21888 (char *) "self",(char *) "datetime", NULL
21889 };
21890
21891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21893 if (SWIG_arg_fail(1)) SWIG_fail;
21894 {
21895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21896 if (SWIG_arg_fail(2)) SWIG_fail;
21897 if (arg2 == NULL) {
21898 SWIG_null_ref("wxDateTime");
21899 }
21900 if (SWIG_arg_fail(2)) SWIG_fail;
21901 }
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21905
21906 wxPyEndAllowThreads(__tstate);
21907 if (PyErr_Occurred()) SWIG_fail;
21908 }
21909 {
21910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21911 }
21912 return resultobj;
21913 fail:
21914 return NULL;
21915 }
21916
21917
21918 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21919 PyObject *resultobj;
21920 wxDateTime *arg1 = (wxDateTime *) 0 ;
21921 wxDateTime *arg2 = 0 ;
21922 wxDateTime *arg3 = 0 ;
21923 bool result;
21924 PyObject * obj0 = 0 ;
21925 PyObject * obj1 = 0 ;
21926 PyObject * obj2 = 0 ;
21927 char *kwnames[] = {
21928 (char *) "self",(char *) "t1",(char *) "t2", NULL
21929 };
21930
21931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21933 if (SWIG_arg_fail(1)) SWIG_fail;
21934 {
21935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21936 if (SWIG_arg_fail(2)) SWIG_fail;
21937 if (arg2 == NULL) {
21938 SWIG_null_ref("wxDateTime");
21939 }
21940 if (SWIG_arg_fail(2)) SWIG_fail;
21941 }
21942 {
21943 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21944 if (SWIG_arg_fail(3)) SWIG_fail;
21945 if (arg3 == NULL) {
21946 SWIG_null_ref("wxDateTime");
21947 }
21948 if (SWIG_arg_fail(3)) SWIG_fail;
21949 }
21950 {
21951 PyThreadState* __tstate = wxPyBeginAllowThreads();
21952 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21953
21954 wxPyEndAllowThreads(__tstate);
21955 if (PyErr_Occurred()) SWIG_fail;
21956 }
21957 {
21958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21959 }
21960 return resultobj;
21961 fail:
21962 return NULL;
21963 }
21964
21965
21966 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21967 PyObject *resultobj;
21968 wxDateTime *arg1 = (wxDateTime *) 0 ;
21969 wxDateTime *arg2 = 0 ;
21970 wxDateTime *arg3 = 0 ;
21971 bool result;
21972 PyObject * obj0 = 0 ;
21973 PyObject * obj1 = 0 ;
21974 PyObject * obj2 = 0 ;
21975 char *kwnames[] = {
21976 (char *) "self",(char *) "t1",(char *) "t2", NULL
21977 };
21978
21979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21981 if (SWIG_arg_fail(1)) SWIG_fail;
21982 {
21983 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21984 if (SWIG_arg_fail(2)) SWIG_fail;
21985 if (arg2 == NULL) {
21986 SWIG_null_ref("wxDateTime");
21987 }
21988 if (SWIG_arg_fail(2)) SWIG_fail;
21989 }
21990 {
21991 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21992 if (SWIG_arg_fail(3)) SWIG_fail;
21993 if (arg3 == NULL) {
21994 SWIG_null_ref("wxDateTime");
21995 }
21996 if (SWIG_arg_fail(3)) SWIG_fail;
21997 }
21998 {
21999 PyThreadState* __tstate = wxPyBeginAllowThreads();
22000 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22001
22002 wxPyEndAllowThreads(__tstate);
22003 if (PyErr_Occurred()) SWIG_fail;
22004 }
22005 {
22006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22007 }
22008 return resultobj;
22009 fail:
22010 return NULL;
22011 }
22012
22013
22014 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22015 PyObject *resultobj;
22016 wxDateTime *arg1 = (wxDateTime *) 0 ;
22017 wxDateTime *arg2 = 0 ;
22018 bool result;
22019 PyObject * obj0 = 0 ;
22020 PyObject * obj1 = 0 ;
22021 char *kwnames[] = {
22022 (char *) "self",(char *) "dt", NULL
22023 };
22024
22025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22027 if (SWIG_arg_fail(1)) SWIG_fail;
22028 {
22029 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22030 if (SWIG_arg_fail(2)) SWIG_fail;
22031 if (arg2 == NULL) {
22032 SWIG_null_ref("wxDateTime");
22033 }
22034 if (SWIG_arg_fail(2)) SWIG_fail;
22035 }
22036 {
22037 PyThreadState* __tstate = wxPyBeginAllowThreads();
22038 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22039
22040 wxPyEndAllowThreads(__tstate);
22041 if (PyErr_Occurred()) SWIG_fail;
22042 }
22043 {
22044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22045 }
22046 return resultobj;
22047 fail:
22048 return NULL;
22049 }
22050
22051
22052 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22053 PyObject *resultobj;
22054 wxDateTime *arg1 = (wxDateTime *) 0 ;
22055 wxDateTime *arg2 = 0 ;
22056 bool result;
22057 PyObject * obj0 = 0 ;
22058 PyObject * obj1 = 0 ;
22059 char *kwnames[] = {
22060 (char *) "self",(char *) "dt", NULL
22061 };
22062
22063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22065 if (SWIG_arg_fail(1)) SWIG_fail;
22066 {
22067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22068 if (SWIG_arg_fail(2)) SWIG_fail;
22069 if (arg2 == NULL) {
22070 SWIG_null_ref("wxDateTime");
22071 }
22072 if (SWIG_arg_fail(2)) SWIG_fail;
22073 }
22074 {
22075 PyThreadState* __tstate = wxPyBeginAllowThreads();
22076 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22077
22078 wxPyEndAllowThreads(__tstate);
22079 if (PyErr_Occurred()) SWIG_fail;
22080 }
22081 {
22082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22083 }
22084 return resultobj;
22085 fail:
22086 return NULL;
22087 }
22088
22089
22090 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22091 PyObject *resultobj;
22092 wxDateTime *arg1 = (wxDateTime *) 0 ;
22093 wxDateTime *arg2 = 0 ;
22094 wxTimeSpan *arg3 = 0 ;
22095 bool result;
22096 PyObject * obj0 = 0 ;
22097 PyObject * obj1 = 0 ;
22098 PyObject * obj2 = 0 ;
22099 char *kwnames[] = {
22100 (char *) "self",(char *) "dt",(char *) "ts", NULL
22101 };
22102
22103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22105 if (SWIG_arg_fail(1)) SWIG_fail;
22106 {
22107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22108 if (SWIG_arg_fail(2)) SWIG_fail;
22109 if (arg2 == NULL) {
22110 SWIG_null_ref("wxDateTime");
22111 }
22112 if (SWIG_arg_fail(2)) SWIG_fail;
22113 }
22114 {
22115 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22116 if (SWIG_arg_fail(3)) SWIG_fail;
22117 if (arg3 == NULL) {
22118 SWIG_null_ref("wxTimeSpan");
22119 }
22120 if (SWIG_arg_fail(3)) SWIG_fail;
22121 }
22122 {
22123 PyThreadState* __tstate = wxPyBeginAllowThreads();
22124 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22125
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 {
22130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22131 }
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22139 PyObject *resultobj;
22140 wxDateTime *arg1 = (wxDateTime *) 0 ;
22141 wxTimeSpan *arg2 = 0 ;
22142 wxDateTime *result;
22143 PyObject * obj0 = 0 ;
22144 PyObject * obj1 = 0 ;
22145 char *kwnames[] = {
22146 (char *) "self",(char *) "diff", NULL
22147 };
22148
22149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22151 if (SWIG_arg_fail(1)) SWIG_fail;
22152 {
22153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22154 if (SWIG_arg_fail(2)) SWIG_fail;
22155 if (arg2 == NULL) {
22156 SWIG_null_ref("wxTimeSpan");
22157 }
22158 if (SWIG_arg_fail(2)) SWIG_fail;
22159 }
22160 {
22161 PyThreadState* __tstate = wxPyBeginAllowThreads();
22162 {
22163 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22164 result = (wxDateTime *) &_result_ref;
22165 }
22166
22167 wxPyEndAllowThreads(__tstate);
22168 if (PyErr_Occurred()) SWIG_fail;
22169 }
22170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22171 return resultobj;
22172 fail:
22173 return NULL;
22174 }
22175
22176
22177 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22178 PyObject *resultobj;
22179 wxDateTime *arg1 = (wxDateTime *) 0 ;
22180 wxDateSpan *arg2 = 0 ;
22181 wxDateTime *result;
22182 PyObject * obj0 = 0 ;
22183 PyObject * obj1 = 0 ;
22184 char *kwnames[] = {
22185 (char *) "self",(char *) "diff", NULL
22186 };
22187
22188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22190 if (SWIG_arg_fail(1)) SWIG_fail;
22191 {
22192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22193 if (SWIG_arg_fail(2)) SWIG_fail;
22194 if (arg2 == NULL) {
22195 SWIG_null_ref("wxDateSpan");
22196 }
22197 if (SWIG_arg_fail(2)) SWIG_fail;
22198 }
22199 {
22200 PyThreadState* __tstate = wxPyBeginAllowThreads();
22201 {
22202 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22203 result = (wxDateTime *) &_result_ref;
22204 }
22205
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22210 return resultobj;
22211 fail:
22212 return NULL;
22213 }
22214
22215
22216 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj;
22218 wxDateTime *arg1 = (wxDateTime *) 0 ;
22219 wxTimeSpan *arg2 = 0 ;
22220 wxDateTime *result;
22221 PyObject * obj0 = 0 ;
22222 PyObject * obj1 = 0 ;
22223 char *kwnames[] = {
22224 (char *) "self",(char *) "diff", NULL
22225 };
22226
22227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22229 if (SWIG_arg_fail(1)) SWIG_fail;
22230 {
22231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22232 if (SWIG_arg_fail(2)) SWIG_fail;
22233 if (arg2 == NULL) {
22234 SWIG_null_ref("wxTimeSpan");
22235 }
22236 if (SWIG_arg_fail(2)) SWIG_fail;
22237 }
22238 {
22239 PyThreadState* __tstate = wxPyBeginAllowThreads();
22240 {
22241 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22242 result = (wxDateTime *) &_result_ref;
22243 }
22244
22245 wxPyEndAllowThreads(__tstate);
22246 if (PyErr_Occurred()) SWIG_fail;
22247 }
22248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22249 return resultobj;
22250 fail:
22251 return NULL;
22252 }
22253
22254
22255 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22256 PyObject *resultobj;
22257 wxDateTime *arg1 = (wxDateTime *) 0 ;
22258 wxDateSpan *arg2 = 0 ;
22259 wxDateTime *result;
22260 PyObject * obj0 = 0 ;
22261 PyObject * obj1 = 0 ;
22262 char *kwnames[] = {
22263 (char *) "self",(char *) "diff", NULL
22264 };
22265
22266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22268 if (SWIG_arg_fail(1)) SWIG_fail;
22269 {
22270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22271 if (SWIG_arg_fail(2)) SWIG_fail;
22272 if (arg2 == NULL) {
22273 SWIG_null_ref("wxDateSpan");
22274 }
22275 if (SWIG_arg_fail(2)) SWIG_fail;
22276 }
22277 {
22278 PyThreadState* __tstate = wxPyBeginAllowThreads();
22279 {
22280 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22281 result = (wxDateTime *) &_result_ref;
22282 }
22283
22284 wxPyEndAllowThreads(__tstate);
22285 if (PyErr_Occurred()) SWIG_fail;
22286 }
22287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22288 return resultobj;
22289 fail:
22290 return NULL;
22291 }
22292
22293
22294 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22295 PyObject *resultobj;
22296 wxDateTime *arg1 = (wxDateTime *) 0 ;
22297 wxDateTime *arg2 = 0 ;
22298 wxTimeSpan result;
22299 PyObject * obj0 = 0 ;
22300 PyObject * obj1 = 0 ;
22301 char *kwnames[] = {
22302 (char *) "self",(char *) "dt", NULL
22303 };
22304
22305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22307 if (SWIG_arg_fail(1)) SWIG_fail;
22308 {
22309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22310 if (SWIG_arg_fail(2)) SWIG_fail;
22311 if (arg2 == NULL) {
22312 SWIG_null_ref("wxDateTime");
22313 }
22314 if (SWIG_arg_fail(2)) SWIG_fail;
22315 }
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22319
22320 wxPyEndAllowThreads(__tstate);
22321 if (PyErr_Occurred()) SWIG_fail;
22322 }
22323 {
22324 wxTimeSpan * resultptr;
22325 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22327 }
22328 return resultobj;
22329 fail:
22330 return NULL;
22331 }
22332
22333
22334 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22335 PyObject *resultobj;
22336 wxDateTime *arg1 = (wxDateTime *) 0 ;
22337 wxTimeSpan *arg2 = 0 ;
22338 wxDateTime *result;
22339 PyObject * obj0 = 0 ;
22340 PyObject * obj1 = 0 ;
22341
22342 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22344 if (SWIG_arg_fail(1)) SWIG_fail;
22345 {
22346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22347 if (SWIG_arg_fail(2)) SWIG_fail;
22348 if (arg2 == NULL) {
22349 SWIG_null_ref("wxTimeSpan");
22350 }
22351 if (SWIG_arg_fail(2)) SWIG_fail;
22352 }
22353 {
22354 PyThreadState* __tstate = wxPyBeginAllowThreads();
22355 {
22356 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22357 result = (wxDateTime *) &_result_ref;
22358 }
22359
22360 wxPyEndAllowThreads(__tstate);
22361 if (PyErr_Occurred()) SWIG_fail;
22362 }
22363 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22364 return resultobj;
22365 fail:
22366 return NULL;
22367 }
22368
22369
22370 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22371 PyObject *resultobj;
22372 wxDateTime *arg1 = (wxDateTime *) 0 ;
22373 wxDateSpan *arg2 = 0 ;
22374 wxDateTime *result;
22375 PyObject * obj0 = 0 ;
22376 PyObject * obj1 = 0 ;
22377
22378 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22380 if (SWIG_arg_fail(1)) SWIG_fail;
22381 {
22382 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22383 if (SWIG_arg_fail(2)) SWIG_fail;
22384 if (arg2 == NULL) {
22385 SWIG_null_ref("wxDateSpan");
22386 }
22387 if (SWIG_arg_fail(2)) SWIG_fail;
22388 }
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 {
22392 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22393 result = (wxDateTime *) &_result_ref;
22394 }
22395
22396 wxPyEndAllowThreads(__tstate);
22397 if (PyErr_Occurred()) SWIG_fail;
22398 }
22399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22400 return resultobj;
22401 fail:
22402 return NULL;
22403 }
22404
22405
22406 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22407 int argc;
22408 PyObject *argv[3];
22409 int ii;
22410
22411 argc = PyObject_Length(args);
22412 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22413 argv[ii] = PyTuple_GetItem(args,ii);
22414 }
22415 if (argc == 2) {
22416 int _v;
22417 {
22418 void *ptr;
22419 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22420 _v = 0;
22421 PyErr_Clear();
22422 } else {
22423 _v = 1;
22424 }
22425 }
22426 if (_v) {
22427 {
22428 void *ptr = 0;
22429 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22430 _v = 0;
22431 PyErr_Clear();
22432 } else {
22433 _v = (ptr != 0);
22434 }
22435 }
22436 if (_v) {
22437 return _wrap_DateTime___iadd____SWIG_0(self,args);
22438 }
22439 }
22440 }
22441 if (argc == 2) {
22442 int _v;
22443 {
22444 void *ptr;
22445 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22446 _v = 0;
22447 PyErr_Clear();
22448 } else {
22449 _v = 1;
22450 }
22451 }
22452 if (_v) {
22453 {
22454 void *ptr = 0;
22455 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22456 _v = 0;
22457 PyErr_Clear();
22458 } else {
22459 _v = (ptr != 0);
22460 }
22461 }
22462 if (_v) {
22463 return _wrap_DateTime___iadd____SWIG_1(self,args);
22464 }
22465 }
22466 }
22467
22468 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22469 return NULL;
22470 }
22471
22472
22473 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22474 PyObject *resultobj;
22475 wxDateTime *arg1 = (wxDateTime *) 0 ;
22476 wxTimeSpan *arg2 = 0 ;
22477 wxDateTime *result;
22478 PyObject * obj0 = 0 ;
22479 PyObject * obj1 = 0 ;
22480
22481 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22483 if (SWIG_arg_fail(1)) SWIG_fail;
22484 {
22485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22486 if (SWIG_arg_fail(2)) SWIG_fail;
22487 if (arg2 == NULL) {
22488 SWIG_null_ref("wxTimeSpan");
22489 }
22490 if (SWIG_arg_fail(2)) SWIG_fail;
22491 }
22492 {
22493 PyThreadState* __tstate = wxPyBeginAllowThreads();
22494 {
22495 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22496 result = (wxDateTime *) &_result_ref;
22497 }
22498
22499 wxPyEndAllowThreads(__tstate);
22500 if (PyErr_Occurred()) SWIG_fail;
22501 }
22502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22510 PyObject *resultobj;
22511 wxDateTime *arg1 = (wxDateTime *) 0 ;
22512 wxDateSpan *arg2 = 0 ;
22513 wxDateTime *result;
22514 PyObject * obj0 = 0 ;
22515 PyObject * obj1 = 0 ;
22516
22517 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22519 if (SWIG_arg_fail(1)) SWIG_fail;
22520 {
22521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22522 if (SWIG_arg_fail(2)) SWIG_fail;
22523 if (arg2 == NULL) {
22524 SWIG_null_ref("wxDateSpan");
22525 }
22526 if (SWIG_arg_fail(2)) SWIG_fail;
22527 }
22528 {
22529 PyThreadState* __tstate = wxPyBeginAllowThreads();
22530 {
22531 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22532 result = (wxDateTime *) &_result_ref;
22533 }
22534
22535 wxPyEndAllowThreads(__tstate);
22536 if (PyErr_Occurred()) SWIG_fail;
22537 }
22538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22539 return resultobj;
22540 fail:
22541 return NULL;
22542 }
22543
22544
22545 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22546 int argc;
22547 PyObject *argv[3];
22548 int ii;
22549
22550 argc = PyObject_Length(args);
22551 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22552 argv[ii] = PyTuple_GetItem(args,ii);
22553 }
22554 if (argc == 2) {
22555 int _v;
22556 {
22557 void *ptr;
22558 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22559 _v = 0;
22560 PyErr_Clear();
22561 } else {
22562 _v = 1;
22563 }
22564 }
22565 if (_v) {
22566 {
22567 void *ptr = 0;
22568 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22569 _v = 0;
22570 PyErr_Clear();
22571 } else {
22572 _v = (ptr != 0);
22573 }
22574 }
22575 if (_v) {
22576 return _wrap_DateTime___isub____SWIG_0(self,args);
22577 }
22578 }
22579 }
22580 if (argc == 2) {
22581 int _v;
22582 {
22583 void *ptr;
22584 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22585 _v = 0;
22586 PyErr_Clear();
22587 } else {
22588 _v = 1;
22589 }
22590 }
22591 if (_v) {
22592 {
22593 void *ptr = 0;
22594 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22595 _v = 0;
22596 PyErr_Clear();
22597 } else {
22598 _v = (ptr != 0);
22599 }
22600 }
22601 if (_v) {
22602 return _wrap_DateTime___isub____SWIG_1(self,args);
22603 }
22604 }
22605 }
22606
22607 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22608 return NULL;
22609 }
22610
22611
22612 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22613 PyObject *resultobj;
22614 wxDateTime *arg1 = (wxDateTime *) 0 ;
22615 wxTimeSpan *arg2 = 0 ;
22616 wxDateTime result;
22617 PyObject * obj0 = 0 ;
22618 PyObject * obj1 = 0 ;
22619
22620 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22622 if (SWIG_arg_fail(1)) SWIG_fail;
22623 {
22624 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22625 if (SWIG_arg_fail(2)) SWIG_fail;
22626 if (arg2 == NULL) {
22627 SWIG_null_ref("wxTimeSpan");
22628 }
22629 if (SWIG_arg_fail(2)) SWIG_fail;
22630 }
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22634
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 {
22639 wxDateTime * resultptr;
22640 resultptr = new wxDateTime((wxDateTime &)(result));
22641 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22642 }
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22650 PyObject *resultobj;
22651 wxDateTime *arg1 = (wxDateTime *) 0 ;
22652 wxDateSpan *arg2 = 0 ;
22653 wxDateTime result;
22654 PyObject * obj0 = 0 ;
22655 PyObject * obj1 = 0 ;
22656
22657 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22659 if (SWIG_arg_fail(1)) SWIG_fail;
22660 {
22661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22662 if (SWIG_arg_fail(2)) SWIG_fail;
22663 if (arg2 == NULL) {
22664 SWIG_null_ref("wxDateSpan");
22665 }
22666 if (SWIG_arg_fail(2)) SWIG_fail;
22667 }
22668 {
22669 PyThreadState* __tstate = wxPyBeginAllowThreads();
22670 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22671
22672 wxPyEndAllowThreads(__tstate);
22673 if (PyErr_Occurred()) SWIG_fail;
22674 }
22675 {
22676 wxDateTime * resultptr;
22677 resultptr = new wxDateTime((wxDateTime &)(result));
22678 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22679 }
22680 return resultobj;
22681 fail:
22682 return NULL;
22683 }
22684
22685
22686 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22687 int argc;
22688 PyObject *argv[3];
22689 int ii;
22690
22691 argc = PyObject_Length(args);
22692 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22693 argv[ii] = PyTuple_GetItem(args,ii);
22694 }
22695 if (argc == 2) {
22696 int _v;
22697 {
22698 void *ptr;
22699 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22700 _v = 0;
22701 PyErr_Clear();
22702 } else {
22703 _v = 1;
22704 }
22705 }
22706 if (_v) {
22707 {
22708 void *ptr = 0;
22709 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22710 _v = 0;
22711 PyErr_Clear();
22712 } else {
22713 _v = (ptr != 0);
22714 }
22715 }
22716 if (_v) {
22717 return _wrap_DateTime___add____SWIG_0(self,args);
22718 }
22719 }
22720 }
22721 if (argc == 2) {
22722 int _v;
22723 {
22724 void *ptr;
22725 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22726 _v = 0;
22727 PyErr_Clear();
22728 } else {
22729 _v = 1;
22730 }
22731 }
22732 if (_v) {
22733 {
22734 void *ptr = 0;
22735 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22736 _v = 0;
22737 PyErr_Clear();
22738 } else {
22739 _v = (ptr != 0);
22740 }
22741 }
22742 if (_v) {
22743 return _wrap_DateTime___add____SWIG_1(self,args);
22744 }
22745 }
22746 }
22747
22748 Py_INCREF(Py_NotImplemented);
22749 return Py_NotImplemented;
22750 }
22751
22752
22753 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22754 PyObject *resultobj;
22755 wxDateTime *arg1 = (wxDateTime *) 0 ;
22756 wxDateTime *arg2 = 0 ;
22757 wxTimeSpan result;
22758 PyObject * obj0 = 0 ;
22759 PyObject * obj1 = 0 ;
22760
22761 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22763 if (SWIG_arg_fail(1)) SWIG_fail;
22764 {
22765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22766 if (SWIG_arg_fail(2)) SWIG_fail;
22767 if (arg2 == NULL) {
22768 SWIG_null_ref("wxDateTime");
22769 }
22770 if (SWIG_arg_fail(2)) SWIG_fail;
22771 }
22772 {
22773 PyThreadState* __tstate = wxPyBeginAllowThreads();
22774 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22775
22776 wxPyEndAllowThreads(__tstate);
22777 if (PyErr_Occurred()) SWIG_fail;
22778 }
22779 {
22780 wxTimeSpan * resultptr;
22781 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22782 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22783 }
22784 return resultobj;
22785 fail:
22786 return NULL;
22787 }
22788
22789
22790 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22791 PyObject *resultobj;
22792 wxDateTime *arg1 = (wxDateTime *) 0 ;
22793 wxTimeSpan *arg2 = 0 ;
22794 wxDateTime result;
22795 PyObject * obj0 = 0 ;
22796 PyObject * obj1 = 0 ;
22797
22798 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22800 if (SWIG_arg_fail(1)) SWIG_fail;
22801 {
22802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22803 if (SWIG_arg_fail(2)) SWIG_fail;
22804 if (arg2 == NULL) {
22805 SWIG_null_ref("wxTimeSpan");
22806 }
22807 if (SWIG_arg_fail(2)) SWIG_fail;
22808 }
22809 {
22810 PyThreadState* __tstate = wxPyBeginAllowThreads();
22811 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22812
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 {
22817 wxDateTime * resultptr;
22818 resultptr = new wxDateTime((wxDateTime &)(result));
22819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22820 }
22821 return resultobj;
22822 fail:
22823 return NULL;
22824 }
22825
22826
22827 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22828 PyObject *resultobj;
22829 wxDateTime *arg1 = (wxDateTime *) 0 ;
22830 wxDateSpan *arg2 = 0 ;
22831 wxDateTime result;
22832 PyObject * obj0 = 0 ;
22833 PyObject * obj1 = 0 ;
22834
22835 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22837 if (SWIG_arg_fail(1)) SWIG_fail;
22838 {
22839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22840 if (SWIG_arg_fail(2)) SWIG_fail;
22841 if (arg2 == NULL) {
22842 SWIG_null_ref("wxDateSpan");
22843 }
22844 if (SWIG_arg_fail(2)) SWIG_fail;
22845 }
22846 {
22847 PyThreadState* __tstate = wxPyBeginAllowThreads();
22848 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22849
22850 wxPyEndAllowThreads(__tstate);
22851 if (PyErr_Occurred()) SWIG_fail;
22852 }
22853 {
22854 wxDateTime * resultptr;
22855 resultptr = new wxDateTime((wxDateTime &)(result));
22856 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22857 }
22858 return resultobj;
22859 fail:
22860 return NULL;
22861 }
22862
22863
22864 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22865 int argc;
22866 PyObject *argv[3];
22867 int ii;
22868
22869 argc = PyObject_Length(args);
22870 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22871 argv[ii] = PyTuple_GetItem(args,ii);
22872 }
22873 if (argc == 2) {
22874 int _v;
22875 {
22876 void *ptr;
22877 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22878 _v = 0;
22879 PyErr_Clear();
22880 } else {
22881 _v = 1;
22882 }
22883 }
22884 if (_v) {
22885 {
22886 void *ptr = 0;
22887 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22888 _v = 0;
22889 PyErr_Clear();
22890 } else {
22891 _v = (ptr != 0);
22892 }
22893 }
22894 if (_v) {
22895 return _wrap_DateTime___sub____SWIG_0(self,args);
22896 }
22897 }
22898 }
22899 if (argc == 2) {
22900 int _v;
22901 {
22902 void *ptr;
22903 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22904 _v = 0;
22905 PyErr_Clear();
22906 } else {
22907 _v = 1;
22908 }
22909 }
22910 if (_v) {
22911 {
22912 void *ptr = 0;
22913 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22914 _v = 0;
22915 PyErr_Clear();
22916 } else {
22917 _v = (ptr != 0);
22918 }
22919 }
22920 if (_v) {
22921 return _wrap_DateTime___sub____SWIG_1(self,args);
22922 }
22923 }
22924 }
22925 if (argc == 2) {
22926 int _v;
22927 {
22928 void *ptr;
22929 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22930 _v = 0;
22931 PyErr_Clear();
22932 } else {
22933 _v = 1;
22934 }
22935 }
22936 if (_v) {
22937 {
22938 void *ptr = 0;
22939 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22940 _v = 0;
22941 PyErr_Clear();
22942 } else {
22943 _v = (ptr != 0);
22944 }
22945 }
22946 if (_v) {
22947 return _wrap_DateTime___sub____SWIG_2(self,args);
22948 }
22949 }
22950 }
22951
22952 Py_INCREF(Py_NotImplemented);
22953 return Py_NotImplemented;
22954 }
22955
22956
22957 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args) {
22958 PyObject *resultobj;
22959 wxDateTime *arg1 = (wxDateTime *) 0 ;
22960 wxDateTime *arg2 = (wxDateTime *) 0 ;
22961 bool result;
22962 PyObject * obj0 = 0 ;
22963 PyObject * obj1 = 0 ;
22964
22965 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___lt__",&obj0,&obj1)) goto fail;
22966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22967 if (SWIG_arg_fail(1)) SWIG_fail;
22968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22969 if (SWIG_arg_fail(2)) SWIG_fail;
22970 {
22971 PyThreadState* __tstate = wxPyBeginAllowThreads();
22972 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22973
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 {
22978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22979 }
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args) {
22987 PyObject *resultobj;
22988 wxDateTime *arg1 = (wxDateTime *) 0 ;
22989 wxDateTime *arg2 = (wxDateTime *) 0 ;
22990 bool result;
22991 PyObject * obj0 = 0 ;
22992 PyObject * obj1 = 0 ;
22993
22994 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___le__",&obj0,&obj1)) goto fail;
22995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22996 if (SWIG_arg_fail(1)) SWIG_fail;
22997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22998 if (SWIG_arg_fail(2)) SWIG_fail;
22999 {
23000 PyThreadState* __tstate = wxPyBeginAllowThreads();
23001 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23002
23003 wxPyEndAllowThreads(__tstate);
23004 if (PyErr_Occurred()) SWIG_fail;
23005 }
23006 {
23007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23008 }
23009 return resultobj;
23010 fail:
23011 return NULL;
23012 }
23013
23014
23015 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args) {
23016 PyObject *resultobj;
23017 wxDateTime *arg1 = (wxDateTime *) 0 ;
23018 wxDateTime *arg2 = (wxDateTime *) 0 ;
23019 bool result;
23020 PyObject * obj0 = 0 ;
23021 PyObject * obj1 = 0 ;
23022
23023 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___gt__",&obj0,&obj1)) goto fail;
23024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23025 if (SWIG_arg_fail(1)) SWIG_fail;
23026 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23027 if (SWIG_arg_fail(2)) SWIG_fail;
23028 {
23029 PyThreadState* __tstate = wxPyBeginAllowThreads();
23030 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23031
23032 wxPyEndAllowThreads(__tstate);
23033 if (PyErr_Occurred()) SWIG_fail;
23034 }
23035 {
23036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23037 }
23038 return resultobj;
23039 fail:
23040 return NULL;
23041 }
23042
23043
23044 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args) {
23045 PyObject *resultobj;
23046 wxDateTime *arg1 = (wxDateTime *) 0 ;
23047 wxDateTime *arg2 = (wxDateTime *) 0 ;
23048 bool result;
23049 PyObject * obj0 = 0 ;
23050 PyObject * obj1 = 0 ;
23051
23052 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ge__",&obj0,&obj1)) goto fail;
23053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23054 if (SWIG_arg_fail(1)) SWIG_fail;
23055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23056 if (SWIG_arg_fail(2)) SWIG_fail;
23057 {
23058 PyThreadState* __tstate = wxPyBeginAllowThreads();
23059 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23060
23061 wxPyEndAllowThreads(__tstate);
23062 if (PyErr_Occurred()) SWIG_fail;
23063 }
23064 {
23065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23066 }
23067 return resultobj;
23068 fail:
23069 return NULL;
23070 }
23071
23072
23073 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args) {
23074 PyObject *resultobj;
23075 wxDateTime *arg1 = (wxDateTime *) 0 ;
23076 wxDateTime *arg2 = (wxDateTime *) 0 ;
23077 bool result;
23078 PyObject * obj0 = 0 ;
23079 PyObject * obj1 = 0 ;
23080
23081 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___eq__",&obj0,&obj1)) goto fail;
23082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23083 if (SWIG_arg_fail(1)) SWIG_fail;
23084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23085 if (SWIG_arg_fail(2)) SWIG_fail;
23086 {
23087 PyThreadState* __tstate = wxPyBeginAllowThreads();
23088 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23089
23090 wxPyEndAllowThreads(__tstate);
23091 if (PyErr_Occurred()) SWIG_fail;
23092 }
23093 {
23094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23095 }
23096 return resultobj;
23097 fail:
23098 return NULL;
23099 }
23100
23101
23102 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args) {
23103 PyObject *resultobj;
23104 wxDateTime *arg1 = (wxDateTime *) 0 ;
23105 wxDateTime *arg2 = (wxDateTime *) 0 ;
23106 bool result;
23107 PyObject * obj0 = 0 ;
23108 PyObject * obj1 = 0 ;
23109
23110 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ne__",&obj0,&obj1)) goto fail;
23111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23112 if (SWIG_arg_fail(1)) SWIG_fail;
23113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23114 if (SWIG_arg_fail(2)) SWIG_fail;
23115 {
23116 PyThreadState* __tstate = wxPyBeginAllowThreads();
23117 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23118
23119 wxPyEndAllowThreads(__tstate);
23120 if (PyErr_Occurred()) SWIG_fail;
23121 }
23122 {
23123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23124 }
23125 return resultobj;
23126 fail:
23127 return NULL;
23128 }
23129
23130
23131 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23132 PyObject *resultobj;
23133 wxDateTime *arg1 = (wxDateTime *) 0 ;
23134 wxString *arg2 = 0 ;
23135 int result;
23136 bool temp2 = false ;
23137 PyObject * obj0 = 0 ;
23138 PyObject * obj1 = 0 ;
23139 char *kwnames[] = {
23140 (char *) "self",(char *) "date", NULL
23141 };
23142
23143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23145 if (SWIG_arg_fail(1)) SWIG_fail;
23146 {
23147 arg2 = wxString_in_helper(obj1);
23148 if (arg2 == NULL) SWIG_fail;
23149 temp2 = true;
23150 }
23151 {
23152 PyThreadState* __tstate = wxPyBeginAllowThreads();
23153 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23154
23155 wxPyEndAllowThreads(__tstate);
23156 if (PyErr_Occurred()) SWIG_fail;
23157 }
23158 {
23159 resultobj = SWIG_From_int((int)(result));
23160 }
23161 {
23162 if (temp2)
23163 delete arg2;
23164 }
23165 return resultobj;
23166 fail:
23167 {
23168 if (temp2)
23169 delete arg2;
23170 }
23171 return NULL;
23172 }
23173
23174
23175 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23176 PyObject *resultobj;
23177 wxDateTime *arg1 = (wxDateTime *) 0 ;
23178 wxString *arg2 = 0 ;
23179 wxString const &arg3_defvalue = wxPyDateFormatStr ;
23180 wxString *arg3 = (wxString *) &arg3_defvalue ;
23181 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23182 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23183 int result;
23184 bool temp2 = false ;
23185 bool temp3 = false ;
23186 PyObject * obj0 = 0 ;
23187 PyObject * obj1 = 0 ;
23188 PyObject * obj2 = 0 ;
23189 PyObject * obj3 = 0 ;
23190 char *kwnames[] = {
23191 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23192 };
23193
23194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23196 if (SWIG_arg_fail(1)) SWIG_fail;
23197 {
23198 arg2 = wxString_in_helper(obj1);
23199 if (arg2 == NULL) SWIG_fail;
23200 temp2 = true;
23201 }
23202 if (obj2) {
23203 {
23204 arg3 = wxString_in_helper(obj2);
23205 if (arg3 == NULL) SWIG_fail;
23206 temp3 = true;
23207 }
23208 }
23209 if (obj3) {
23210 {
23211 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23212 if (SWIG_arg_fail(4)) SWIG_fail;
23213 if (arg4 == NULL) {
23214 SWIG_null_ref("wxDateTime");
23215 }
23216 if (SWIG_arg_fail(4)) SWIG_fail;
23217 }
23218 }
23219 {
23220 PyThreadState* __tstate = wxPyBeginAllowThreads();
23221 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23222
23223 wxPyEndAllowThreads(__tstate);
23224 if (PyErr_Occurred()) SWIG_fail;
23225 }
23226 {
23227 resultobj = SWIG_From_int((int)(result));
23228 }
23229 {
23230 if (temp2)
23231 delete arg2;
23232 }
23233 {
23234 if (temp3)
23235 delete arg3;
23236 }
23237 return resultobj;
23238 fail:
23239 {
23240 if (temp2)
23241 delete arg2;
23242 }
23243 {
23244 if (temp3)
23245 delete arg3;
23246 }
23247 return NULL;
23248 }
23249
23250
23251 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23252 PyObject *resultobj;
23253 wxDateTime *arg1 = (wxDateTime *) 0 ;
23254 wxString *arg2 = 0 ;
23255 int result;
23256 bool temp2 = false ;
23257 PyObject * obj0 = 0 ;
23258 PyObject * obj1 = 0 ;
23259 char *kwnames[] = {
23260 (char *) "self",(char *) "datetime", NULL
23261 };
23262
23263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23265 if (SWIG_arg_fail(1)) SWIG_fail;
23266 {
23267 arg2 = wxString_in_helper(obj1);
23268 if (arg2 == NULL) SWIG_fail;
23269 temp2 = true;
23270 }
23271 {
23272 PyThreadState* __tstate = wxPyBeginAllowThreads();
23273 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23274
23275 wxPyEndAllowThreads(__tstate);
23276 if (PyErr_Occurred()) SWIG_fail;
23277 }
23278 {
23279 resultobj = SWIG_From_int((int)(result));
23280 }
23281 {
23282 if (temp2)
23283 delete arg2;
23284 }
23285 return resultobj;
23286 fail:
23287 {
23288 if (temp2)
23289 delete arg2;
23290 }
23291 return NULL;
23292 }
23293
23294
23295 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23296 PyObject *resultobj;
23297 wxDateTime *arg1 = (wxDateTime *) 0 ;
23298 wxString *arg2 = 0 ;
23299 int result;
23300 bool temp2 = false ;
23301 PyObject * obj0 = 0 ;
23302 PyObject * obj1 = 0 ;
23303 char *kwnames[] = {
23304 (char *) "self",(char *) "date", NULL
23305 };
23306
23307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23309 if (SWIG_arg_fail(1)) SWIG_fail;
23310 {
23311 arg2 = wxString_in_helper(obj1);
23312 if (arg2 == NULL) SWIG_fail;
23313 temp2 = true;
23314 }
23315 {
23316 PyThreadState* __tstate = wxPyBeginAllowThreads();
23317 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23318
23319 wxPyEndAllowThreads(__tstate);
23320 if (PyErr_Occurred()) SWIG_fail;
23321 }
23322 {
23323 resultobj = SWIG_From_int((int)(result));
23324 }
23325 {
23326 if (temp2)
23327 delete arg2;
23328 }
23329 return resultobj;
23330 fail:
23331 {
23332 if (temp2)
23333 delete arg2;
23334 }
23335 return NULL;
23336 }
23337
23338
23339 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23340 PyObject *resultobj;
23341 wxDateTime *arg1 = (wxDateTime *) 0 ;
23342 wxString *arg2 = 0 ;
23343 int result;
23344 bool temp2 = false ;
23345 PyObject * obj0 = 0 ;
23346 PyObject * obj1 = 0 ;
23347 char *kwnames[] = {
23348 (char *) "self",(char *) "time", NULL
23349 };
23350
23351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23353 if (SWIG_arg_fail(1)) SWIG_fail;
23354 {
23355 arg2 = wxString_in_helper(obj1);
23356 if (arg2 == NULL) SWIG_fail;
23357 temp2 = true;
23358 }
23359 {
23360 PyThreadState* __tstate = wxPyBeginAllowThreads();
23361 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23362
23363 wxPyEndAllowThreads(__tstate);
23364 if (PyErr_Occurred()) SWIG_fail;
23365 }
23366 {
23367 resultobj = SWIG_From_int((int)(result));
23368 }
23369 {
23370 if (temp2)
23371 delete arg2;
23372 }
23373 return resultobj;
23374 fail:
23375 {
23376 if (temp2)
23377 delete arg2;
23378 }
23379 return NULL;
23380 }
23381
23382
23383 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj;
23385 wxDateTime *arg1 = (wxDateTime *) 0 ;
23386 wxString const &arg2_defvalue = wxPyDateFormatStr ;
23387 wxString *arg2 = (wxString *) &arg2_defvalue ;
23388 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23389 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23390 wxString result;
23391 bool temp2 = false ;
23392 bool temp3 = false ;
23393 PyObject * obj0 = 0 ;
23394 PyObject * obj1 = 0 ;
23395 PyObject * obj2 = 0 ;
23396 char *kwnames[] = {
23397 (char *) "self",(char *) "format",(char *) "tz", NULL
23398 };
23399
23400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23402 if (SWIG_arg_fail(1)) SWIG_fail;
23403 if (obj1) {
23404 {
23405 arg2 = wxString_in_helper(obj1);
23406 if (arg2 == NULL) SWIG_fail;
23407 temp2 = true;
23408 }
23409 }
23410 if (obj2) {
23411 {
23412 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23413 temp3 = true;
23414 }
23415 }
23416 {
23417 PyThreadState* __tstate = wxPyBeginAllowThreads();
23418 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23419
23420 wxPyEndAllowThreads(__tstate);
23421 if (PyErr_Occurred()) SWIG_fail;
23422 }
23423 {
23424 #if wxUSE_UNICODE
23425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23426 #else
23427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23428 #endif
23429 }
23430 {
23431 if (temp2)
23432 delete arg2;
23433 }
23434 {
23435 if (temp3) delete arg3;
23436 }
23437 return resultobj;
23438 fail:
23439 {
23440 if (temp2)
23441 delete arg2;
23442 }
23443 {
23444 if (temp3) delete arg3;
23445 }
23446 return NULL;
23447 }
23448
23449
23450 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23451 PyObject *resultobj;
23452 wxDateTime *arg1 = (wxDateTime *) 0 ;
23453 wxString result;
23454 PyObject * obj0 = 0 ;
23455 char *kwnames[] = {
23456 (char *) "self", NULL
23457 };
23458
23459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23461 if (SWIG_arg_fail(1)) SWIG_fail;
23462 {
23463 PyThreadState* __tstate = wxPyBeginAllowThreads();
23464 result = ((wxDateTime const *)arg1)->FormatDate();
23465
23466 wxPyEndAllowThreads(__tstate);
23467 if (PyErr_Occurred()) SWIG_fail;
23468 }
23469 {
23470 #if wxUSE_UNICODE
23471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23472 #else
23473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23474 #endif
23475 }
23476 return resultobj;
23477 fail:
23478 return NULL;
23479 }
23480
23481
23482 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23483 PyObject *resultobj;
23484 wxDateTime *arg1 = (wxDateTime *) 0 ;
23485 wxString result;
23486 PyObject * obj0 = 0 ;
23487 char *kwnames[] = {
23488 (char *) "self", NULL
23489 };
23490
23491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23493 if (SWIG_arg_fail(1)) SWIG_fail;
23494 {
23495 PyThreadState* __tstate = wxPyBeginAllowThreads();
23496 result = ((wxDateTime const *)arg1)->FormatTime();
23497
23498 wxPyEndAllowThreads(__tstate);
23499 if (PyErr_Occurred()) SWIG_fail;
23500 }
23501 {
23502 #if wxUSE_UNICODE
23503 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23504 #else
23505 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23506 #endif
23507 }
23508 return resultobj;
23509 fail:
23510 return NULL;
23511 }
23512
23513
23514 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23515 PyObject *resultobj;
23516 wxDateTime *arg1 = (wxDateTime *) 0 ;
23517 wxString result;
23518 PyObject * obj0 = 0 ;
23519 char *kwnames[] = {
23520 (char *) "self", NULL
23521 };
23522
23523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23525 if (SWIG_arg_fail(1)) SWIG_fail;
23526 {
23527 PyThreadState* __tstate = wxPyBeginAllowThreads();
23528 result = ((wxDateTime const *)arg1)->FormatISODate();
23529
23530 wxPyEndAllowThreads(__tstate);
23531 if (PyErr_Occurred()) SWIG_fail;
23532 }
23533 {
23534 #if wxUSE_UNICODE
23535 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23536 #else
23537 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23538 #endif
23539 }
23540 return resultobj;
23541 fail:
23542 return NULL;
23543 }
23544
23545
23546 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23547 PyObject *resultobj;
23548 wxDateTime *arg1 = (wxDateTime *) 0 ;
23549 wxString result;
23550 PyObject * obj0 = 0 ;
23551 char *kwnames[] = {
23552 (char *) "self", NULL
23553 };
23554
23555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23557 if (SWIG_arg_fail(1)) SWIG_fail;
23558 {
23559 PyThreadState* __tstate = wxPyBeginAllowThreads();
23560 result = ((wxDateTime const *)arg1)->FormatISOTime();
23561
23562 wxPyEndAllowThreads(__tstate);
23563 if (PyErr_Occurred()) SWIG_fail;
23564 }
23565 {
23566 #if wxUSE_UNICODE
23567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23568 #else
23569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23570 #endif
23571 }
23572 return resultobj;
23573 fail:
23574 return NULL;
23575 }
23576
23577
23578 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23579 PyObject *obj;
23580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23581 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23582 Py_INCREF(obj);
23583 return Py_BuildValue((char *)"");
23584 }
23585 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23586 PyObject *resultobj;
23587 long arg1 ;
23588 wxTimeSpan result;
23589 PyObject * obj0 = 0 ;
23590 char *kwnames[] = {
23591 (char *) "sec", NULL
23592 };
23593
23594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23595 {
23596 arg1 = (long)(SWIG_As_long(obj0));
23597 if (SWIG_arg_fail(1)) SWIG_fail;
23598 }
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 result = wxTimeSpan::Seconds(arg1);
23602
23603 wxPyEndAllowThreads(__tstate);
23604 if (PyErr_Occurred()) SWIG_fail;
23605 }
23606 {
23607 wxTimeSpan * resultptr;
23608 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23610 }
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23618 PyObject *resultobj;
23619 wxTimeSpan result;
23620 char *kwnames[] = {
23621 NULL
23622 };
23623
23624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 result = wxTimeSpan::Second();
23628
23629 wxPyEndAllowThreads(__tstate);
23630 if (PyErr_Occurred()) SWIG_fail;
23631 }
23632 {
23633 wxTimeSpan * resultptr;
23634 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23636 }
23637 return resultobj;
23638 fail:
23639 return NULL;
23640 }
23641
23642
23643 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23644 PyObject *resultobj;
23645 long arg1 ;
23646 wxTimeSpan result;
23647 PyObject * obj0 = 0 ;
23648 char *kwnames[] = {
23649 (char *) "min", NULL
23650 };
23651
23652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23653 {
23654 arg1 = (long)(SWIG_As_long(obj0));
23655 if (SWIG_arg_fail(1)) SWIG_fail;
23656 }
23657 {
23658 PyThreadState* __tstate = wxPyBeginAllowThreads();
23659 result = wxTimeSpan::Minutes(arg1);
23660
23661 wxPyEndAllowThreads(__tstate);
23662 if (PyErr_Occurred()) SWIG_fail;
23663 }
23664 {
23665 wxTimeSpan * resultptr;
23666 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23667 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23668 }
23669 return resultobj;
23670 fail:
23671 return NULL;
23672 }
23673
23674
23675 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23676 PyObject *resultobj;
23677 wxTimeSpan result;
23678 char *kwnames[] = {
23679 NULL
23680 };
23681
23682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23683 {
23684 PyThreadState* __tstate = wxPyBeginAllowThreads();
23685 result = wxTimeSpan::Minute();
23686
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 {
23691 wxTimeSpan * resultptr;
23692 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23693 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23694 }
23695 return resultobj;
23696 fail:
23697 return NULL;
23698 }
23699
23700
23701 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23702 PyObject *resultobj;
23703 long arg1 ;
23704 wxTimeSpan result;
23705 PyObject * obj0 = 0 ;
23706 char *kwnames[] = {
23707 (char *) "hours", NULL
23708 };
23709
23710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23711 {
23712 arg1 = (long)(SWIG_As_long(obj0));
23713 if (SWIG_arg_fail(1)) SWIG_fail;
23714 }
23715 {
23716 PyThreadState* __tstate = wxPyBeginAllowThreads();
23717 result = wxTimeSpan::Hours(arg1);
23718
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 {
23723 wxTimeSpan * resultptr;
23724 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23725 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23726 }
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23734 PyObject *resultobj;
23735 wxTimeSpan result;
23736 char *kwnames[] = {
23737 NULL
23738 };
23739
23740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23741 {
23742 PyThreadState* __tstate = wxPyBeginAllowThreads();
23743 result = wxTimeSpan::Hour();
23744
23745 wxPyEndAllowThreads(__tstate);
23746 if (PyErr_Occurred()) SWIG_fail;
23747 }
23748 {
23749 wxTimeSpan * resultptr;
23750 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23752 }
23753 return resultobj;
23754 fail:
23755 return NULL;
23756 }
23757
23758
23759 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23760 PyObject *resultobj;
23761 long arg1 ;
23762 wxTimeSpan result;
23763 PyObject * obj0 = 0 ;
23764 char *kwnames[] = {
23765 (char *) "days", NULL
23766 };
23767
23768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23769 {
23770 arg1 = (long)(SWIG_As_long(obj0));
23771 if (SWIG_arg_fail(1)) SWIG_fail;
23772 }
23773 {
23774 PyThreadState* __tstate = wxPyBeginAllowThreads();
23775 result = wxTimeSpan::Days(arg1);
23776
23777 wxPyEndAllowThreads(__tstate);
23778 if (PyErr_Occurred()) SWIG_fail;
23779 }
23780 {
23781 wxTimeSpan * resultptr;
23782 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23783 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23784 }
23785 return resultobj;
23786 fail:
23787 return NULL;
23788 }
23789
23790
23791 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23792 PyObject *resultobj;
23793 wxTimeSpan result;
23794 char *kwnames[] = {
23795 NULL
23796 };
23797
23798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23799 {
23800 PyThreadState* __tstate = wxPyBeginAllowThreads();
23801 result = wxTimeSpan::Day();
23802
23803 wxPyEndAllowThreads(__tstate);
23804 if (PyErr_Occurred()) SWIG_fail;
23805 }
23806 {
23807 wxTimeSpan * resultptr;
23808 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23809 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23810 }
23811 return resultobj;
23812 fail:
23813 return NULL;
23814 }
23815
23816
23817 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23818 PyObject *resultobj;
23819 long arg1 ;
23820 wxTimeSpan result;
23821 PyObject * obj0 = 0 ;
23822 char *kwnames[] = {
23823 (char *) "days", NULL
23824 };
23825
23826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23827 {
23828 arg1 = (long)(SWIG_As_long(obj0));
23829 if (SWIG_arg_fail(1)) SWIG_fail;
23830 }
23831 {
23832 PyThreadState* __tstate = wxPyBeginAllowThreads();
23833 result = wxTimeSpan::Weeks(arg1);
23834
23835 wxPyEndAllowThreads(__tstate);
23836 if (PyErr_Occurred()) SWIG_fail;
23837 }
23838 {
23839 wxTimeSpan * resultptr;
23840 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23841 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23842 }
23843 return resultobj;
23844 fail:
23845 return NULL;
23846 }
23847
23848
23849 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23850 PyObject *resultobj;
23851 wxTimeSpan result;
23852 char *kwnames[] = {
23853 NULL
23854 };
23855
23856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23857 {
23858 PyThreadState* __tstate = wxPyBeginAllowThreads();
23859 result = wxTimeSpan::Week();
23860
23861 wxPyEndAllowThreads(__tstate);
23862 if (PyErr_Occurred()) SWIG_fail;
23863 }
23864 {
23865 wxTimeSpan * resultptr;
23866 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23868 }
23869 return resultobj;
23870 fail:
23871 return NULL;
23872 }
23873
23874
23875 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23876 PyObject *resultobj;
23877 long arg1 = (long) 0 ;
23878 long arg2 = (long) 0 ;
23879 long arg3 = (long) 0 ;
23880 long arg4 = (long) 0 ;
23881 wxTimeSpan *result;
23882 PyObject * obj0 = 0 ;
23883 PyObject * obj1 = 0 ;
23884 PyObject * obj2 = 0 ;
23885 PyObject * obj3 = 0 ;
23886 char *kwnames[] = {
23887 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23888 };
23889
23890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23891 if (obj0) {
23892 {
23893 arg1 = (long)(SWIG_As_long(obj0));
23894 if (SWIG_arg_fail(1)) SWIG_fail;
23895 }
23896 }
23897 if (obj1) {
23898 {
23899 arg2 = (long)(SWIG_As_long(obj1));
23900 if (SWIG_arg_fail(2)) SWIG_fail;
23901 }
23902 }
23903 if (obj2) {
23904 {
23905 arg3 = (long)(SWIG_As_long(obj2));
23906 if (SWIG_arg_fail(3)) SWIG_fail;
23907 }
23908 }
23909 if (obj3) {
23910 {
23911 arg4 = (long)(SWIG_As_long(obj3));
23912 if (SWIG_arg_fail(4)) SWIG_fail;
23913 }
23914 }
23915 {
23916 PyThreadState* __tstate = wxPyBeginAllowThreads();
23917 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23918
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj;
23931 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23932 PyObject * obj0 = 0 ;
23933 char *kwnames[] = {
23934 (char *) "self", NULL
23935 };
23936
23937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23939 if (SWIG_arg_fail(1)) SWIG_fail;
23940 {
23941 PyThreadState* __tstate = wxPyBeginAllowThreads();
23942 delete arg1;
23943
23944 wxPyEndAllowThreads(__tstate);
23945 if (PyErr_Occurred()) SWIG_fail;
23946 }
23947 Py_INCREF(Py_None); resultobj = Py_None;
23948 return resultobj;
23949 fail:
23950 return NULL;
23951 }
23952
23953
23954 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23955 PyObject *resultobj;
23956 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23957 wxTimeSpan *arg2 = 0 ;
23958 wxTimeSpan *result;
23959 PyObject * obj0 = 0 ;
23960 PyObject * obj1 = 0 ;
23961 char *kwnames[] = {
23962 (char *) "self",(char *) "diff", NULL
23963 };
23964
23965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23967 if (SWIG_arg_fail(1)) SWIG_fail;
23968 {
23969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23970 if (SWIG_arg_fail(2)) SWIG_fail;
23971 if (arg2 == NULL) {
23972 SWIG_null_ref("wxTimeSpan");
23973 }
23974 if (SWIG_arg_fail(2)) SWIG_fail;
23975 }
23976 {
23977 PyThreadState* __tstate = wxPyBeginAllowThreads();
23978 {
23979 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23980 result = (wxTimeSpan *) &_result_ref;
23981 }
23982
23983 wxPyEndAllowThreads(__tstate);
23984 if (PyErr_Occurred()) SWIG_fail;
23985 }
23986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23987 return resultobj;
23988 fail:
23989 return NULL;
23990 }
23991
23992
23993 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23994 PyObject *resultobj;
23995 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23996 wxTimeSpan *arg2 = 0 ;
23997 wxTimeSpan *result;
23998 PyObject * obj0 = 0 ;
23999 PyObject * obj1 = 0 ;
24000 char *kwnames[] = {
24001 (char *) "self",(char *) "diff", NULL
24002 };
24003
24004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24006 if (SWIG_arg_fail(1)) SWIG_fail;
24007 {
24008 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24009 if (SWIG_arg_fail(2)) SWIG_fail;
24010 if (arg2 == NULL) {
24011 SWIG_null_ref("wxTimeSpan");
24012 }
24013 if (SWIG_arg_fail(2)) SWIG_fail;
24014 }
24015 {
24016 PyThreadState* __tstate = wxPyBeginAllowThreads();
24017 {
24018 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24019 result = (wxTimeSpan *) &_result_ref;
24020 }
24021
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24026 return resultobj;
24027 fail:
24028 return NULL;
24029 }
24030
24031
24032 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24033 PyObject *resultobj;
24034 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24035 int arg2 ;
24036 wxTimeSpan *result;
24037 PyObject * obj0 = 0 ;
24038 PyObject * obj1 = 0 ;
24039 char *kwnames[] = {
24040 (char *) "self",(char *) "n", NULL
24041 };
24042
24043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24045 if (SWIG_arg_fail(1)) SWIG_fail;
24046 {
24047 arg2 = (int)(SWIG_As_int(obj1));
24048 if (SWIG_arg_fail(2)) SWIG_fail;
24049 }
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 {
24053 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24054 result = (wxTimeSpan *) &_result_ref;
24055 }
24056
24057 wxPyEndAllowThreads(__tstate);
24058 if (PyErr_Occurred()) SWIG_fail;
24059 }
24060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24061 return resultobj;
24062 fail:
24063 return NULL;
24064 }
24065
24066
24067 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24068 PyObject *resultobj;
24069 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24070 wxTimeSpan *result;
24071 PyObject * obj0 = 0 ;
24072 char *kwnames[] = {
24073 (char *) "self", NULL
24074 };
24075
24076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24078 if (SWIG_arg_fail(1)) SWIG_fail;
24079 {
24080 PyThreadState* __tstate = wxPyBeginAllowThreads();
24081 {
24082 wxTimeSpan &_result_ref = (arg1)->Neg();
24083 result = (wxTimeSpan *) &_result_ref;
24084 }
24085
24086 wxPyEndAllowThreads(__tstate);
24087 if (PyErr_Occurred()) SWIG_fail;
24088 }
24089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24097 PyObject *resultobj;
24098 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24099 wxTimeSpan result;
24100 PyObject * obj0 = 0 ;
24101 char *kwnames[] = {
24102 (char *) "self", NULL
24103 };
24104
24105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24107 if (SWIG_arg_fail(1)) SWIG_fail;
24108 {
24109 PyThreadState* __tstate = wxPyBeginAllowThreads();
24110 result = ((wxTimeSpan const *)arg1)->Abs();
24111
24112 wxPyEndAllowThreads(__tstate);
24113 if (PyErr_Occurred()) SWIG_fail;
24114 }
24115 {
24116 wxTimeSpan * resultptr;
24117 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24119 }
24120 return resultobj;
24121 fail:
24122 return NULL;
24123 }
24124
24125
24126 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24127 PyObject *resultobj;
24128 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24129 wxTimeSpan *arg2 = 0 ;
24130 wxTimeSpan *result;
24131 PyObject * obj0 = 0 ;
24132 PyObject * obj1 = 0 ;
24133 char *kwnames[] = {
24134 (char *) "self",(char *) "diff", NULL
24135 };
24136
24137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24139 if (SWIG_arg_fail(1)) SWIG_fail;
24140 {
24141 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24142 if (SWIG_arg_fail(2)) SWIG_fail;
24143 if (arg2 == NULL) {
24144 SWIG_null_ref("wxTimeSpan");
24145 }
24146 if (SWIG_arg_fail(2)) SWIG_fail;
24147 }
24148 {
24149 PyThreadState* __tstate = wxPyBeginAllowThreads();
24150 {
24151 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24152 result = (wxTimeSpan *) &_result_ref;
24153 }
24154
24155 wxPyEndAllowThreads(__tstate);
24156 if (PyErr_Occurred()) SWIG_fail;
24157 }
24158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24159 return resultobj;
24160 fail:
24161 return NULL;
24162 }
24163
24164
24165 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24166 PyObject *resultobj;
24167 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24168 wxTimeSpan *arg2 = 0 ;
24169 wxTimeSpan *result;
24170 PyObject * obj0 = 0 ;
24171 PyObject * obj1 = 0 ;
24172 char *kwnames[] = {
24173 (char *) "self",(char *) "diff", NULL
24174 };
24175
24176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24178 if (SWIG_arg_fail(1)) SWIG_fail;
24179 {
24180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24181 if (SWIG_arg_fail(2)) SWIG_fail;
24182 if (arg2 == NULL) {
24183 SWIG_null_ref("wxTimeSpan");
24184 }
24185 if (SWIG_arg_fail(2)) SWIG_fail;
24186 }
24187 {
24188 PyThreadState* __tstate = wxPyBeginAllowThreads();
24189 {
24190 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24191 result = (wxTimeSpan *) &_result_ref;
24192 }
24193
24194 wxPyEndAllowThreads(__tstate);
24195 if (PyErr_Occurred()) SWIG_fail;
24196 }
24197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24198 return resultobj;
24199 fail:
24200 return NULL;
24201 }
24202
24203
24204 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24205 PyObject *resultobj;
24206 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24207 int arg2 ;
24208 wxTimeSpan *result;
24209 PyObject * obj0 = 0 ;
24210 PyObject * obj1 = 0 ;
24211 char *kwnames[] = {
24212 (char *) "self",(char *) "n", NULL
24213 };
24214
24215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24217 if (SWIG_arg_fail(1)) SWIG_fail;
24218 {
24219 arg2 = (int)(SWIG_As_int(obj1));
24220 if (SWIG_arg_fail(2)) SWIG_fail;
24221 }
24222 {
24223 PyThreadState* __tstate = wxPyBeginAllowThreads();
24224 {
24225 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24226 result = (wxTimeSpan *) &_result_ref;
24227 }
24228
24229 wxPyEndAllowThreads(__tstate);
24230 if (PyErr_Occurred()) SWIG_fail;
24231 }
24232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24233 return resultobj;
24234 fail:
24235 return NULL;
24236 }
24237
24238
24239 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24240 PyObject *resultobj;
24241 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24242 wxTimeSpan *result;
24243 PyObject * obj0 = 0 ;
24244 char *kwnames[] = {
24245 (char *) "self", NULL
24246 };
24247
24248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24250 if (SWIG_arg_fail(1)) SWIG_fail;
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 {
24254 wxTimeSpan &_result_ref = (arg1)->operator -();
24255 result = (wxTimeSpan *) &_result_ref;
24256 }
24257
24258 wxPyEndAllowThreads(__tstate);
24259 if (PyErr_Occurred()) SWIG_fail;
24260 }
24261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24262 return resultobj;
24263 fail:
24264 return NULL;
24265 }
24266
24267
24268 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24269 PyObject *resultobj;
24270 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24271 wxTimeSpan *arg2 = 0 ;
24272 wxTimeSpan result;
24273 PyObject * obj0 = 0 ;
24274 PyObject * obj1 = 0 ;
24275 char *kwnames[] = {
24276 (char *) "self",(char *) "other", NULL
24277 };
24278
24279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24281 if (SWIG_arg_fail(1)) SWIG_fail;
24282 {
24283 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24284 if (SWIG_arg_fail(2)) SWIG_fail;
24285 if (arg2 == NULL) {
24286 SWIG_null_ref("wxTimeSpan");
24287 }
24288 if (SWIG_arg_fail(2)) SWIG_fail;
24289 }
24290 {
24291 PyThreadState* __tstate = wxPyBeginAllowThreads();
24292 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24293
24294 wxPyEndAllowThreads(__tstate);
24295 if (PyErr_Occurred()) SWIG_fail;
24296 }
24297 {
24298 wxTimeSpan * resultptr;
24299 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24300 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24301 }
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24309 PyObject *resultobj;
24310 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24311 wxTimeSpan *arg2 = 0 ;
24312 wxTimeSpan result;
24313 PyObject * obj0 = 0 ;
24314 PyObject * obj1 = 0 ;
24315 char *kwnames[] = {
24316 (char *) "self",(char *) "other", NULL
24317 };
24318
24319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24321 if (SWIG_arg_fail(1)) SWIG_fail;
24322 {
24323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24324 if (SWIG_arg_fail(2)) SWIG_fail;
24325 if (arg2 == NULL) {
24326 SWIG_null_ref("wxTimeSpan");
24327 }
24328 if (SWIG_arg_fail(2)) SWIG_fail;
24329 }
24330 {
24331 PyThreadState* __tstate = wxPyBeginAllowThreads();
24332 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24333
24334 wxPyEndAllowThreads(__tstate);
24335 if (PyErr_Occurred()) SWIG_fail;
24336 }
24337 {
24338 wxTimeSpan * resultptr;
24339 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24340 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24341 }
24342 return resultobj;
24343 fail:
24344 return NULL;
24345 }
24346
24347
24348 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24349 PyObject *resultobj;
24350 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24351 int arg2 ;
24352 wxTimeSpan result;
24353 PyObject * obj0 = 0 ;
24354 PyObject * obj1 = 0 ;
24355 char *kwnames[] = {
24356 (char *) "self",(char *) "n", NULL
24357 };
24358
24359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24361 if (SWIG_arg_fail(1)) SWIG_fail;
24362 {
24363 arg2 = (int)(SWIG_As_int(obj1));
24364 if (SWIG_arg_fail(2)) SWIG_fail;
24365 }
24366 {
24367 PyThreadState* __tstate = wxPyBeginAllowThreads();
24368 result = wxTimeSpan___mul__(arg1,arg2);
24369
24370 wxPyEndAllowThreads(__tstate);
24371 if (PyErr_Occurred()) SWIG_fail;
24372 }
24373 {
24374 wxTimeSpan * resultptr;
24375 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24376 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24377 }
24378 return resultobj;
24379 fail:
24380 return NULL;
24381 }
24382
24383
24384 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24385 PyObject *resultobj;
24386 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24387 int arg2 ;
24388 wxTimeSpan result;
24389 PyObject * obj0 = 0 ;
24390 PyObject * obj1 = 0 ;
24391 char *kwnames[] = {
24392 (char *) "self",(char *) "n", NULL
24393 };
24394
24395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24397 if (SWIG_arg_fail(1)) SWIG_fail;
24398 {
24399 arg2 = (int)(SWIG_As_int(obj1));
24400 if (SWIG_arg_fail(2)) SWIG_fail;
24401 }
24402 {
24403 PyThreadState* __tstate = wxPyBeginAllowThreads();
24404 result = wxTimeSpan___rmul__(arg1,arg2);
24405
24406 wxPyEndAllowThreads(__tstate);
24407 if (PyErr_Occurred()) SWIG_fail;
24408 }
24409 {
24410 wxTimeSpan * resultptr;
24411 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24412 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24413 }
24414 return resultobj;
24415 fail:
24416 return NULL;
24417 }
24418
24419
24420 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24421 PyObject *resultobj;
24422 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24423 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24424 bool result;
24425 PyObject * obj0 = 0 ;
24426 PyObject * obj1 = 0 ;
24427 char *kwnames[] = {
24428 (char *) "self",(char *) "other", NULL
24429 };
24430
24431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24433 if (SWIG_arg_fail(1)) SWIG_fail;
24434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24435 if (SWIG_arg_fail(2)) SWIG_fail;
24436 {
24437 PyThreadState* __tstate = wxPyBeginAllowThreads();
24438 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24439
24440 wxPyEndAllowThreads(__tstate);
24441 if (PyErr_Occurred()) SWIG_fail;
24442 }
24443 {
24444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24445 }
24446 return resultobj;
24447 fail:
24448 return NULL;
24449 }
24450
24451
24452 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24453 PyObject *resultobj;
24454 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24455 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24456 bool result;
24457 PyObject * obj0 = 0 ;
24458 PyObject * obj1 = 0 ;
24459 char *kwnames[] = {
24460 (char *) "self",(char *) "other", NULL
24461 };
24462
24463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24465 if (SWIG_arg_fail(1)) SWIG_fail;
24466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24467 if (SWIG_arg_fail(2)) SWIG_fail;
24468 {
24469 PyThreadState* __tstate = wxPyBeginAllowThreads();
24470 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24471
24472 wxPyEndAllowThreads(__tstate);
24473 if (PyErr_Occurred()) SWIG_fail;
24474 }
24475 {
24476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24477 }
24478 return resultobj;
24479 fail:
24480 return NULL;
24481 }
24482
24483
24484 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24485 PyObject *resultobj;
24486 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24487 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24488 bool result;
24489 PyObject * obj0 = 0 ;
24490 PyObject * obj1 = 0 ;
24491 char *kwnames[] = {
24492 (char *) "self",(char *) "other", NULL
24493 };
24494
24495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24497 if (SWIG_arg_fail(1)) SWIG_fail;
24498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24499 if (SWIG_arg_fail(2)) SWIG_fail;
24500 {
24501 PyThreadState* __tstate = wxPyBeginAllowThreads();
24502 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24503
24504 wxPyEndAllowThreads(__tstate);
24505 if (PyErr_Occurred()) SWIG_fail;
24506 }
24507 {
24508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24509 }
24510 return resultobj;
24511 fail:
24512 return NULL;
24513 }
24514
24515
24516 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24517 PyObject *resultobj;
24518 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24519 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24520 bool result;
24521 PyObject * obj0 = 0 ;
24522 PyObject * obj1 = 0 ;
24523 char *kwnames[] = {
24524 (char *) "self",(char *) "other", NULL
24525 };
24526
24527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24529 if (SWIG_arg_fail(1)) SWIG_fail;
24530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24531 if (SWIG_arg_fail(2)) SWIG_fail;
24532 {
24533 PyThreadState* __tstate = wxPyBeginAllowThreads();
24534 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24535
24536 wxPyEndAllowThreads(__tstate);
24537 if (PyErr_Occurred()) SWIG_fail;
24538 }
24539 {
24540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24541 }
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj;
24550 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24551 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24552 bool result;
24553 PyObject * obj0 = 0 ;
24554 PyObject * obj1 = 0 ;
24555 char *kwnames[] = {
24556 (char *) "self",(char *) "other", NULL
24557 };
24558
24559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24561 if (SWIG_arg_fail(1)) SWIG_fail;
24562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24563 if (SWIG_arg_fail(2)) SWIG_fail;
24564 {
24565 PyThreadState* __tstate = wxPyBeginAllowThreads();
24566 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24567
24568 wxPyEndAllowThreads(__tstate);
24569 if (PyErr_Occurred()) SWIG_fail;
24570 }
24571 {
24572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24573 }
24574 return resultobj;
24575 fail:
24576 return NULL;
24577 }
24578
24579
24580 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24581 PyObject *resultobj;
24582 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24583 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24584 bool result;
24585 PyObject * obj0 = 0 ;
24586 PyObject * obj1 = 0 ;
24587 char *kwnames[] = {
24588 (char *) "self",(char *) "other", NULL
24589 };
24590
24591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24593 if (SWIG_arg_fail(1)) SWIG_fail;
24594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24595 if (SWIG_arg_fail(2)) SWIG_fail;
24596 {
24597 PyThreadState* __tstate = wxPyBeginAllowThreads();
24598 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24599
24600 wxPyEndAllowThreads(__tstate);
24601 if (PyErr_Occurred()) SWIG_fail;
24602 }
24603 {
24604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24605 }
24606 return resultobj;
24607 fail:
24608 return NULL;
24609 }
24610
24611
24612 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24613 PyObject *resultobj;
24614 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24615 bool result;
24616 PyObject * obj0 = 0 ;
24617 char *kwnames[] = {
24618 (char *) "self", NULL
24619 };
24620
24621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24623 if (SWIG_arg_fail(1)) SWIG_fail;
24624 {
24625 PyThreadState* __tstate = wxPyBeginAllowThreads();
24626 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24627
24628 wxPyEndAllowThreads(__tstate);
24629 if (PyErr_Occurred()) SWIG_fail;
24630 }
24631 {
24632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24633 }
24634 return resultobj;
24635 fail:
24636 return NULL;
24637 }
24638
24639
24640 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj;
24642 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24643 bool result;
24644 PyObject * obj0 = 0 ;
24645 char *kwnames[] = {
24646 (char *) "self", NULL
24647 };
24648
24649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24651 if (SWIG_arg_fail(1)) SWIG_fail;
24652 {
24653 PyThreadState* __tstate = wxPyBeginAllowThreads();
24654 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24655
24656 wxPyEndAllowThreads(__tstate);
24657 if (PyErr_Occurred()) SWIG_fail;
24658 }
24659 {
24660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24661 }
24662 return resultobj;
24663 fail:
24664 return NULL;
24665 }
24666
24667
24668 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj;
24670 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24671 bool result;
24672 PyObject * obj0 = 0 ;
24673 char *kwnames[] = {
24674 (char *) "self", NULL
24675 };
24676
24677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24679 if (SWIG_arg_fail(1)) SWIG_fail;
24680 {
24681 PyThreadState* __tstate = wxPyBeginAllowThreads();
24682 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24683
24684 wxPyEndAllowThreads(__tstate);
24685 if (PyErr_Occurred()) SWIG_fail;
24686 }
24687 {
24688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24689 }
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24697 PyObject *resultobj;
24698 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24699 wxTimeSpan *arg2 = 0 ;
24700 bool result;
24701 PyObject * obj0 = 0 ;
24702 PyObject * obj1 = 0 ;
24703 char *kwnames[] = {
24704 (char *) "self",(char *) "ts", NULL
24705 };
24706
24707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24709 if (SWIG_arg_fail(1)) SWIG_fail;
24710 {
24711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24712 if (SWIG_arg_fail(2)) SWIG_fail;
24713 if (arg2 == NULL) {
24714 SWIG_null_ref("wxTimeSpan");
24715 }
24716 if (SWIG_arg_fail(2)) SWIG_fail;
24717 }
24718 {
24719 PyThreadState* __tstate = wxPyBeginAllowThreads();
24720 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24721
24722 wxPyEndAllowThreads(__tstate);
24723 if (PyErr_Occurred()) SWIG_fail;
24724 }
24725 {
24726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24727 }
24728 return resultobj;
24729 fail:
24730 return NULL;
24731 }
24732
24733
24734 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24735 PyObject *resultobj;
24736 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24737 wxTimeSpan *arg2 = 0 ;
24738 bool result;
24739 PyObject * obj0 = 0 ;
24740 PyObject * obj1 = 0 ;
24741 char *kwnames[] = {
24742 (char *) "self",(char *) "ts", NULL
24743 };
24744
24745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24747 if (SWIG_arg_fail(1)) SWIG_fail;
24748 {
24749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24750 if (SWIG_arg_fail(2)) SWIG_fail;
24751 if (arg2 == NULL) {
24752 SWIG_null_ref("wxTimeSpan");
24753 }
24754 if (SWIG_arg_fail(2)) SWIG_fail;
24755 }
24756 {
24757 PyThreadState* __tstate = wxPyBeginAllowThreads();
24758 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24759
24760 wxPyEndAllowThreads(__tstate);
24761 if (PyErr_Occurred()) SWIG_fail;
24762 }
24763 {
24764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24765 }
24766 return resultobj;
24767 fail:
24768 return NULL;
24769 }
24770
24771
24772 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24773 PyObject *resultobj;
24774 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24775 wxTimeSpan *arg2 = 0 ;
24776 bool result;
24777 PyObject * obj0 = 0 ;
24778 PyObject * obj1 = 0 ;
24779 char *kwnames[] = {
24780 (char *) "self",(char *) "t", NULL
24781 };
24782
24783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24785 if (SWIG_arg_fail(1)) SWIG_fail;
24786 {
24787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24788 if (SWIG_arg_fail(2)) SWIG_fail;
24789 if (arg2 == NULL) {
24790 SWIG_null_ref("wxTimeSpan");
24791 }
24792 if (SWIG_arg_fail(2)) SWIG_fail;
24793 }
24794 {
24795 PyThreadState* __tstate = wxPyBeginAllowThreads();
24796 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24797
24798 wxPyEndAllowThreads(__tstate);
24799 if (PyErr_Occurred()) SWIG_fail;
24800 }
24801 {
24802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24803 }
24804 return resultobj;
24805 fail:
24806 return NULL;
24807 }
24808
24809
24810 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24811 PyObject *resultobj;
24812 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24813 int result;
24814 PyObject * obj0 = 0 ;
24815 char *kwnames[] = {
24816 (char *) "self", NULL
24817 };
24818
24819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24821 if (SWIG_arg_fail(1)) SWIG_fail;
24822 {
24823 PyThreadState* __tstate = wxPyBeginAllowThreads();
24824 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24825
24826 wxPyEndAllowThreads(__tstate);
24827 if (PyErr_Occurred()) SWIG_fail;
24828 }
24829 {
24830 resultobj = SWIG_From_int((int)(result));
24831 }
24832 return resultobj;
24833 fail:
24834 return NULL;
24835 }
24836
24837
24838 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24839 PyObject *resultobj;
24840 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24841 int result;
24842 PyObject * obj0 = 0 ;
24843 char *kwnames[] = {
24844 (char *) "self", NULL
24845 };
24846
24847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24849 if (SWIG_arg_fail(1)) SWIG_fail;
24850 {
24851 PyThreadState* __tstate = wxPyBeginAllowThreads();
24852 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24853
24854 wxPyEndAllowThreads(__tstate);
24855 if (PyErr_Occurred()) SWIG_fail;
24856 }
24857 {
24858 resultobj = SWIG_From_int((int)(result));
24859 }
24860 return resultobj;
24861 fail:
24862 return NULL;
24863 }
24864
24865
24866 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24867 PyObject *resultobj;
24868 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24869 int result;
24870 PyObject * obj0 = 0 ;
24871 char *kwnames[] = {
24872 (char *) "self", NULL
24873 };
24874
24875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24877 if (SWIG_arg_fail(1)) SWIG_fail;
24878 {
24879 PyThreadState* __tstate = wxPyBeginAllowThreads();
24880 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24881
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 {
24886 resultobj = SWIG_From_int((int)(result));
24887 }
24888 return resultobj;
24889 fail:
24890 return NULL;
24891 }
24892
24893
24894 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24895 PyObject *resultobj;
24896 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24897 int result;
24898 PyObject * obj0 = 0 ;
24899 char *kwnames[] = {
24900 (char *) "self", NULL
24901 };
24902
24903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24905 if (SWIG_arg_fail(1)) SWIG_fail;
24906 {
24907 PyThreadState* __tstate = wxPyBeginAllowThreads();
24908 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24909
24910 wxPyEndAllowThreads(__tstate);
24911 if (PyErr_Occurred()) SWIG_fail;
24912 }
24913 {
24914 resultobj = SWIG_From_int((int)(result));
24915 }
24916 return resultobj;
24917 fail:
24918 return NULL;
24919 }
24920
24921
24922 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24923 PyObject *resultobj;
24924 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24925 wxLongLong result;
24926 PyObject * obj0 = 0 ;
24927 char *kwnames[] = {
24928 (char *) "self", NULL
24929 };
24930
24931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
24932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24933 if (SWIG_arg_fail(1)) SWIG_fail;
24934 {
24935 PyThreadState* __tstate = wxPyBeginAllowThreads();
24936 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24937
24938 wxPyEndAllowThreads(__tstate);
24939 if (PyErr_Occurred()) SWIG_fail;
24940 }
24941 {
24942 PyObject *hi, *lo, *shifter, *shifted;
24943 hi = PyLong_FromLong( (&result)->GetHi() );
24944 lo = PyLong_FromLong( (&result)->GetLo() );
24945 shifter = PyLong_FromLong(32);
24946 shifted = PyNumber_Lshift(hi, shifter);
24947 resultobj = PyNumber_Or(shifted, lo);
24948 Py_DECREF(hi);
24949 Py_DECREF(lo);
24950 Py_DECREF(shifter);
24951 Py_DECREF(shifted);
24952 }
24953 return resultobj;
24954 fail:
24955 return NULL;
24956 }
24957
24958
24959 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24960 PyObject *resultobj;
24961 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24962 wxLongLong result;
24963 PyObject * obj0 = 0 ;
24964 char *kwnames[] = {
24965 (char *) "self", NULL
24966 };
24967
24968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
24969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24970 if (SWIG_arg_fail(1)) SWIG_fail;
24971 {
24972 PyThreadState* __tstate = wxPyBeginAllowThreads();
24973 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
24974
24975 wxPyEndAllowThreads(__tstate);
24976 if (PyErr_Occurred()) SWIG_fail;
24977 }
24978 {
24979 PyObject *hi, *lo, *shifter, *shifted;
24980 hi = PyLong_FromLong( (&result)->GetHi() );
24981 lo = PyLong_FromLong( (&result)->GetLo() );
24982 shifter = PyLong_FromLong(32);
24983 shifted = PyNumber_Lshift(hi, shifter);
24984 resultobj = PyNumber_Or(shifted, lo);
24985 Py_DECREF(hi);
24986 Py_DECREF(lo);
24987 Py_DECREF(shifter);
24988 Py_DECREF(shifted);
24989 }
24990 return resultobj;
24991 fail:
24992 return NULL;
24993 }
24994
24995
24996 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24997 PyObject *resultobj;
24998 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24999 wxString const &arg2_defvalue = wxPyTimeSpanFormatStr ;
25000 wxString *arg2 = (wxString *) &arg2_defvalue ;
25001 wxString result;
25002 bool temp2 = false ;
25003 PyObject * obj0 = 0 ;
25004 PyObject * obj1 = 0 ;
25005 char *kwnames[] = {
25006 (char *) "self",(char *) "format", NULL
25007 };
25008
25009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25011 if (SWIG_arg_fail(1)) SWIG_fail;
25012 if (obj1) {
25013 {
25014 arg2 = wxString_in_helper(obj1);
25015 if (arg2 == NULL) SWIG_fail;
25016 temp2 = true;
25017 }
25018 }
25019 {
25020 PyThreadState* __tstate = wxPyBeginAllowThreads();
25021 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25022
25023 wxPyEndAllowThreads(__tstate);
25024 if (PyErr_Occurred()) SWIG_fail;
25025 }
25026 {
25027 #if wxUSE_UNICODE
25028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25029 #else
25030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25031 #endif
25032 }
25033 {
25034 if (temp2)
25035 delete arg2;
25036 }
25037 return resultobj;
25038 fail:
25039 {
25040 if (temp2)
25041 delete arg2;
25042 }
25043 return NULL;
25044 }
25045
25046
25047 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25048 PyObject *obj;
25049 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25050 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25051 Py_INCREF(obj);
25052 return Py_BuildValue((char *)"");
25053 }
25054 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25055 PyObject *resultobj;
25056 int arg1 = (int) 0 ;
25057 int arg2 = (int) 0 ;
25058 int arg3 = (int) 0 ;
25059 int arg4 = (int) 0 ;
25060 wxDateSpan *result;
25061 PyObject * obj0 = 0 ;
25062 PyObject * obj1 = 0 ;
25063 PyObject * obj2 = 0 ;
25064 PyObject * obj3 = 0 ;
25065 char *kwnames[] = {
25066 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25067 };
25068
25069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25070 if (obj0) {
25071 {
25072 arg1 = (int)(SWIG_As_int(obj0));
25073 if (SWIG_arg_fail(1)) SWIG_fail;
25074 }
25075 }
25076 if (obj1) {
25077 {
25078 arg2 = (int)(SWIG_As_int(obj1));
25079 if (SWIG_arg_fail(2)) SWIG_fail;
25080 }
25081 }
25082 if (obj2) {
25083 {
25084 arg3 = (int)(SWIG_As_int(obj2));
25085 if (SWIG_arg_fail(3)) SWIG_fail;
25086 }
25087 }
25088 if (obj3) {
25089 {
25090 arg4 = (int)(SWIG_As_int(obj3));
25091 if (SWIG_arg_fail(4)) SWIG_fail;
25092 }
25093 }
25094 {
25095 PyThreadState* __tstate = wxPyBeginAllowThreads();
25096 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25097
25098 wxPyEndAllowThreads(__tstate);
25099 if (PyErr_Occurred()) SWIG_fail;
25100 }
25101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25102 return resultobj;
25103 fail:
25104 return NULL;
25105 }
25106
25107
25108 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25109 PyObject *resultobj;
25110 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25111 PyObject * obj0 = 0 ;
25112 char *kwnames[] = {
25113 (char *) "self", NULL
25114 };
25115
25116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25118 if (SWIG_arg_fail(1)) SWIG_fail;
25119 {
25120 PyThreadState* __tstate = wxPyBeginAllowThreads();
25121 delete arg1;
25122
25123 wxPyEndAllowThreads(__tstate);
25124 if (PyErr_Occurred()) SWIG_fail;
25125 }
25126 Py_INCREF(Py_None); resultobj = Py_None;
25127 return resultobj;
25128 fail:
25129 return NULL;
25130 }
25131
25132
25133 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25134 PyObject *resultobj;
25135 int arg1 ;
25136 wxDateSpan result;
25137 PyObject * obj0 = 0 ;
25138 char *kwnames[] = {
25139 (char *) "days", NULL
25140 };
25141
25142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25143 {
25144 arg1 = (int)(SWIG_As_int(obj0));
25145 if (SWIG_arg_fail(1)) SWIG_fail;
25146 }
25147 {
25148 PyThreadState* __tstate = wxPyBeginAllowThreads();
25149 result = wxDateSpan::Days(arg1);
25150
25151 wxPyEndAllowThreads(__tstate);
25152 if (PyErr_Occurred()) SWIG_fail;
25153 }
25154 {
25155 wxDateSpan * resultptr;
25156 resultptr = new wxDateSpan((wxDateSpan &)(result));
25157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25158 }
25159 return resultobj;
25160 fail:
25161 return NULL;
25162 }
25163
25164
25165 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25166 PyObject *resultobj;
25167 wxDateSpan result;
25168 char *kwnames[] = {
25169 NULL
25170 };
25171
25172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25173 {
25174 PyThreadState* __tstate = wxPyBeginAllowThreads();
25175 result = wxDateSpan::Day();
25176
25177 wxPyEndAllowThreads(__tstate);
25178 if (PyErr_Occurred()) SWIG_fail;
25179 }
25180 {
25181 wxDateSpan * resultptr;
25182 resultptr = new wxDateSpan((wxDateSpan &)(result));
25183 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25184 }
25185 return resultobj;
25186 fail:
25187 return NULL;
25188 }
25189
25190
25191 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25192 PyObject *resultobj;
25193 int arg1 ;
25194 wxDateSpan result;
25195 PyObject * obj0 = 0 ;
25196 char *kwnames[] = {
25197 (char *) "weeks", NULL
25198 };
25199
25200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25201 {
25202 arg1 = (int)(SWIG_As_int(obj0));
25203 if (SWIG_arg_fail(1)) SWIG_fail;
25204 }
25205 {
25206 PyThreadState* __tstate = wxPyBeginAllowThreads();
25207 result = wxDateSpan::Weeks(arg1);
25208
25209 wxPyEndAllowThreads(__tstate);
25210 if (PyErr_Occurred()) SWIG_fail;
25211 }
25212 {
25213 wxDateSpan * resultptr;
25214 resultptr = new wxDateSpan((wxDateSpan &)(result));
25215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25216 }
25217 return resultobj;
25218 fail:
25219 return NULL;
25220 }
25221
25222
25223 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25224 PyObject *resultobj;
25225 wxDateSpan result;
25226 char *kwnames[] = {
25227 NULL
25228 };
25229
25230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25231 {
25232 PyThreadState* __tstate = wxPyBeginAllowThreads();
25233 result = wxDateSpan::Week();
25234
25235 wxPyEndAllowThreads(__tstate);
25236 if (PyErr_Occurred()) SWIG_fail;
25237 }
25238 {
25239 wxDateSpan * resultptr;
25240 resultptr = new wxDateSpan((wxDateSpan &)(result));
25241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25242 }
25243 return resultobj;
25244 fail:
25245 return NULL;
25246 }
25247
25248
25249 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25250 PyObject *resultobj;
25251 int arg1 ;
25252 wxDateSpan result;
25253 PyObject * obj0 = 0 ;
25254 char *kwnames[] = {
25255 (char *) "mon", NULL
25256 };
25257
25258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25259 {
25260 arg1 = (int)(SWIG_As_int(obj0));
25261 if (SWIG_arg_fail(1)) SWIG_fail;
25262 }
25263 {
25264 PyThreadState* __tstate = wxPyBeginAllowThreads();
25265 result = wxDateSpan::Months(arg1);
25266
25267 wxPyEndAllowThreads(__tstate);
25268 if (PyErr_Occurred()) SWIG_fail;
25269 }
25270 {
25271 wxDateSpan * resultptr;
25272 resultptr = new wxDateSpan((wxDateSpan &)(result));
25273 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25274 }
25275 return resultobj;
25276 fail:
25277 return NULL;
25278 }
25279
25280
25281 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25282 PyObject *resultobj;
25283 wxDateSpan result;
25284 char *kwnames[] = {
25285 NULL
25286 };
25287
25288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25289 {
25290 PyThreadState* __tstate = wxPyBeginAllowThreads();
25291 result = wxDateSpan::Month();
25292
25293 wxPyEndAllowThreads(__tstate);
25294 if (PyErr_Occurred()) SWIG_fail;
25295 }
25296 {
25297 wxDateSpan * resultptr;
25298 resultptr = new wxDateSpan((wxDateSpan &)(result));
25299 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25300 }
25301 return resultobj;
25302 fail:
25303 return NULL;
25304 }
25305
25306
25307 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25308 PyObject *resultobj;
25309 int arg1 ;
25310 wxDateSpan result;
25311 PyObject * obj0 = 0 ;
25312 char *kwnames[] = {
25313 (char *) "years", NULL
25314 };
25315
25316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25317 {
25318 arg1 = (int)(SWIG_As_int(obj0));
25319 if (SWIG_arg_fail(1)) SWIG_fail;
25320 }
25321 {
25322 PyThreadState* __tstate = wxPyBeginAllowThreads();
25323 result = wxDateSpan::Years(arg1);
25324
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 {
25329 wxDateSpan * resultptr;
25330 resultptr = new wxDateSpan((wxDateSpan &)(result));
25331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25332 }
25333 return resultobj;
25334 fail:
25335 return NULL;
25336 }
25337
25338
25339 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25340 PyObject *resultobj;
25341 wxDateSpan result;
25342 char *kwnames[] = {
25343 NULL
25344 };
25345
25346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25347 {
25348 PyThreadState* __tstate = wxPyBeginAllowThreads();
25349 result = wxDateSpan::Year();
25350
25351 wxPyEndAllowThreads(__tstate);
25352 if (PyErr_Occurred()) SWIG_fail;
25353 }
25354 {
25355 wxDateSpan * resultptr;
25356 resultptr = new wxDateSpan((wxDateSpan &)(result));
25357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25358 }
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25366 PyObject *resultobj;
25367 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25368 int arg2 ;
25369 wxDateSpan *result;
25370 PyObject * obj0 = 0 ;
25371 PyObject * obj1 = 0 ;
25372 char *kwnames[] = {
25373 (char *) "self",(char *) "n", NULL
25374 };
25375
25376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25378 if (SWIG_arg_fail(1)) SWIG_fail;
25379 {
25380 arg2 = (int)(SWIG_As_int(obj1));
25381 if (SWIG_arg_fail(2)) SWIG_fail;
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 {
25386 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25387 result = (wxDateSpan *) &_result_ref;
25388 }
25389
25390 wxPyEndAllowThreads(__tstate);
25391 if (PyErr_Occurred()) SWIG_fail;
25392 }
25393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25394 return resultobj;
25395 fail:
25396 return NULL;
25397 }
25398
25399
25400 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25401 PyObject *resultobj;
25402 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25403 int arg2 ;
25404 wxDateSpan *result;
25405 PyObject * obj0 = 0 ;
25406 PyObject * obj1 = 0 ;
25407 char *kwnames[] = {
25408 (char *) "self",(char *) "n", NULL
25409 };
25410
25411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25413 if (SWIG_arg_fail(1)) SWIG_fail;
25414 {
25415 arg2 = (int)(SWIG_As_int(obj1));
25416 if (SWIG_arg_fail(2)) SWIG_fail;
25417 }
25418 {
25419 PyThreadState* __tstate = wxPyBeginAllowThreads();
25420 {
25421 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25422 result = (wxDateSpan *) &_result_ref;
25423 }
25424
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25436 PyObject *resultobj;
25437 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25438 int arg2 ;
25439 wxDateSpan *result;
25440 PyObject * obj0 = 0 ;
25441 PyObject * obj1 = 0 ;
25442 char *kwnames[] = {
25443 (char *) "self",(char *) "n", NULL
25444 };
25445
25446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25448 if (SWIG_arg_fail(1)) SWIG_fail;
25449 {
25450 arg2 = (int)(SWIG_As_int(obj1));
25451 if (SWIG_arg_fail(2)) SWIG_fail;
25452 }
25453 {
25454 PyThreadState* __tstate = wxPyBeginAllowThreads();
25455 {
25456 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25457 result = (wxDateSpan *) &_result_ref;
25458 }
25459
25460 wxPyEndAllowThreads(__tstate);
25461 if (PyErr_Occurred()) SWIG_fail;
25462 }
25463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25464 return resultobj;
25465 fail:
25466 return NULL;
25467 }
25468
25469
25470 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25471 PyObject *resultobj;
25472 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25473 int arg2 ;
25474 wxDateSpan *result;
25475 PyObject * obj0 = 0 ;
25476 PyObject * obj1 = 0 ;
25477 char *kwnames[] = {
25478 (char *) "self",(char *) "n", NULL
25479 };
25480
25481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25483 if (SWIG_arg_fail(1)) SWIG_fail;
25484 {
25485 arg2 = (int)(SWIG_As_int(obj1));
25486 if (SWIG_arg_fail(2)) SWIG_fail;
25487 }
25488 {
25489 PyThreadState* __tstate = wxPyBeginAllowThreads();
25490 {
25491 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25492 result = (wxDateSpan *) &_result_ref;
25493 }
25494
25495 wxPyEndAllowThreads(__tstate);
25496 if (PyErr_Occurred()) SWIG_fail;
25497 }
25498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25499 return resultobj;
25500 fail:
25501 return NULL;
25502 }
25503
25504
25505 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25506 PyObject *resultobj;
25507 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25508 int result;
25509 PyObject * obj0 = 0 ;
25510 char *kwnames[] = {
25511 (char *) "self", NULL
25512 };
25513
25514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25516 if (SWIG_arg_fail(1)) SWIG_fail;
25517 {
25518 PyThreadState* __tstate = wxPyBeginAllowThreads();
25519 result = (int)((wxDateSpan const *)arg1)->GetYears();
25520
25521 wxPyEndAllowThreads(__tstate);
25522 if (PyErr_Occurred()) SWIG_fail;
25523 }
25524 {
25525 resultobj = SWIG_From_int((int)(result));
25526 }
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25534 PyObject *resultobj;
25535 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25536 int result;
25537 PyObject * obj0 = 0 ;
25538 char *kwnames[] = {
25539 (char *) "self", NULL
25540 };
25541
25542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25544 if (SWIG_arg_fail(1)) SWIG_fail;
25545 {
25546 PyThreadState* __tstate = wxPyBeginAllowThreads();
25547 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25548
25549 wxPyEndAllowThreads(__tstate);
25550 if (PyErr_Occurred()) SWIG_fail;
25551 }
25552 {
25553 resultobj = SWIG_From_int((int)(result));
25554 }
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25562 PyObject *resultobj;
25563 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25564 int result;
25565 PyObject * obj0 = 0 ;
25566 char *kwnames[] = {
25567 (char *) "self", NULL
25568 };
25569
25570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25572 if (SWIG_arg_fail(1)) SWIG_fail;
25573 {
25574 PyThreadState* __tstate = wxPyBeginAllowThreads();
25575 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25576
25577 wxPyEndAllowThreads(__tstate);
25578 if (PyErr_Occurred()) SWIG_fail;
25579 }
25580 {
25581 resultobj = SWIG_From_int((int)(result));
25582 }
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25590 PyObject *resultobj;
25591 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25592 int result;
25593 PyObject * obj0 = 0 ;
25594 char *kwnames[] = {
25595 (char *) "self", NULL
25596 };
25597
25598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25600 if (SWIG_arg_fail(1)) SWIG_fail;
25601 {
25602 PyThreadState* __tstate = wxPyBeginAllowThreads();
25603 result = (int)((wxDateSpan const *)arg1)->GetDays();
25604
25605 wxPyEndAllowThreads(__tstate);
25606 if (PyErr_Occurred()) SWIG_fail;
25607 }
25608 {
25609 resultobj = SWIG_From_int((int)(result));
25610 }
25611 return resultobj;
25612 fail:
25613 return NULL;
25614 }
25615
25616
25617 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25618 PyObject *resultobj;
25619 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25620 int result;
25621 PyObject * obj0 = 0 ;
25622 char *kwnames[] = {
25623 (char *) "self", NULL
25624 };
25625
25626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25628 if (SWIG_arg_fail(1)) SWIG_fail;
25629 {
25630 PyThreadState* __tstate = wxPyBeginAllowThreads();
25631 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25632
25633 wxPyEndAllowThreads(__tstate);
25634 if (PyErr_Occurred()) SWIG_fail;
25635 }
25636 {
25637 resultobj = SWIG_From_int((int)(result));
25638 }
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25646 PyObject *resultobj;
25647 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25648 wxDateSpan *arg2 = 0 ;
25649 wxDateSpan *result;
25650 PyObject * obj0 = 0 ;
25651 PyObject * obj1 = 0 ;
25652 char *kwnames[] = {
25653 (char *) "self",(char *) "other", NULL
25654 };
25655
25656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25658 if (SWIG_arg_fail(1)) SWIG_fail;
25659 {
25660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25661 if (SWIG_arg_fail(2)) SWIG_fail;
25662 if (arg2 == NULL) {
25663 SWIG_null_ref("wxDateSpan");
25664 }
25665 if (SWIG_arg_fail(2)) SWIG_fail;
25666 }
25667 {
25668 PyThreadState* __tstate = wxPyBeginAllowThreads();
25669 {
25670 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25671 result = (wxDateSpan *) &_result_ref;
25672 }
25673
25674 wxPyEndAllowThreads(__tstate);
25675 if (PyErr_Occurred()) SWIG_fail;
25676 }
25677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25678 return resultobj;
25679 fail:
25680 return NULL;
25681 }
25682
25683
25684 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25685 PyObject *resultobj;
25686 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25687 wxDateSpan *arg2 = 0 ;
25688 wxDateSpan *result;
25689 PyObject * obj0 = 0 ;
25690 PyObject * obj1 = 0 ;
25691 char *kwnames[] = {
25692 (char *) "self",(char *) "other", NULL
25693 };
25694
25695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25697 if (SWIG_arg_fail(1)) SWIG_fail;
25698 {
25699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25700 if (SWIG_arg_fail(2)) SWIG_fail;
25701 if (arg2 == NULL) {
25702 SWIG_null_ref("wxDateSpan");
25703 }
25704 if (SWIG_arg_fail(2)) SWIG_fail;
25705 }
25706 {
25707 PyThreadState* __tstate = wxPyBeginAllowThreads();
25708 {
25709 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25710 result = (wxDateSpan *) &_result_ref;
25711 }
25712
25713 wxPyEndAllowThreads(__tstate);
25714 if (PyErr_Occurred()) SWIG_fail;
25715 }
25716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25724 PyObject *resultobj;
25725 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25726 wxDateSpan *result;
25727 PyObject * obj0 = 0 ;
25728 char *kwnames[] = {
25729 (char *) "self", NULL
25730 };
25731
25732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25734 if (SWIG_arg_fail(1)) SWIG_fail;
25735 {
25736 PyThreadState* __tstate = wxPyBeginAllowThreads();
25737 {
25738 wxDateSpan &_result_ref = (arg1)->Neg();
25739 result = (wxDateSpan *) &_result_ref;
25740 }
25741
25742 wxPyEndAllowThreads(__tstate);
25743 if (PyErr_Occurred()) SWIG_fail;
25744 }
25745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25746 return resultobj;
25747 fail:
25748 return NULL;
25749 }
25750
25751
25752 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25753 PyObject *resultobj;
25754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25755 int arg2 ;
25756 wxDateSpan *result;
25757 PyObject * obj0 = 0 ;
25758 PyObject * obj1 = 0 ;
25759 char *kwnames[] = {
25760 (char *) "self",(char *) "factor", NULL
25761 };
25762
25763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25765 if (SWIG_arg_fail(1)) SWIG_fail;
25766 {
25767 arg2 = (int)(SWIG_As_int(obj1));
25768 if (SWIG_arg_fail(2)) SWIG_fail;
25769 }
25770 {
25771 PyThreadState* __tstate = wxPyBeginAllowThreads();
25772 {
25773 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25774 result = (wxDateSpan *) &_result_ref;
25775 }
25776
25777 wxPyEndAllowThreads(__tstate);
25778 if (PyErr_Occurred()) SWIG_fail;
25779 }
25780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25781 return resultobj;
25782 fail:
25783 return NULL;
25784 }
25785
25786
25787 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25788 PyObject *resultobj;
25789 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25790 wxDateSpan *arg2 = 0 ;
25791 wxDateSpan *result;
25792 PyObject * obj0 = 0 ;
25793 PyObject * obj1 = 0 ;
25794 char *kwnames[] = {
25795 (char *) "self",(char *) "other", NULL
25796 };
25797
25798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25800 if (SWIG_arg_fail(1)) SWIG_fail;
25801 {
25802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25803 if (SWIG_arg_fail(2)) SWIG_fail;
25804 if (arg2 == NULL) {
25805 SWIG_null_ref("wxDateSpan");
25806 }
25807 if (SWIG_arg_fail(2)) SWIG_fail;
25808 }
25809 {
25810 PyThreadState* __tstate = wxPyBeginAllowThreads();
25811 {
25812 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25813 result = (wxDateSpan *) &_result_ref;
25814 }
25815
25816 wxPyEndAllowThreads(__tstate);
25817 if (PyErr_Occurred()) SWIG_fail;
25818 }
25819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25820 return resultobj;
25821 fail:
25822 return NULL;
25823 }
25824
25825
25826 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25827 PyObject *resultobj;
25828 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25829 wxDateSpan *arg2 = 0 ;
25830 wxDateSpan *result;
25831 PyObject * obj0 = 0 ;
25832 PyObject * obj1 = 0 ;
25833 char *kwnames[] = {
25834 (char *) "self",(char *) "other", NULL
25835 };
25836
25837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25839 if (SWIG_arg_fail(1)) SWIG_fail;
25840 {
25841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25842 if (SWIG_arg_fail(2)) SWIG_fail;
25843 if (arg2 == NULL) {
25844 SWIG_null_ref("wxDateSpan");
25845 }
25846 if (SWIG_arg_fail(2)) SWIG_fail;
25847 }
25848 {
25849 PyThreadState* __tstate = wxPyBeginAllowThreads();
25850 {
25851 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25852 result = (wxDateSpan *) &_result_ref;
25853 }
25854
25855 wxPyEndAllowThreads(__tstate);
25856 if (PyErr_Occurred()) SWIG_fail;
25857 }
25858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25859 return resultobj;
25860 fail:
25861 return NULL;
25862 }
25863
25864
25865 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25866 PyObject *resultobj;
25867 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25868 wxDateSpan *result;
25869 PyObject * obj0 = 0 ;
25870 char *kwnames[] = {
25871 (char *) "self", NULL
25872 };
25873
25874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25876 if (SWIG_arg_fail(1)) SWIG_fail;
25877 {
25878 PyThreadState* __tstate = wxPyBeginAllowThreads();
25879 {
25880 wxDateSpan &_result_ref = (arg1)->operator -();
25881 result = (wxDateSpan *) &_result_ref;
25882 }
25883
25884 wxPyEndAllowThreads(__tstate);
25885 if (PyErr_Occurred()) SWIG_fail;
25886 }
25887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25888 return resultobj;
25889 fail:
25890 return NULL;
25891 }
25892
25893
25894 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25895 PyObject *resultobj;
25896 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25897 int arg2 ;
25898 wxDateSpan *result;
25899 PyObject * obj0 = 0 ;
25900 PyObject * obj1 = 0 ;
25901 char *kwnames[] = {
25902 (char *) "self",(char *) "factor", NULL
25903 };
25904
25905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25907 if (SWIG_arg_fail(1)) SWIG_fail;
25908 {
25909 arg2 = (int)(SWIG_As_int(obj1));
25910 if (SWIG_arg_fail(2)) SWIG_fail;
25911 }
25912 {
25913 PyThreadState* __tstate = wxPyBeginAllowThreads();
25914 {
25915 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25916 result = (wxDateSpan *) &_result_ref;
25917 }
25918
25919 wxPyEndAllowThreads(__tstate);
25920 if (PyErr_Occurred()) SWIG_fail;
25921 }
25922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25923 return resultobj;
25924 fail:
25925 return NULL;
25926 }
25927
25928
25929 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25930 PyObject *resultobj;
25931 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25932 wxDateSpan *arg2 = 0 ;
25933 wxDateSpan result;
25934 PyObject * obj0 = 0 ;
25935 PyObject * obj1 = 0 ;
25936 char *kwnames[] = {
25937 (char *) "self",(char *) "other", NULL
25938 };
25939
25940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25942 if (SWIG_arg_fail(1)) SWIG_fail;
25943 {
25944 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25945 if (SWIG_arg_fail(2)) SWIG_fail;
25946 if (arg2 == NULL) {
25947 SWIG_null_ref("wxDateSpan");
25948 }
25949 if (SWIG_arg_fail(2)) SWIG_fail;
25950 }
25951 {
25952 PyThreadState* __tstate = wxPyBeginAllowThreads();
25953 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25954
25955 wxPyEndAllowThreads(__tstate);
25956 if (PyErr_Occurred()) SWIG_fail;
25957 }
25958 {
25959 wxDateSpan * resultptr;
25960 resultptr = new wxDateSpan((wxDateSpan &)(result));
25961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25962 }
25963 return resultobj;
25964 fail:
25965 return NULL;
25966 }
25967
25968
25969 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25970 PyObject *resultobj;
25971 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25972 wxDateSpan *arg2 = 0 ;
25973 wxDateSpan result;
25974 PyObject * obj0 = 0 ;
25975 PyObject * obj1 = 0 ;
25976 char *kwnames[] = {
25977 (char *) "self",(char *) "other", NULL
25978 };
25979
25980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25982 if (SWIG_arg_fail(1)) SWIG_fail;
25983 {
25984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25985 if (SWIG_arg_fail(2)) SWIG_fail;
25986 if (arg2 == NULL) {
25987 SWIG_null_ref("wxDateSpan");
25988 }
25989 if (SWIG_arg_fail(2)) SWIG_fail;
25990 }
25991 {
25992 PyThreadState* __tstate = wxPyBeginAllowThreads();
25993 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
25994
25995 wxPyEndAllowThreads(__tstate);
25996 if (PyErr_Occurred()) SWIG_fail;
25997 }
25998 {
25999 wxDateSpan * resultptr;
26000 resultptr = new wxDateSpan((wxDateSpan &)(result));
26001 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26002 }
26003 return resultobj;
26004 fail:
26005 return NULL;
26006 }
26007
26008
26009 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26010 PyObject *resultobj;
26011 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26012 int arg2 ;
26013 wxDateSpan result;
26014 PyObject * obj0 = 0 ;
26015 PyObject * obj1 = 0 ;
26016 char *kwnames[] = {
26017 (char *) "self",(char *) "n", NULL
26018 };
26019
26020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26022 if (SWIG_arg_fail(1)) SWIG_fail;
26023 {
26024 arg2 = (int)(SWIG_As_int(obj1));
26025 if (SWIG_arg_fail(2)) SWIG_fail;
26026 }
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 result = wxDateSpan___mul__(arg1,arg2);
26030
26031 wxPyEndAllowThreads(__tstate);
26032 if (PyErr_Occurred()) SWIG_fail;
26033 }
26034 {
26035 wxDateSpan * resultptr;
26036 resultptr = new wxDateSpan((wxDateSpan &)(result));
26037 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26038 }
26039 return resultobj;
26040 fail:
26041 return NULL;
26042 }
26043
26044
26045 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26046 PyObject *resultobj;
26047 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26048 int arg2 ;
26049 wxDateSpan result;
26050 PyObject * obj0 = 0 ;
26051 PyObject * obj1 = 0 ;
26052 char *kwnames[] = {
26053 (char *) "self",(char *) "n", NULL
26054 };
26055
26056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26058 if (SWIG_arg_fail(1)) SWIG_fail;
26059 {
26060 arg2 = (int)(SWIG_As_int(obj1));
26061 if (SWIG_arg_fail(2)) SWIG_fail;
26062 }
26063 {
26064 PyThreadState* __tstate = wxPyBeginAllowThreads();
26065 result = wxDateSpan___rmul__(arg1,arg2);
26066
26067 wxPyEndAllowThreads(__tstate);
26068 if (PyErr_Occurred()) SWIG_fail;
26069 }
26070 {
26071 wxDateSpan * resultptr;
26072 resultptr = new wxDateSpan((wxDateSpan &)(result));
26073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26074 }
26075 return resultobj;
26076 fail:
26077 return NULL;
26078 }
26079
26080
26081 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26082 PyObject *resultobj;
26083 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26084 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26085 bool result;
26086 PyObject * obj0 = 0 ;
26087 PyObject * obj1 = 0 ;
26088 char *kwnames[] = {
26089 (char *) "self",(char *) "other", NULL
26090 };
26091
26092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26094 if (SWIG_arg_fail(1)) SWIG_fail;
26095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26096 if (SWIG_arg_fail(2)) SWIG_fail;
26097 {
26098 PyThreadState* __tstate = wxPyBeginAllowThreads();
26099 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26100
26101 wxPyEndAllowThreads(__tstate);
26102 if (PyErr_Occurred()) SWIG_fail;
26103 }
26104 {
26105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26106 }
26107 return resultobj;
26108 fail:
26109 return NULL;
26110 }
26111
26112
26113 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26114 PyObject *resultobj;
26115 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26116 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26117 bool result;
26118 PyObject * obj0 = 0 ;
26119 PyObject * obj1 = 0 ;
26120 char *kwnames[] = {
26121 (char *) "self",(char *) "other", NULL
26122 };
26123
26124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26126 if (SWIG_arg_fail(1)) SWIG_fail;
26127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26128 if (SWIG_arg_fail(2)) SWIG_fail;
26129 {
26130 PyThreadState* __tstate = wxPyBeginAllowThreads();
26131 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26132
26133 wxPyEndAllowThreads(__tstate);
26134 if (PyErr_Occurred()) SWIG_fail;
26135 }
26136 {
26137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26138 }
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26146 PyObject *obj;
26147 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26148 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26149 Py_INCREF(obj);
26150 return Py_BuildValue((char *)"");
26151 }
26152 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26153 PyObject *resultobj;
26154 long result;
26155 char *kwnames[] = {
26156 NULL
26157 };
26158
26159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26160 {
26161 PyThreadState* __tstate = wxPyBeginAllowThreads();
26162 result = (long)wxGetLocalTime();
26163
26164 wxPyEndAllowThreads(__tstate);
26165 if (PyErr_Occurred()) SWIG_fail;
26166 }
26167 {
26168 resultobj = SWIG_From_long((long)(result));
26169 }
26170 return resultobj;
26171 fail:
26172 return NULL;
26173 }
26174
26175
26176 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26177 PyObject *resultobj;
26178 long result;
26179 char *kwnames[] = {
26180 NULL
26181 };
26182
26183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26184 {
26185 PyThreadState* __tstate = wxPyBeginAllowThreads();
26186 result = (long)wxGetUTCTime();
26187
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 {
26192 resultobj = SWIG_From_long((long)(result));
26193 }
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26201 PyObject *resultobj;
26202 long result;
26203 char *kwnames[] = {
26204 NULL
26205 };
26206
26207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 result = (long)wxGetCurrentTime();
26211
26212 wxPyEndAllowThreads(__tstate);
26213 if (PyErr_Occurred()) SWIG_fail;
26214 }
26215 {
26216 resultobj = SWIG_From_long((long)(result));
26217 }
26218 return resultobj;
26219 fail:
26220 return NULL;
26221 }
26222
26223
26224 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26225 PyObject *resultobj;
26226 wxLongLong result;
26227 char *kwnames[] = {
26228 NULL
26229 };
26230
26231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26232 {
26233 PyThreadState* __tstate = wxPyBeginAllowThreads();
26234 result = wxGetLocalTimeMillis();
26235
26236 wxPyEndAllowThreads(__tstate);
26237 if (PyErr_Occurred()) SWIG_fail;
26238 }
26239 {
26240 PyObject *hi, *lo, *shifter, *shifted;
26241 hi = PyLong_FromLong( (&result)->GetHi() );
26242 lo = PyLong_FromLong( (&result)->GetLo() );
26243 shifter = PyLong_FromLong(32);
26244 shifted = PyNumber_Lshift(hi, shifter);
26245 resultobj = PyNumber_Or(shifted, lo);
26246 Py_DECREF(hi);
26247 Py_DECREF(lo);
26248 Py_DECREF(shifter);
26249 Py_DECREF(shifted);
26250 }
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 static int _wrap_DefaultDateTime_set(PyObject *) {
26258 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26259 return 1;
26260 }
26261
26262
26263 static PyObject *_wrap_DefaultDateTime_get(void) {
26264 PyObject *pyobj;
26265
26266 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26267 return pyobj;
26268 }
26269
26270
26271 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26272 PyObject *resultobj;
26273 wxDataFormatId arg1 ;
26274 wxDataFormat *result;
26275 PyObject * obj0 = 0 ;
26276 char *kwnames[] = {
26277 (char *) "type", NULL
26278 };
26279
26280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26281 {
26282 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26283 if (SWIG_arg_fail(1)) SWIG_fail;
26284 }
26285 {
26286 PyThreadState* __tstate = wxPyBeginAllowThreads();
26287 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26288
26289 wxPyEndAllowThreads(__tstate);
26290 if (PyErr_Occurred()) SWIG_fail;
26291 }
26292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26293 return resultobj;
26294 fail:
26295 return NULL;
26296 }
26297
26298
26299 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26300 PyObject *resultobj;
26301 wxString *arg1 = 0 ;
26302 wxDataFormat *result;
26303 bool temp1 = false ;
26304 PyObject * obj0 = 0 ;
26305 char *kwnames[] = {
26306 (char *) "format", NULL
26307 };
26308
26309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26310 {
26311 arg1 = wxString_in_helper(obj0);
26312 if (arg1 == NULL) SWIG_fail;
26313 temp1 = true;
26314 }
26315 {
26316 PyThreadState* __tstate = wxPyBeginAllowThreads();
26317 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26318
26319 wxPyEndAllowThreads(__tstate);
26320 if (PyErr_Occurred()) SWIG_fail;
26321 }
26322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26323 {
26324 if (temp1)
26325 delete arg1;
26326 }
26327 return resultobj;
26328 fail:
26329 {
26330 if (temp1)
26331 delete arg1;
26332 }
26333 return NULL;
26334 }
26335
26336
26337 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26338 PyObject *resultobj;
26339 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26340 PyObject * obj0 = 0 ;
26341 char *kwnames[] = {
26342 (char *) "self", NULL
26343 };
26344
26345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26347 if (SWIG_arg_fail(1)) SWIG_fail;
26348 {
26349 PyThreadState* __tstate = wxPyBeginAllowThreads();
26350 delete arg1;
26351
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 Py_INCREF(Py_None); resultobj = Py_None;
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26363 PyObject *resultobj;
26364 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26365 wxDataFormatId arg2 ;
26366 bool result;
26367 PyObject * obj0 = 0 ;
26368 PyObject * obj1 = 0 ;
26369
26370 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26372 if (SWIG_arg_fail(1)) SWIG_fail;
26373 {
26374 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26375 if (SWIG_arg_fail(2)) SWIG_fail;
26376 }
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26380
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 {
26385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26386 }
26387 return resultobj;
26388 fail:
26389 return NULL;
26390 }
26391
26392
26393 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26394 PyObject *resultobj;
26395 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26396 wxDataFormatId arg2 ;
26397 bool result;
26398 PyObject * obj0 = 0 ;
26399 PyObject * obj1 = 0 ;
26400
26401 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26403 if (SWIG_arg_fail(1)) SWIG_fail;
26404 {
26405 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26406 if (SWIG_arg_fail(2)) SWIG_fail;
26407 }
26408 {
26409 PyThreadState* __tstate = wxPyBeginAllowThreads();
26410 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26411
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 {
26416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26417 }
26418 return resultobj;
26419 fail:
26420 return NULL;
26421 }
26422
26423
26424 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26425 PyObject *resultobj;
26426 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26427 wxDataFormat *arg2 = 0 ;
26428 bool result;
26429 PyObject * obj0 = 0 ;
26430 PyObject * obj1 = 0 ;
26431
26432 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26434 if (SWIG_arg_fail(1)) SWIG_fail;
26435 {
26436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26437 if (SWIG_arg_fail(2)) SWIG_fail;
26438 if (arg2 == NULL) {
26439 SWIG_null_ref("wxDataFormat");
26440 }
26441 if (SWIG_arg_fail(2)) SWIG_fail;
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26446
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 {
26451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26452 }
26453 return resultobj;
26454 fail:
26455 return NULL;
26456 }
26457
26458
26459 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26460 int argc;
26461 PyObject *argv[3];
26462 int ii;
26463
26464 argc = PyObject_Length(args);
26465 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26466 argv[ii] = PyTuple_GetItem(args,ii);
26467 }
26468 if (argc == 2) {
26469 int _v;
26470 {
26471 void *ptr;
26472 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26473 _v = 0;
26474 PyErr_Clear();
26475 } else {
26476 _v = 1;
26477 }
26478 }
26479 if (_v) {
26480 {
26481 void *ptr = 0;
26482 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26483 _v = 0;
26484 PyErr_Clear();
26485 } else {
26486 _v = (ptr != 0);
26487 }
26488 }
26489 if (_v) {
26490 return _wrap_DataFormat___eq____SWIG_1(self,args);
26491 }
26492 }
26493 }
26494 if (argc == 2) {
26495 int _v;
26496 {
26497 void *ptr;
26498 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26499 _v = 0;
26500 PyErr_Clear();
26501 } else {
26502 _v = 1;
26503 }
26504 }
26505 if (_v) {
26506 _v = SWIG_Check_int(argv[1]);
26507 if (_v) {
26508 return _wrap_DataFormat___eq____SWIG_0(self,args);
26509 }
26510 }
26511 }
26512
26513 Py_INCREF(Py_NotImplemented);
26514 return Py_NotImplemented;
26515 }
26516
26517
26518 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26519 PyObject *resultobj;
26520 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26521 wxDataFormat *arg2 = 0 ;
26522 bool result;
26523 PyObject * obj0 = 0 ;
26524 PyObject * obj1 = 0 ;
26525
26526 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26528 if (SWIG_arg_fail(1)) SWIG_fail;
26529 {
26530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26531 if (SWIG_arg_fail(2)) SWIG_fail;
26532 if (arg2 == NULL) {
26533 SWIG_null_ref("wxDataFormat");
26534 }
26535 if (SWIG_arg_fail(2)) SWIG_fail;
26536 }
26537 {
26538 PyThreadState* __tstate = wxPyBeginAllowThreads();
26539 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26540
26541 wxPyEndAllowThreads(__tstate);
26542 if (PyErr_Occurred()) SWIG_fail;
26543 }
26544 {
26545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26546 }
26547 return resultobj;
26548 fail:
26549 return NULL;
26550 }
26551
26552
26553 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26554 int argc;
26555 PyObject *argv[3];
26556 int ii;
26557
26558 argc = PyObject_Length(args);
26559 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26560 argv[ii] = PyTuple_GetItem(args,ii);
26561 }
26562 if (argc == 2) {
26563 int _v;
26564 {
26565 void *ptr;
26566 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26567 _v = 0;
26568 PyErr_Clear();
26569 } else {
26570 _v = 1;
26571 }
26572 }
26573 if (_v) {
26574 {
26575 void *ptr = 0;
26576 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26577 _v = 0;
26578 PyErr_Clear();
26579 } else {
26580 _v = (ptr != 0);
26581 }
26582 }
26583 if (_v) {
26584 return _wrap_DataFormat___ne____SWIG_1(self,args);
26585 }
26586 }
26587 }
26588 if (argc == 2) {
26589 int _v;
26590 {
26591 void *ptr;
26592 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26593 _v = 0;
26594 PyErr_Clear();
26595 } else {
26596 _v = 1;
26597 }
26598 }
26599 if (_v) {
26600 _v = SWIG_Check_int(argv[1]);
26601 if (_v) {
26602 return _wrap_DataFormat___ne____SWIG_0(self,args);
26603 }
26604 }
26605 }
26606
26607 Py_INCREF(Py_NotImplemented);
26608 return Py_NotImplemented;
26609 }
26610
26611
26612 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26613 PyObject *resultobj;
26614 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26615 wxDataFormatId arg2 ;
26616 PyObject * obj0 = 0 ;
26617 PyObject * obj1 = 0 ;
26618 char *kwnames[] = {
26619 (char *) "self",(char *) "format", NULL
26620 };
26621
26622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26624 if (SWIG_arg_fail(1)) SWIG_fail;
26625 {
26626 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26627 if (SWIG_arg_fail(2)) SWIG_fail;
26628 }
26629 {
26630 PyThreadState* __tstate = wxPyBeginAllowThreads();
26631 (arg1)->SetType((wxDataFormatId )arg2);
26632
26633 wxPyEndAllowThreads(__tstate);
26634 if (PyErr_Occurred()) SWIG_fail;
26635 }
26636 Py_INCREF(Py_None); resultobj = Py_None;
26637 return resultobj;
26638 fail:
26639 return NULL;
26640 }
26641
26642
26643 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26644 PyObject *resultobj;
26645 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26646 wxDataFormatId result;
26647 PyObject * obj0 = 0 ;
26648 char *kwnames[] = {
26649 (char *) "self", NULL
26650 };
26651
26652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26654 if (SWIG_arg_fail(1)) SWIG_fail;
26655 {
26656 PyThreadState* __tstate = wxPyBeginAllowThreads();
26657 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26658
26659 wxPyEndAllowThreads(__tstate);
26660 if (PyErr_Occurred()) SWIG_fail;
26661 }
26662 resultobj = SWIG_From_int((result));
26663 return resultobj;
26664 fail:
26665 return NULL;
26666 }
26667
26668
26669 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26670 PyObject *resultobj;
26671 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26672 wxString result;
26673 PyObject * obj0 = 0 ;
26674 char *kwnames[] = {
26675 (char *) "self", NULL
26676 };
26677
26678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26680 if (SWIG_arg_fail(1)) SWIG_fail;
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 result = ((wxDataFormat const *)arg1)->GetId();
26684
26685 wxPyEndAllowThreads(__tstate);
26686 if (PyErr_Occurred()) SWIG_fail;
26687 }
26688 {
26689 #if wxUSE_UNICODE
26690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26691 #else
26692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26693 #endif
26694 }
26695 return resultobj;
26696 fail:
26697 return NULL;
26698 }
26699
26700
26701 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26702 PyObject *resultobj;
26703 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26704 wxString *arg2 = 0 ;
26705 bool temp2 = false ;
26706 PyObject * obj0 = 0 ;
26707 PyObject * obj1 = 0 ;
26708 char *kwnames[] = {
26709 (char *) "self",(char *) "format", NULL
26710 };
26711
26712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26714 if (SWIG_arg_fail(1)) SWIG_fail;
26715 {
26716 arg2 = wxString_in_helper(obj1);
26717 if (arg2 == NULL) SWIG_fail;
26718 temp2 = true;
26719 }
26720 {
26721 PyThreadState* __tstate = wxPyBeginAllowThreads();
26722 (arg1)->SetId((wxString const &)*arg2);
26723
26724 wxPyEndAllowThreads(__tstate);
26725 if (PyErr_Occurred()) SWIG_fail;
26726 }
26727 Py_INCREF(Py_None); resultobj = Py_None;
26728 {
26729 if (temp2)
26730 delete arg2;
26731 }
26732 return resultobj;
26733 fail:
26734 {
26735 if (temp2)
26736 delete arg2;
26737 }
26738 return NULL;
26739 }
26740
26741
26742 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26743 PyObject *obj;
26744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26745 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26746 Py_INCREF(obj);
26747 return Py_BuildValue((char *)"");
26748 }
26749 static int _wrap_FormatInvalid_set(PyObject *) {
26750 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26751 return 1;
26752 }
26753
26754
26755 static PyObject *_wrap_FormatInvalid_get(void) {
26756 PyObject *pyobj;
26757
26758 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26759 return pyobj;
26760 }
26761
26762
26763 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26764 PyObject *resultobj;
26765 wxDataObject *arg1 = (wxDataObject *) 0 ;
26766 PyObject * obj0 = 0 ;
26767 char *kwnames[] = {
26768 (char *) "self", NULL
26769 };
26770
26771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26773 if (SWIG_arg_fail(1)) SWIG_fail;
26774 {
26775 PyThreadState* __tstate = wxPyBeginAllowThreads();
26776 delete arg1;
26777
26778 wxPyEndAllowThreads(__tstate);
26779 if (PyErr_Occurred()) SWIG_fail;
26780 }
26781 Py_INCREF(Py_None); resultobj = Py_None;
26782 return resultobj;
26783 fail:
26784 return NULL;
26785 }
26786
26787
26788 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26789 PyObject *resultobj;
26790 wxDataObject *arg1 = (wxDataObject *) 0 ;
26791 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26792 SwigValueWrapper<wxDataFormat > result;
26793 PyObject * obj0 = 0 ;
26794 PyObject * obj1 = 0 ;
26795 char *kwnames[] = {
26796 (char *) "self",(char *) "dir", NULL
26797 };
26798
26799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26801 if (SWIG_arg_fail(1)) SWIG_fail;
26802 if (obj1) {
26803 {
26804 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26805 if (SWIG_arg_fail(2)) SWIG_fail;
26806 }
26807 }
26808 {
26809 PyThreadState* __tstate = wxPyBeginAllowThreads();
26810 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26811
26812 wxPyEndAllowThreads(__tstate);
26813 if (PyErr_Occurred()) SWIG_fail;
26814 }
26815 {
26816 wxDataFormat * resultptr;
26817 resultptr = new wxDataFormat((wxDataFormat &)(result));
26818 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26819 }
26820 return resultobj;
26821 fail:
26822 return NULL;
26823 }
26824
26825
26826 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26827 PyObject *resultobj;
26828 wxDataObject *arg1 = (wxDataObject *) 0 ;
26829 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26830 size_t result;
26831 PyObject * obj0 = 0 ;
26832 PyObject * obj1 = 0 ;
26833 char *kwnames[] = {
26834 (char *) "self",(char *) "dir", NULL
26835 };
26836
26837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26839 if (SWIG_arg_fail(1)) SWIG_fail;
26840 if (obj1) {
26841 {
26842 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26843 if (SWIG_arg_fail(2)) SWIG_fail;
26844 }
26845 }
26846 {
26847 PyThreadState* __tstate = wxPyBeginAllowThreads();
26848 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26849
26850 wxPyEndAllowThreads(__tstate);
26851 if (PyErr_Occurred()) SWIG_fail;
26852 }
26853 {
26854 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26855 }
26856 return resultobj;
26857 fail:
26858 return NULL;
26859 }
26860
26861
26862 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26863 PyObject *resultobj;
26864 wxDataObject *arg1 = (wxDataObject *) 0 ;
26865 wxDataFormat *arg2 = 0 ;
26866 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26867 bool result;
26868 PyObject * obj0 = 0 ;
26869 PyObject * obj1 = 0 ;
26870 PyObject * obj2 = 0 ;
26871 char *kwnames[] = {
26872 (char *) "self",(char *) "format",(char *) "dir", NULL
26873 };
26874
26875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26877 if (SWIG_arg_fail(1)) SWIG_fail;
26878 {
26879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26880 if (SWIG_arg_fail(2)) SWIG_fail;
26881 if (arg2 == NULL) {
26882 SWIG_null_ref("wxDataFormat");
26883 }
26884 if (SWIG_arg_fail(2)) SWIG_fail;
26885 }
26886 if (obj2) {
26887 {
26888 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26889 if (SWIG_arg_fail(3)) SWIG_fail;
26890 }
26891 }
26892 {
26893 PyThreadState* __tstate = wxPyBeginAllowThreads();
26894 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26895
26896 wxPyEndAllowThreads(__tstate);
26897 if (PyErr_Occurred()) SWIG_fail;
26898 }
26899 {
26900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26901 }
26902 return resultobj;
26903 fail:
26904 return NULL;
26905 }
26906
26907
26908 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26909 PyObject *resultobj;
26910 wxDataObject *arg1 = (wxDataObject *) 0 ;
26911 wxDataFormat *arg2 = 0 ;
26912 size_t result;
26913 PyObject * obj0 = 0 ;
26914 PyObject * obj1 = 0 ;
26915 char *kwnames[] = {
26916 (char *) "self",(char *) "format", NULL
26917 };
26918
26919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26921 if (SWIG_arg_fail(1)) SWIG_fail;
26922 {
26923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26924 if (SWIG_arg_fail(2)) SWIG_fail;
26925 if (arg2 == NULL) {
26926 SWIG_null_ref("wxDataFormat");
26927 }
26928 if (SWIG_arg_fail(2)) SWIG_fail;
26929 }
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26933
26934 wxPyEndAllowThreads(__tstate);
26935 if (PyErr_Occurred()) SWIG_fail;
26936 }
26937 {
26938 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26939 }
26940 return resultobj;
26941 fail:
26942 return NULL;
26943 }
26944
26945
26946 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26947 PyObject *resultobj;
26948 wxDataObject *arg1 = (wxDataObject *) 0 ;
26949 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26950 PyObject *result;
26951 PyObject * obj0 = 0 ;
26952 PyObject * obj1 = 0 ;
26953 char *kwnames[] = {
26954 (char *) "self",(char *) "dir", NULL
26955 };
26956
26957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26959 if (SWIG_arg_fail(1)) SWIG_fail;
26960 if (obj1) {
26961 {
26962 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26963 if (SWIG_arg_fail(2)) SWIG_fail;
26964 }
26965 }
26966 {
26967 PyThreadState* __tstate = wxPyBeginAllowThreads();
26968 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26969
26970 wxPyEndAllowThreads(__tstate);
26971 if (PyErr_Occurred()) SWIG_fail;
26972 }
26973 resultobj = result;
26974 return resultobj;
26975 fail:
26976 return NULL;
26977 }
26978
26979
26980 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26981 PyObject *resultobj;
26982 wxDataObject *arg1 = (wxDataObject *) 0 ;
26983 wxDataFormat *arg2 = 0 ;
26984 PyObject *result;
26985 PyObject * obj0 = 0 ;
26986 PyObject * obj1 = 0 ;
26987 char *kwnames[] = {
26988 (char *) "self",(char *) "format", NULL
26989 };
26990
26991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
26992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26993 if (SWIG_arg_fail(1)) SWIG_fail;
26994 {
26995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26996 if (SWIG_arg_fail(2)) SWIG_fail;
26997 if (arg2 == NULL) {
26998 SWIG_null_ref("wxDataFormat");
26999 }
27000 if (SWIG_arg_fail(2)) SWIG_fail;
27001 }
27002 {
27003 PyThreadState* __tstate = wxPyBeginAllowThreads();
27004 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27005
27006 wxPyEndAllowThreads(__tstate);
27007 if (PyErr_Occurred()) SWIG_fail;
27008 }
27009 resultobj = result;
27010 return resultobj;
27011 fail:
27012 return NULL;
27013 }
27014
27015
27016 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27017 PyObject *resultobj;
27018 wxDataObject *arg1 = (wxDataObject *) 0 ;
27019 wxDataFormat *arg2 = 0 ;
27020 PyObject *arg3 = (PyObject *) 0 ;
27021 bool result;
27022 PyObject * obj0 = 0 ;
27023 PyObject * obj1 = 0 ;
27024 PyObject * obj2 = 0 ;
27025 char *kwnames[] = {
27026 (char *) "self",(char *) "format",(char *) "data", NULL
27027 };
27028
27029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27031 if (SWIG_arg_fail(1)) SWIG_fail;
27032 {
27033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27034 if (SWIG_arg_fail(2)) SWIG_fail;
27035 if (arg2 == NULL) {
27036 SWIG_null_ref("wxDataFormat");
27037 }
27038 if (SWIG_arg_fail(2)) SWIG_fail;
27039 }
27040 arg3 = obj2;
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27044
27045 wxPyEndAllowThreads(__tstate);
27046 if (PyErr_Occurred()) SWIG_fail;
27047 }
27048 {
27049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27050 }
27051 return resultobj;
27052 fail:
27053 return NULL;
27054 }
27055
27056
27057 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27058 PyObject *obj;
27059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27060 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27061 Py_INCREF(obj);
27062 return Py_BuildValue((char *)"");
27063 }
27064 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27065 PyObject *resultobj;
27066 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27067 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27068 wxDataObjectSimple *result;
27069 PyObject * obj0 = 0 ;
27070 char *kwnames[] = {
27071 (char *) "format", NULL
27072 };
27073
27074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27075 if (obj0) {
27076 {
27077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27078 if (SWIG_arg_fail(1)) SWIG_fail;
27079 if (arg1 == NULL) {
27080 SWIG_null_ref("wxDataFormat");
27081 }
27082 if (SWIG_arg_fail(1)) SWIG_fail;
27083 }
27084 }
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27088
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27093 return resultobj;
27094 fail:
27095 return NULL;
27096 }
27097
27098
27099 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27100 PyObject *resultobj;
27101 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27102 wxDataFormat *result;
27103 PyObject * obj0 = 0 ;
27104 char *kwnames[] = {
27105 (char *) "self", NULL
27106 };
27107
27108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27110 if (SWIG_arg_fail(1)) SWIG_fail;
27111 {
27112 PyThreadState* __tstate = wxPyBeginAllowThreads();
27113 {
27114 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27115 result = (wxDataFormat *) &_result_ref;
27116 }
27117
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27122 return resultobj;
27123 fail:
27124 return NULL;
27125 }
27126
27127
27128 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27129 PyObject *resultobj;
27130 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27131 wxDataFormat *arg2 = 0 ;
27132 PyObject * obj0 = 0 ;
27133 PyObject * obj1 = 0 ;
27134 char *kwnames[] = {
27135 (char *) "self",(char *) "format", NULL
27136 };
27137
27138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27140 if (SWIG_arg_fail(1)) SWIG_fail;
27141 {
27142 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27143 if (SWIG_arg_fail(2)) SWIG_fail;
27144 if (arg2 == NULL) {
27145 SWIG_null_ref("wxDataFormat");
27146 }
27147 if (SWIG_arg_fail(2)) SWIG_fail;
27148 }
27149 {
27150 PyThreadState* __tstate = wxPyBeginAllowThreads();
27151 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27152
27153 wxPyEndAllowThreads(__tstate);
27154 if (PyErr_Occurred()) SWIG_fail;
27155 }
27156 Py_INCREF(Py_None); resultobj = Py_None;
27157 return resultobj;
27158 fail:
27159 return NULL;
27160 }
27161
27162
27163 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27164 PyObject *resultobj;
27165 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27166 size_t result;
27167 PyObject * obj0 = 0 ;
27168 char *kwnames[] = {
27169 (char *) "self", NULL
27170 };
27171
27172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27174 if (SWIG_arg_fail(1)) SWIG_fail;
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27178
27179 wxPyEndAllowThreads(__tstate);
27180 if (PyErr_Occurred()) SWIG_fail;
27181 }
27182 {
27183 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27184 }
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27192 PyObject *resultobj;
27193 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27194 PyObject *result;
27195 PyObject * obj0 = 0 ;
27196 char *kwnames[] = {
27197 (char *) "self", NULL
27198 };
27199
27200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27202 if (SWIG_arg_fail(1)) SWIG_fail;
27203 {
27204 PyThreadState* __tstate = wxPyBeginAllowThreads();
27205 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27206
27207 wxPyEndAllowThreads(__tstate);
27208 if (PyErr_Occurred()) SWIG_fail;
27209 }
27210 resultobj = result;
27211 return resultobj;
27212 fail:
27213 return NULL;
27214 }
27215
27216
27217 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27218 PyObject *resultobj;
27219 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27220 PyObject *arg2 = (PyObject *) 0 ;
27221 bool result;
27222 PyObject * obj0 = 0 ;
27223 PyObject * obj1 = 0 ;
27224 char *kwnames[] = {
27225 (char *) "self",(char *) "data", NULL
27226 };
27227
27228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27230 if (SWIG_arg_fail(1)) SWIG_fail;
27231 arg2 = obj1;
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27235
27236 wxPyEndAllowThreads(__tstate);
27237 if (PyErr_Occurred()) SWIG_fail;
27238 }
27239 {
27240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27241 }
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27249 PyObject *obj;
27250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27251 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27252 Py_INCREF(obj);
27253 return Py_BuildValue((char *)"");
27254 }
27255 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27256 PyObject *resultobj;
27257 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27258 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27259 wxPyDataObjectSimple *result;
27260 PyObject * obj0 = 0 ;
27261 char *kwnames[] = {
27262 (char *) "format", NULL
27263 };
27264
27265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27266 if (obj0) {
27267 {
27268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27269 if (SWIG_arg_fail(1)) SWIG_fail;
27270 if (arg1 == NULL) {
27271 SWIG_null_ref("wxDataFormat");
27272 }
27273 if (SWIG_arg_fail(1)) SWIG_fail;
27274 }
27275 }
27276 {
27277 PyThreadState* __tstate = wxPyBeginAllowThreads();
27278 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27279
27280 wxPyEndAllowThreads(__tstate);
27281 if (PyErr_Occurred()) SWIG_fail;
27282 }
27283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27291 PyObject *resultobj;
27292 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27293 PyObject *arg2 = (PyObject *) 0 ;
27294 PyObject *arg3 = (PyObject *) 0 ;
27295 PyObject * obj0 = 0 ;
27296 PyObject * obj1 = 0 ;
27297 PyObject * obj2 = 0 ;
27298 char *kwnames[] = {
27299 (char *) "self",(char *) "self",(char *) "_class", NULL
27300 };
27301
27302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27304 if (SWIG_arg_fail(1)) SWIG_fail;
27305 arg2 = obj1;
27306 arg3 = obj2;
27307 {
27308 PyThreadState* __tstate = wxPyBeginAllowThreads();
27309 (arg1)->_setCallbackInfo(arg2,arg3);
27310
27311 wxPyEndAllowThreads(__tstate);
27312 if (PyErr_Occurred()) SWIG_fail;
27313 }
27314 Py_INCREF(Py_None); resultobj = Py_None;
27315 return resultobj;
27316 fail:
27317 return NULL;
27318 }
27319
27320
27321 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27322 PyObject *obj;
27323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27324 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27325 Py_INCREF(obj);
27326 return Py_BuildValue((char *)"");
27327 }
27328 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27329 PyObject *resultobj;
27330 wxDataObjectComposite *result;
27331 char *kwnames[] = {
27332 NULL
27333 };
27334
27335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27339
27340 wxPyEndAllowThreads(__tstate);
27341 if (PyErr_Occurred()) SWIG_fail;
27342 }
27343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27351 PyObject *resultobj;
27352 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27353 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27354 bool arg3 = (bool) false ;
27355 PyObject * obj0 = 0 ;
27356 PyObject * obj1 = 0 ;
27357 PyObject * obj2 = 0 ;
27358 char *kwnames[] = {
27359 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27360 };
27361
27362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27364 if (SWIG_arg_fail(1)) SWIG_fail;
27365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27366 if (SWIG_arg_fail(2)) SWIG_fail;
27367 if (obj2) {
27368 {
27369 arg3 = (bool)(SWIG_As_bool(obj2));
27370 if (SWIG_arg_fail(3)) SWIG_fail;
27371 }
27372 }
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 (arg1)->Add(arg2,arg3);
27376
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 Py_INCREF(Py_None); resultobj = Py_None;
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27388 PyObject *obj;
27389 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27390 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27391 Py_INCREF(obj);
27392 return Py_BuildValue((char *)"");
27393 }
27394 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27395 PyObject *resultobj;
27396 wxString const &arg1_defvalue = wxPyEmptyString ;
27397 wxString *arg1 = (wxString *) &arg1_defvalue ;
27398 wxTextDataObject *result;
27399 bool temp1 = false ;
27400 PyObject * obj0 = 0 ;
27401 char *kwnames[] = {
27402 (char *) "text", NULL
27403 };
27404
27405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27406 if (obj0) {
27407 {
27408 arg1 = wxString_in_helper(obj0);
27409 if (arg1 == NULL) SWIG_fail;
27410 temp1 = true;
27411 }
27412 }
27413 {
27414 PyThreadState* __tstate = wxPyBeginAllowThreads();
27415 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27416
27417 wxPyEndAllowThreads(__tstate);
27418 if (PyErr_Occurred()) SWIG_fail;
27419 }
27420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27421 {
27422 if (temp1)
27423 delete arg1;
27424 }
27425 return resultobj;
27426 fail:
27427 {
27428 if (temp1)
27429 delete arg1;
27430 }
27431 return NULL;
27432 }
27433
27434
27435 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27436 PyObject *resultobj;
27437 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27438 size_t result;
27439 PyObject * obj0 = 0 ;
27440 char *kwnames[] = {
27441 (char *) "self", NULL
27442 };
27443
27444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27446 if (SWIG_arg_fail(1)) SWIG_fail;
27447 {
27448 PyThreadState* __tstate = wxPyBeginAllowThreads();
27449 result = (size_t)(arg1)->GetTextLength();
27450
27451 wxPyEndAllowThreads(__tstate);
27452 if (PyErr_Occurred()) SWIG_fail;
27453 }
27454 {
27455 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27456 }
27457 return resultobj;
27458 fail:
27459 return NULL;
27460 }
27461
27462
27463 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27464 PyObject *resultobj;
27465 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27466 wxString result;
27467 PyObject * obj0 = 0 ;
27468 char *kwnames[] = {
27469 (char *) "self", NULL
27470 };
27471
27472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27474 if (SWIG_arg_fail(1)) SWIG_fail;
27475 {
27476 PyThreadState* __tstate = wxPyBeginAllowThreads();
27477 result = (arg1)->GetText();
27478
27479 wxPyEndAllowThreads(__tstate);
27480 if (PyErr_Occurred()) SWIG_fail;
27481 }
27482 {
27483 #if wxUSE_UNICODE
27484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27485 #else
27486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27487 #endif
27488 }
27489 return resultobj;
27490 fail:
27491 return NULL;
27492 }
27493
27494
27495 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27496 PyObject *resultobj;
27497 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27498 wxString *arg2 = 0 ;
27499 bool temp2 = false ;
27500 PyObject * obj0 = 0 ;
27501 PyObject * obj1 = 0 ;
27502 char *kwnames[] = {
27503 (char *) "self",(char *) "text", NULL
27504 };
27505
27506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27508 if (SWIG_arg_fail(1)) SWIG_fail;
27509 {
27510 arg2 = wxString_in_helper(obj1);
27511 if (arg2 == NULL) SWIG_fail;
27512 temp2 = true;
27513 }
27514 {
27515 PyThreadState* __tstate = wxPyBeginAllowThreads();
27516 (arg1)->SetText((wxString const &)*arg2);
27517
27518 wxPyEndAllowThreads(__tstate);
27519 if (PyErr_Occurred()) SWIG_fail;
27520 }
27521 Py_INCREF(Py_None); resultobj = Py_None;
27522 {
27523 if (temp2)
27524 delete arg2;
27525 }
27526 return resultobj;
27527 fail:
27528 {
27529 if (temp2)
27530 delete arg2;
27531 }
27532 return NULL;
27533 }
27534
27535
27536 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27537 PyObject *obj;
27538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27539 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27540 Py_INCREF(obj);
27541 return Py_BuildValue((char *)"");
27542 }
27543 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27544 PyObject *resultobj;
27545 wxString const &arg1_defvalue = wxPyEmptyString ;
27546 wxString *arg1 = (wxString *) &arg1_defvalue ;
27547 wxPyTextDataObject *result;
27548 bool temp1 = false ;
27549 PyObject * obj0 = 0 ;
27550 char *kwnames[] = {
27551 (char *) "text", NULL
27552 };
27553
27554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27555 if (obj0) {
27556 {
27557 arg1 = wxString_in_helper(obj0);
27558 if (arg1 == NULL) SWIG_fail;
27559 temp1 = true;
27560 }
27561 }
27562 {
27563 PyThreadState* __tstate = wxPyBeginAllowThreads();
27564 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27565
27566 wxPyEndAllowThreads(__tstate);
27567 if (PyErr_Occurred()) SWIG_fail;
27568 }
27569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27570 {
27571 if (temp1)
27572 delete arg1;
27573 }
27574 return resultobj;
27575 fail:
27576 {
27577 if (temp1)
27578 delete arg1;
27579 }
27580 return NULL;
27581 }
27582
27583
27584 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27585 PyObject *resultobj;
27586 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27587 PyObject *arg2 = (PyObject *) 0 ;
27588 PyObject *arg3 = (PyObject *) 0 ;
27589 PyObject * obj0 = 0 ;
27590 PyObject * obj1 = 0 ;
27591 PyObject * obj2 = 0 ;
27592 char *kwnames[] = {
27593 (char *) "self",(char *) "self",(char *) "_class", NULL
27594 };
27595
27596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27598 if (SWIG_arg_fail(1)) SWIG_fail;
27599 arg2 = obj1;
27600 arg3 = obj2;
27601 {
27602 PyThreadState* __tstate = wxPyBeginAllowThreads();
27603 (arg1)->_setCallbackInfo(arg2,arg3);
27604
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 Py_INCREF(Py_None); resultobj = Py_None;
27609 return resultobj;
27610 fail:
27611 return NULL;
27612 }
27613
27614
27615 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27616 PyObject *obj;
27617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27618 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27619 Py_INCREF(obj);
27620 return Py_BuildValue((char *)"");
27621 }
27622 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27623 PyObject *resultobj;
27624 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27625 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27626 wxBitmapDataObject *result;
27627 PyObject * obj0 = 0 ;
27628 char *kwnames[] = {
27629 (char *) "bitmap", NULL
27630 };
27631
27632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27633 if (obj0) {
27634 {
27635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27636 if (SWIG_arg_fail(1)) SWIG_fail;
27637 if (arg1 == NULL) {
27638 SWIG_null_ref("wxBitmap");
27639 }
27640 if (SWIG_arg_fail(1)) SWIG_fail;
27641 }
27642 }
27643 {
27644 PyThreadState* __tstate = wxPyBeginAllowThreads();
27645 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27646
27647 wxPyEndAllowThreads(__tstate);
27648 if (PyErr_Occurred()) SWIG_fail;
27649 }
27650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27651 return resultobj;
27652 fail:
27653 return NULL;
27654 }
27655
27656
27657 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27658 PyObject *resultobj;
27659 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27660 wxBitmap result;
27661 PyObject * obj0 = 0 ;
27662 char *kwnames[] = {
27663 (char *) "self", NULL
27664 };
27665
27666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27668 if (SWIG_arg_fail(1)) SWIG_fail;
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27672
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 {
27677 wxBitmap * resultptr;
27678 resultptr = new wxBitmap((wxBitmap &)(result));
27679 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27680 }
27681 return resultobj;
27682 fail:
27683 return NULL;
27684 }
27685
27686
27687 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27688 PyObject *resultobj;
27689 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27690 wxBitmap *arg2 = 0 ;
27691 PyObject * obj0 = 0 ;
27692 PyObject * obj1 = 0 ;
27693 char *kwnames[] = {
27694 (char *) "self",(char *) "bitmap", NULL
27695 };
27696
27697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27699 if (SWIG_arg_fail(1)) SWIG_fail;
27700 {
27701 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27702 if (SWIG_arg_fail(2)) SWIG_fail;
27703 if (arg2 == NULL) {
27704 SWIG_null_ref("wxBitmap");
27705 }
27706 if (SWIG_arg_fail(2)) SWIG_fail;
27707 }
27708 {
27709 PyThreadState* __tstate = wxPyBeginAllowThreads();
27710 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27711
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 Py_INCREF(Py_None); resultobj = Py_None;
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27723 PyObject *obj;
27724 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27725 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27726 Py_INCREF(obj);
27727 return Py_BuildValue((char *)"");
27728 }
27729 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27730 PyObject *resultobj;
27731 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27732 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27733 wxPyBitmapDataObject *result;
27734 PyObject * obj0 = 0 ;
27735 char *kwnames[] = {
27736 (char *) "bitmap", NULL
27737 };
27738
27739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27740 if (obj0) {
27741 {
27742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27743 if (SWIG_arg_fail(1)) SWIG_fail;
27744 if (arg1 == NULL) {
27745 SWIG_null_ref("wxBitmap");
27746 }
27747 if (SWIG_arg_fail(1)) SWIG_fail;
27748 }
27749 }
27750 {
27751 PyThreadState* __tstate = wxPyBeginAllowThreads();
27752 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27753
27754 wxPyEndAllowThreads(__tstate);
27755 if (PyErr_Occurred()) SWIG_fail;
27756 }
27757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27758 return resultobj;
27759 fail:
27760 return NULL;
27761 }
27762
27763
27764 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27765 PyObject *resultobj;
27766 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27767 PyObject *arg2 = (PyObject *) 0 ;
27768 PyObject *arg3 = (PyObject *) 0 ;
27769 PyObject * obj0 = 0 ;
27770 PyObject * obj1 = 0 ;
27771 PyObject * obj2 = 0 ;
27772 char *kwnames[] = {
27773 (char *) "self",(char *) "self",(char *) "_class", NULL
27774 };
27775
27776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27778 if (SWIG_arg_fail(1)) SWIG_fail;
27779 arg2 = obj1;
27780 arg3 = obj2;
27781 {
27782 PyThreadState* __tstate = wxPyBeginAllowThreads();
27783 (arg1)->_setCallbackInfo(arg2,arg3);
27784
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 Py_INCREF(Py_None); resultobj = Py_None;
27789 return resultobj;
27790 fail:
27791 return NULL;
27792 }
27793
27794
27795 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27796 PyObject *obj;
27797 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27798 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27799 Py_INCREF(obj);
27800 return Py_BuildValue((char *)"");
27801 }
27802 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27803 PyObject *resultobj;
27804 wxFileDataObject *result;
27805 char *kwnames[] = {
27806 NULL
27807 };
27808
27809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27810 {
27811 PyThreadState* __tstate = wxPyBeginAllowThreads();
27812 result = (wxFileDataObject *)new wxFileDataObject();
27813
27814 wxPyEndAllowThreads(__tstate);
27815 if (PyErr_Occurred()) SWIG_fail;
27816 }
27817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27818 return resultobj;
27819 fail:
27820 return NULL;
27821 }
27822
27823
27824 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27825 PyObject *resultobj;
27826 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27827 wxArrayString *result;
27828 PyObject * obj0 = 0 ;
27829 char *kwnames[] = {
27830 (char *) "self", NULL
27831 };
27832
27833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27835 if (SWIG_arg_fail(1)) SWIG_fail;
27836 {
27837 PyThreadState* __tstate = wxPyBeginAllowThreads();
27838 {
27839 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27840 result = (wxArrayString *) &_result_ref;
27841 }
27842
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 {
27847 resultobj = wxArrayString2PyList_helper(*result);
27848 }
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27856 PyObject *resultobj;
27857 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27858 wxString *arg2 = 0 ;
27859 bool temp2 = false ;
27860 PyObject * obj0 = 0 ;
27861 PyObject * obj1 = 0 ;
27862 char *kwnames[] = {
27863 (char *) "self",(char *) "filename", NULL
27864 };
27865
27866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27868 if (SWIG_arg_fail(1)) SWIG_fail;
27869 {
27870 arg2 = wxString_in_helper(obj1);
27871 if (arg2 == NULL) SWIG_fail;
27872 temp2 = true;
27873 }
27874 {
27875 PyThreadState* __tstate = wxPyBeginAllowThreads();
27876 (arg1)->AddFile((wxString const &)*arg2);
27877
27878 wxPyEndAllowThreads(__tstate);
27879 if (PyErr_Occurred()) SWIG_fail;
27880 }
27881 Py_INCREF(Py_None); resultobj = Py_None;
27882 {
27883 if (temp2)
27884 delete arg2;
27885 }
27886 return resultobj;
27887 fail:
27888 {
27889 if (temp2)
27890 delete arg2;
27891 }
27892 return NULL;
27893 }
27894
27895
27896 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27897 PyObject *obj;
27898 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27899 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27900 Py_INCREF(obj);
27901 return Py_BuildValue((char *)"");
27902 }
27903 static PyObject *_wrap_new_CustomDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27904 PyObject *resultobj;
27905 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27906 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27907 wxCustomDataObject *result;
27908 PyObject * obj0 = 0 ;
27909 char *kwnames[] = {
27910 (char *) "format", NULL
27911 };
27912
27913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_CustomDataObject",kwnames,&obj0)) goto fail;
27914 if (obj0) {
27915 {
27916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27917 if (SWIG_arg_fail(1)) SWIG_fail;
27918 if (arg1 == NULL) {
27919 SWIG_null_ref("wxDataFormat");
27920 }
27921 if (SWIG_arg_fail(1)) SWIG_fail;
27922 }
27923 }
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27927
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27932 return resultobj;
27933 fail:
27934 return NULL;
27935 }
27936
27937
27938 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27939 PyObject *resultobj;
27940 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27941 PyObject *arg2 = (PyObject *) 0 ;
27942 bool result;
27943 PyObject * obj0 = 0 ;
27944 PyObject * obj1 = 0 ;
27945 char *kwnames[] = {
27946 (char *) "self",(char *) "data", NULL
27947 };
27948
27949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
27950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27951 if (SWIG_arg_fail(1)) SWIG_fail;
27952 arg2 = obj1;
27953 {
27954 PyThreadState* __tstate = wxPyBeginAllowThreads();
27955 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
27956
27957 wxPyEndAllowThreads(__tstate);
27958 if (PyErr_Occurred()) SWIG_fail;
27959 }
27960 {
27961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27962 }
27963 return resultobj;
27964 fail:
27965 return NULL;
27966 }
27967
27968
27969 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27970 PyObject *resultobj;
27971 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27972 size_t result;
27973 PyObject * obj0 = 0 ;
27974 char *kwnames[] = {
27975 (char *) "self", NULL
27976 };
27977
27978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
27979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27980 if (SWIG_arg_fail(1)) SWIG_fail;
27981 {
27982 PyThreadState* __tstate = wxPyBeginAllowThreads();
27983 result = (size_t)(arg1)->GetSize();
27984
27985 wxPyEndAllowThreads(__tstate);
27986 if (PyErr_Occurred()) SWIG_fail;
27987 }
27988 {
27989 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27990 }
27991 return resultobj;
27992 fail:
27993 return NULL;
27994 }
27995
27996
27997 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27998 PyObject *resultobj;
27999 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28000 PyObject *result;
28001 PyObject * obj0 = 0 ;
28002 char *kwnames[] = {
28003 (char *) "self", NULL
28004 };
28005
28006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28008 if (SWIG_arg_fail(1)) SWIG_fail;
28009 {
28010 PyThreadState* __tstate = wxPyBeginAllowThreads();
28011 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28012
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 resultobj = result;
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28024 PyObject *obj;
28025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28026 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28027 Py_INCREF(obj);
28028 return Py_BuildValue((char *)"");
28029 }
28030 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28031 PyObject *resultobj;
28032 wxURLDataObject *result;
28033 char *kwnames[] = {
28034 NULL
28035 };
28036
28037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28038 {
28039 PyThreadState* __tstate = wxPyBeginAllowThreads();
28040 result = (wxURLDataObject *)new wxURLDataObject();
28041
28042 wxPyEndAllowThreads(__tstate);
28043 if (PyErr_Occurred()) SWIG_fail;
28044 }
28045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28046 return resultobj;
28047 fail:
28048 return NULL;
28049 }
28050
28051
28052 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28053 PyObject *resultobj;
28054 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28055 wxString result;
28056 PyObject * obj0 = 0 ;
28057 char *kwnames[] = {
28058 (char *) "self", NULL
28059 };
28060
28061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28063 if (SWIG_arg_fail(1)) SWIG_fail;
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 result = (arg1)->GetURL();
28067
28068 wxPyEndAllowThreads(__tstate);
28069 if (PyErr_Occurred()) SWIG_fail;
28070 }
28071 {
28072 #if wxUSE_UNICODE
28073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28074 #else
28075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28076 #endif
28077 }
28078 return resultobj;
28079 fail:
28080 return NULL;
28081 }
28082
28083
28084 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28085 PyObject *resultobj;
28086 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28087 wxString *arg2 = 0 ;
28088 bool temp2 = false ;
28089 PyObject * obj0 = 0 ;
28090 PyObject * obj1 = 0 ;
28091 char *kwnames[] = {
28092 (char *) "self",(char *) "url", NULL
28093 };
28094
28095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28097 if (SWIG_arg_fail(1)) SWIG_fail;
28098 {
28099 arg2 = wxString_in_helper(obj1);
28100 if (arg2 == NULL) SWIG_fail;
28101 temp2 = true;
28102 }
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 (arg1)->SetURL((wxString const &)*arg2);
28106
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 Py_INCREF(Py_None); resultobj = Py_None;
28111 {
28112 if (temp2)
28113 delete arg2;
28114 }
28115 return resultobj;
28116 fail:
28117 {
28118 if (temp2)
28119 delete arg2;
28120 }
28121 return NULL;
28122 }
28123
28124
28125 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28126 PyObject *obj;
28127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28128 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28129 Py_INCREF(obj);
28130 return Py_BuildValue((char *)"");
28131 }
28132 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj;
28134 wxMetafileDataObject *result;
28135 char *kwnames[] = {
28136 NULL
28137 };
28138
28139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28143
28144 wxPyEndAllowThreads(__tstate);
28145 if (PyErr_Occurred()) SWIG_fail;
28146 }
28147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28148 return resultobj;
28149 fail:
28150 return NULL;
28151 }
28152
28153
28154 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28155 PyObject *resultobj;
28156 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28157 wxMetafile *arg2 = 0 ;
28158 PyObject * obj0 = 0 ;
28159 PyObject * obj1 = 0 ;
28160 char *kwnames[] = {
28161 (char *) "self",(char *) "metafile", NULL
28162 };
28163
28164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28166 if (SWIG_arg_fail(1)) SWIG_fail;
28167 {
28168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28169 if (SWIG_arg_fail(2)) SWIG_fail;
28170 if (arg2 == NULL) {
28171 SWIG_null_ref("wxMetafile");
28172 }
28173 if (SWIG_arg_fail(2)) SWIG_fail;
28174 }
28175 {
28176 PyThreadState* __tstate = wxPyBeginAllowThreads();
28177 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28178
28179 wxPyEndAllowThreads(__tstate);
28180 if (PyErr_Occurred()) SWIG_fail;
28181 }
28182 Py_INCREF(Py_None); resultobj = Py_None;
28183 return resultobj;
28184 fail:
28185 return NULL;
28186 }
28187
28188
28189 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28190 PyObject *resultobj;
28191 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28192 wxMetafile result;
28193 PyObject * obj0 = 0 ;
28194 char *kwnames[] = {
28195 (char *) "self", NULL
28196 };
28197
28198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28200 if (SWIG_arg_fail(1)) SWIG_fail;
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28204
28205 wxPyEndAllowThreads(__tstate);
28206 if (PyErr_Occurred()) SWIG_fail;
28207 }
28208 {
28209 wxMetafile * resultptr;
28210 resultptr = new wxMetafile((wxMetafile &)(result));
28211 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28212 }
28213 return resultobj;
28214 fail:
28215 return NULL;
28216 }
28217
28218
28219 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28220 PyObject *obj;
28221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28222 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28223 Py_INCREF(obj);
28224 return Py_BuildValue((char *)"");
28225 }
28226 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28227 PyObject *resultobj;
28228 wxDragResult arg1 ;
28229 bool result;
28230 PyObject * obj0 = 0 ;
28231 char *kwnames[] = {
28232 (char *) "res", NULL
28233 };
28234
28235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28236 {
28237 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28238 if (SWIG_arg_fail(1)) SWIG_fail;
28239 }
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28243
28244 wxPyEndAllowThreads(__tstate);
28245 if (PyErr_Occurred()) SWIG_fail;
28246 }
28247 {
28248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28249 }
28250 return resultobj;
28251 fail:
28252 return NULL;
28253 }
28254
28255
28256 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28257 PyObject *resultobj;
28258 wxWindow *arg1 = (wxWindow *) 0 ;
28259 wxCursor const &arg2_defvalue = wxNullCursor ;
28260 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28261 wxCursor const &arg3_defvalue = wxNullCursor ;
28262 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28263 wxCursor const &arg4_defvalue = wxNullCursor ;
28264 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28265 wxPyDropSource *result;
28266 PyObject * obj0 = 0 ;
28267 PyObject * obj1 = 0 ;
28268 PyObject * obj2 = 0 ;
28269 PyObject * obj3 = 0 ;
28270 char *kwnames[] = {
28271 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28272 };
28273
28274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28276 if (SWIG_arg_fail(1)) SWIG_fail;
28277 if (obj1) {
28278 {
28279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28280 if (SWIG_arg_fail(2)) SWIG_fail;
28281 if (arg2 == NULL) {
28282 SWIG_null_ref("wxCursor");
28283 }
28284 if (SWIG_arg_fail(2)) SWIG_fail;
28285 }
28286 }
28287 if (obj2) {
28288 {
28289 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28290 if (SWIG_arg_fail(3)) SWIG_fail;
28291 if (arg3 == NULL) {
28292 SWIG_null_ref("wxCursor");
28293 }
28294 if (SWIG_arg_fail(3)) SWIG_fail;
28295 }
28296 }
28297 if (obj3) {
28298 {
28299 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28300 if (SWIG_arg_fail(4)) SWIG_fail;
28301 if (arg4 == NULL) {
28302 SWIG_null_ref("wxCursor");
28303 }
28304 if (SWIG_arg_fail(4)) SWIG_fail;
28305 }
28306 }
28307 {
28308 PyThreadState* __tstate = wxPyBeginAllowThreads();
28309 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28310
28311 wxPyEndAllowThreads(__tstate);
28312 if (PyErr_Occurred()) SWIG_fail;
28313 }
28314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28315 return resultobj;
28316 fail:
28317 return NULL;
28318 }
28319
28320
28321 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28322 PyObject *resultobj;
28323 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28324 PyObject *arg2 = (PyObject *) 0 ;
28325 PyObject *arg3 = (PyObject *) 0 ;
28326 int arg4 ;
28327 PyObject * obj0 = 0 ;
28328 PyObject * obj1 = 0 ;
28329 PyObject * obj2 = 0 ;
28330 PyObject * obj3 = 0 ;
28331 char *kwnames[] = {
28332 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28333 };
28334
28335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = obj1;
28339 arg3 = obj2;
28340 {
28341 arg4 = (int)(SWIG_As_int(obj3));
28342 if (SWIG_arg_fail(4)) SWIG_fail;
28343 }
28344 {
28345 PyThreadState* __tstate = wxPyBeginAllowThreads();
28346 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28347
28348 wxPyEndAllowThreads(__tstate);
28349 if (PyErr_Occurred()) SWIG_fail;
28350 }
28351 Py_INCREF(Py_None); resultobj = Py_None;
28352 return resultobj;
28353 fail:
28354 return NULL;
28355 }
28356
28357
28358 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28359 PyObject *resultobj;
28360 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28361 PyObject * obj0 = 0 ;
28362 char *kwnames[] = {
28363 (char *) "self", NULL
28364 };
28365
28366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28368 if (SWIG_arg_fail(1)) SWIG_fail;
28369 {
28370 PyThreadState* __tstate = wxPyBeginAllowThreads();
28371 delete arg1;
28372
28373 wxPyEndAllowThreads(__tstate);
28374 if (PyErr_Occurred()) SWIG_fail;
28375 }
28376 Py_INCREF(Py_None); resultobj = Py_None;
28377 return resultobj;
28378 fail:
28379 return NULL;
28380 }
28381
28382
28383 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28384 PyObject *resultobj;
28385 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28386 wxDataObject *arg2 = 0 ;
28387 PyObject * obj0 = 0 ;
28388 PyObject * obj1 = 0 ;
28389 char *kwnames[] = {
28390 (char *) "self",(char *) "data", NULL
28391 };
28392
28393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28395 if (SWIG_arg_fail(1)) SWIG_fail;
28396 {
28397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28398 if (SWIG_arg_fail(2)) SWIG_fail;
28399 if (arg2 == NULL) {
28400 SWIG_null_ref("wxDataObject");
28401 }
28402 if (SWIG_arg_fail(2)) SWIG_fail;
28403 }
28404 {
28405 PyThreadState* __tstate = wxPyBeginAllowThreads();
28406 (arg1)->SetData(*arg2);
28407
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 Py_INCREF(Py_None); resultobj = Py_None;
28412 return resultobj;
28413 fail:
28414 return NULL;
28415 }
28416
28417
28418 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28419 PyObject *resultobj;
28420 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28421 wxDataObject *result;
28422 PyObject * obj0 = 0 ;
28423 char *kwnames[] = {
28424 (char *) "self", NULL
28425 };
28426
28427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28429 if (SWIG_arg_fail(1)) SWIG_fail;
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = (wxDataObject *)(arg1)->GetDataObject();
28433
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28438 return resultobj;
28439 fail:
28440 return NULL;
28441 }
28442
28443
28444 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28445 PyObject *resultobj;
28446 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28447 wxDragResult arg2 ;
28448 wxCursor *arg3 = 0 ;
28449 PyObject * obj0 = 0 ;
28450 PyObject * obj1 = 0 ;
28451 PyObject * obj2 = 0 ;
28452 char *kwnames[] = {
28453 (char *) "self",(char *) "res",(char *) "cursor", NULL
28454 };
28455
28456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28458 if (SWIG_arg_fail(1)) SWIG_fail;
28459 {
28460 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28461 if (SWIG_arg_fail(2)) SWIG_fail;
28462 }
28463 {
28464 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28465 if (SWIG_arg_fail(3)) SWIG_fail;
28466 if (arg3 == NULL) {
28467 SWIG_null_ref("wxCursor");
28468 }
28469 if (SWIG_arg_fail(3)) SWIG_fail;
28470 }
28471 {
28472 PyThreadState* __tstate = wxPyBeginAllowThreads();
28473 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28474
28475 wxPyEndAllowThreads(__tstate);
28476 if (PyErr_Occurred()) SWIG_fail;
28477 }
28478 Py_INCREF(Py_None); resultobj = Py_None;
28479 return resultobj;
28480 fail:
28481 return NULL;
28482 }
28483
28484
28485 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28486 PyObject *resultobj;
28487 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28488 int arg2 = (int) wxDrag_CopyOnly ;
28489 wxDragResult result;
28490 PyObject * obj0 = 0 ;
28491 PyObject * obj1 = 0 ;
28492 char *kwnames[] = {
28493 (char *) "self",(char *) "flags", NULL
28494 };
28495
28496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28498 if (SWIG_arg_fail(1)) SWIG_fail;
28499 if (obj1) {
28500 {
28501 arg2 = (int)(SWIG_As_int(obj1));
28502 if (SWIG_arg_fail(2)) SWIG_fail;
28503 }
28504 }
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28508
28509 wxPyEndAllowThreads(__tstate);
28510 if (PyErr_Occurred()) SWIG_fail;
28511 }
28512 resultobj = SWIG_From_int((result));
28513 return resultobj;
28514 fail:
28515 return NULL;
28516 }
28517
28518
28519 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28520 PyObject *resultobj;
28521 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28522 wxDragResult arg2 ;
28523 bool result;
28524 PyObject * obj0 = 0 ;
28525 PyObject * obj1 = 0 ;
28526 char *kwnames[] = {
28527 (char *) "self",(char *) "effect", NULL
28528 };
28529
28530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28532 if (SWIG_arg_fail(1)) SWIG_fail;
28533 {
28534 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28535 if (SWIG_arg_fail(2)) SWIG_fail;
28536 }
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28540
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 {
28545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28546 }
28547 return resultobj;
28548 fail:
28549 return NULL;
28550 }
28551
28552
28553 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28554 PyObject *obj;
28555 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28556 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28557 Py_INCREF(obj);
28558 return Py_BuildValue((char *)"");
28559 }
28560 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28561 PyObject *resultobj;
28562 wxDataObject *arg1 = (wxDataObject *) NULL ;
28563 wxPyDropTarget *result;
28564 PyObject * obj0 = 0 ;
28565 char *kwnames[] = {
28566 (char *) "dataObject", NULL
28567 };
28568
28569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28570 if (obj0) {
28571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28572 if (SWIG_arg_fail(1)) SWIG_fail;
28573 }
28574 {
28575 PyThreadState* __tstate = wxPyBeginAllowThreads();
28576 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28577
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28589 PyObject *resultobj;
28590 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28591 PyObject *arg2 = (PyObject *) 0 ;
28592 PyObject *arg3 = (PyObject *) 0 ;
28593 PyObject * obj0 = 0 ;
28594 PyObject * obj1 = 0 ;
28595 PyObject * obj2 = 0 ;
28596 char *kwnames[] = {
28597 (char *) "self",(char *) "self",(char *) "_class", NULL
28598 };
28599
28600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28602 if (SWIG_arg_fail(1)) SWIG_fail;
28603 arg2 = obj1;
28604 arg3 = obj2;
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 (arg1)->_setCallbackInfo(arg2,arg3);
28608
28609 wxPyEndAllowThreads(__tstate);
28610 if (PyErr_Occurred()) SWIG_fail;
28611 }
28612 Py_INCREF(Py_None); resultobj = Py_None;
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28620 PyObject *resultobj;
28621 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28622 PyObject * obj0 = 0 ;
28623 char *kwnames[] = {
28624 (char *) "self", NULL
28625 };
28626
28627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28629 if (SWIG_arg_fail(1)) SWIG_fail;
28630 {
28631 PyThreadState* __tstate = wxPyBeginAllowThreads();
28632 delete arg1;
28633
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 Py_INCREF(Py_None); resultobj = Py_None;
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28645 PyObject *resultobj;
28646 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28647 wxDataObject *result;
28648 PyObject * obj0 = 0 ;
28649 char *kwnames[] = {
28650 (char *) "self", NULL
28651 };
28652
28653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28655 if (SWIG_arg_fail(1)) SWIG_fail;
28656 {
28657 PyThreadState* __tstate = wxPyBeginAllowThreads();
28658 result = (wxDataObject *)(arg1)->GetDataObject();
28659
28660 wxPyEndAllowThreads(__tstate);
28661 if (PyErr_Occurred()) SWIG_fail;
28662 }
28663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28664 return resultobj;
28665 fail:
28666 return NULL;
28667 }
28668
28669
28670 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28671 PyObject *resultobj;
28672 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28673 wxDataObject *arg2 = (wxDataObject *) 0 ;
28674 PyObject * obj0 = 0 ;
28675 PyObject * obj1 = 0 ;
28676 char *kwnames[] = {
28677 (char *) "self",(char *) "dataObject", NULL
28678 };
28679
28680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28682 if (SWIG_arg_fail(1)) SWIG_fail;
28683 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28684 if (SWIG_arg_fail(2)) SWIG_fail;
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 (arg1)->SetDataObject(arg2);
28688
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 Py_INCREF(Py_None); resultobj = Py_None;
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28700 PyObject *resultobj;
28701 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28702 int arg2 ;
28703 int arg3 ;
28704 wxDragResult arg4 ;
28705 wxDragResult result;
28706 PyObject * obj0 = 0 ;
28707 PyObject * obj1 = 0 ;
28708 PyObject * obj2 = 0 ;
28709 PyObject * obj3 = 0 ;
28710 char *kwnames[] = {
28711 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28712 };
28713
28714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28716 if (SWIG_arg_fail(1)) SWIG_fail;
28717 {
28718 arg2 = (int)(SWIG_As_int(obj1));
28719 if (SWIG_arg_fail(2)) SWIG_fail;
28720 }
28721 {
28722 arg3 = (int)(SWIG_As_int(obj2));
28723 if (SWIG_arg_fail(3)) SWIG_fail;
28724 }
28725 {
28726 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28727 if (SWIG_arg_fail(4)) SWIG_fail;
28728 }
28729 {
28730 PyThreadState* __tstate = wxPyBeginAllowThreads();
28731 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28732
28733 wxPyEndAllowThreads(__tstate);
28734 if (PyErr_Occurred()) SWIG_fail;
28735 }
28736 resultobj = SWIG_From_int((result));
28737 return resultobj;
28738 fail:
28739 return NULL;
28740 }
28741
28742
28743 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28744 PyObject *resultobj;
28745 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28746 int arg2 ;
28747 int arg3 ;
28748 wxDragResult arg4 ;
28749 wxDragResult result;
28750 PyObject * obj0 = 0 ;
28751 PyObject * obj1 = 0 ;
28752 PyObject * obj2 = 0 ;
28753 PyObject * obj3 = 0 ;
28754 char *kwnames[] = {
28755 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28756 };
28757
28758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28760 if (SWIG_arg_fail(1)) SWIG_fail;
28761 {
28762 arg2 = (int)(SWIG_As_int(obj1));
28763 if (SWIG_arg_fail(2)) SWIG_fail;
28764 }
28765 {
28766 arg3 = (int)(SWIG_As_int(obj2));
28767 if (SWIG_arg_fail(3)) SWIG_fail;
28768 }
28769 {
28770 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28771 if (SWIG_arg_fail(4)) SWIG_fail;
28772 }
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28776
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 resultobj = SWIG_From_int((result));
28781 return resultobj;
28782 fail:
28783 return NULL;
28784 }
28785
28786
28787 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28788 PyObject *resultobj;
28789 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28790 PyObject * obj0 = 0 ;
28791 char *kwnames[] = {
28792 (char *) "self", NULL
28793 };
28794
28795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28797 if (SWIG_arg_fail(1)) SWIG_fail;
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 (arg1)->base_OnLeave();
28801
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 Py_INCREF(Py_None); resultobj = Py_None;
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28813 PyObject *resultobj;
28814 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28815 int arg2 ;
28816 int arg3 ;
28817 bool result;
28818 PyObject * obj0 = 0 ;
28819 PyObject * obj1 = 0 ;
28820 PyObject * obj2 = 0 ;
28821 char *kwnames[] = {
28822 (char *) "self",(char *) "x",(char *) "y", NULL
28823 };
28824
28825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28827 if (SWIG_arg_fail(1)) SWIG_fail;
28828 {
28829 arg2 = (int)(SWIG_As_int(obj1));
28830 if (SWIG_arg_fail(2)) SWIG_fail;
28831 }
28832 {
28833 arg3 = (int)(SWIG_As_int(obj2));
28834 if (SWIG_arg_fail(3)) SWIG_fail;
28835 }
28836 {
28837 PyThreadState* __tstate = wxPyBeginAllowThreads();
28838 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28839
28840 wxPyEndAllowThreads(__tstate);
28841 if (PyErr_Occurred()) SWIG_fail;
28842 }
28843 {
28844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28845 }
28846 return resultobj;
28847 fail:
28848 return NULL;
28849 }
28850
28851
28852 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28853 PyObject *resultobj;
28854 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28855 bool result;
28856 PyObject * obj0 = 0 ;
28857 char *kwnames[] = {
28858 (char *) "self", NULL
28859 };
28860
28861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28863 if (SWIG_arg_fail(1)) SWIG_fail;
28864 {
28865 PyThreadState* __tstate = wxPyBeginAllowThreads();
28866 result = (bool)(arg1)->GetData();
28867
28868 wxPyEndAllowThreads(__tstate);
28869 if (PyErr_Occurred()) SWIG_fail;
28870 }
28871 {
28872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28873 }
28874 return resultobj;
28875 fail:
28876 return NULL;
28877 }
28878
28879
28880 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28881 PyObject *obj;
28882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28883 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28884 Py_INCREF(obj);
28885 return Py_BuildValue((char *)"");
28886 }
28887 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28888 PyObject *resultobj;
28889 wxPyTextDropTarget *result;
28890 char *kwnames[] = {
28891 NULL
28892 };
28893
28894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28895 {
28896 PyThreadState* __tstate = wxPyBeginAllowThreads();
28897 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28898
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28910 PyObject *resultobj;
28911 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28912 PyObject *arg2 = (PyObject *) 0 ;
28913 PyObject *arg3 = (PyObject *) 0 ;
28914 PyObject * obj0 = 0 ;
28915 PyObject * obj1 = 0 ;
28916 PyObject * obj2 = 0 ;
28917 char *kwnames[] = {
28918 (char *) "self",(char *) "self",(char *) "_class", NULL
28919 };
28920
28921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28923 if (SWIG_arg_fail(1)) SWIG_fail;
28924 arg2 = obj1;
28925 arg3 = obj2;
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 (arg1)->_setCallbackInfo(arg2,arg3);
28929
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 Py_INCREF(Py_None); resultobj = Py_None;
28934 return resultobj;
28935 fail:
28936 return NULL;
28937 }
28938
28939
28940 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28941 PyObject *resultobj;
28942 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28943 int arg2 ;
28944 int arg3 ;
28945 wxDragResult arg4 ;
28946 wxDragResult result;
28947 PyObject * obj0 = 0 ;
28948 PyObject * obj1 = 0 ;
28949 PyObject * obj2 = 0 ;
28950 PyObject * obj3 = 0 ;
28951 char *kwnames[] = {
28952 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28953 };
28954
28955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28957 if (SWIG_arg_fail(1)) SWIG_fail;
28958 {
28959 arg2 = (int)(SWIG_As_int(obj1));
28960 if (SWIG_arg_fail(2)) SWIG_fail;
28961 }
28962 {
28963 arg3 = (int)(SWIG_As_int(obj2));
28964 if (SWIG_arg_fail(3)) SWIG_fail;
28965 }
28966 {
28967 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28968 if (SWIG_arg_fail(4)) SWIG_fail;
28969 }
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28973
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 resultobj = SWIG_From_int((result));
28978 return resultobj;
28979 fail:
28980 return NULL;
28981 }
28982
28983
28984 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28985 PyObject *resultobj;
28986 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28987 int arg2 ;
28988 int arg3 ;
28989 wxDragResult arg4 ;
28990 wxDragResult result;
28991 PyObject * obj0 = 0 ;
28992 PyObject * obj1 = 0 ;
28993 PyObject * obj2 = 0 ;
28994 PyObject * obj3 = 0 ;
28995 char *kwnames[] = {
28996 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28997 };
28998
28999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29001 if (SWIG_arg_fail(1)) SWIG_fail;
29002 {
29003 arg2 = (int)(SWIG_As_int(obj1));
29004 if (SWIG_arg_fail(2)) SWIG_fail;
29005 }
29006 {
29007 arg3 = (int)(SWIG_As_int(obj2));
29008 if (SWIG_arg_fail(3)) SWIG_fail;
29009 }
29010 {
29011 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29012 if (SWIG_arg_fail(4)) SWIG_fail;
29013 }
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29017
29018 wxPyEndAllowThreads(__tstate);
29019 if (PyErr_Occurred()) SWIG_fail;
29020 }
29021 resultobj = SWIG_From_int((result));
29022 return resultobj;
29023 fail:
29024 return NULL;
29025 }
29026
29027
29028 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29029 PyObject *resultobj;
29030 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29031 PyObject * obj0 = 0 ;
29032 char *kwnames[] = {
29033 (char *) "self", NULL
29034 };
29035
29036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29038 if (SWIG_arg_fail(1)) SWIG_fail;
29039 {
29040 PyThreadState* __tstate = wxPyBeginAllowThreads();
29041 (arg1)->base_OnLeave();
29042
29043 wxPyEndAllowThreads(__tstate);
29044 if (PyErr_Occurred()) SWIG_fail;
29045 }
29046 Py_INCREF(Py_None); resultobj = Py_None;
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29054 PyObject *resultobj;
29055 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29056 int arg2 ;
29057 int arg3 ;
29058 bool result;
29059 PyObject * obj0 = 0 ;
29060 PyObject * obj1 = 0 ;
29061 PyObject * obj2 = 0 ;
29062 char *kwnames[] = {
29063 (char *) "self",(char *) "x",(char *) "y", NULL
29064 };
29065
29066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29068 if (SWIG_arg_fail(1)) SWIG_fail;
29069 {
29070 arg2 = (int)(SWIG_As_int(obj1));
29071 if (SWIG_arg_fail(2)) SWIG_fail;
29072 }
29073 {
29074 arg3 = (int)(SWIG_As_int(obj2));
29075 if (SWIG_arg_fail(3)) SWIG_fail;
29076 }
29077 {
29078 PyThreadState* __tstate = wxPyBeginAllowThreads();
29079 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29080
29081 wxPyEndAllowThreads(__tstate);
29082 if (PyErr_Occurred()) SWIG_fail;
29083 }
29084 {
29085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29086 }
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29094 PyObject *resultobj;
29095 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29096 int arg2 ;
29097 int arg3 ;
29098 wxDragResult arg4 ;
29099 wxDragResult result;
29100 PyObject * obj0 = 0 ;
29101 PyObject * obj1 = 0 ;
29102 PyObject * obj2 = 0 ;
29103 PyObject * obj3 = 0 ;
29104 char *kwnames[] = {
29105 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29106 };
29107
29108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29110 if (SWIG_arg_fail(1)) SWIG_fail;
29111 {
29112 arg2 = (int)(SWIG_As_int(obj1));
29113 if (SWIG_arg_fail(2)) SWIG_fail;
29114 }
29115 {
29116 arg3 = (int)(SWIG_As_int(obj2));
29117 if (SWIG_arg_fail(3)) SWIG_fail;
29118 }
29119 {
29120 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29121 if (SWIG_arg_fail(4)) SWIG_fail;
29122 }
29123 {
29124 PyThreadState* __tstate = wxPyBeginAllowThreads();
29125 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29126
29127 wxPyEndAllowThreads(__tstate);
29128 if (PyErr_Occurred()) SWIG_fail;
29129 }
29130 resultobj = SWIG_From_int((result));
29131 return resultobj;
29132 fail:
29133 return NULL;
29134 }
29135
29136
29137 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29138 PyObject *obj;
29139 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29140 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29141 Py_INCREF(obj);
29142 return Py_BuildValue((char *)"");
29143 }
29144 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29145 PyObject *resultobj;
29146 wxPyFileDropTarget *result;
29147 char *kwnames[] = {
29148 NULL
29149 };
29150
29151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29152 {
29153 PyThreadState* __tstate = wxPyBeginAllowThreads();
29154 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29155
29156 wxPyEndAllowThreads(__tstate);
29157 if (PyErr_Occurred()) SWIG_fail;
29158 }
29159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29160 return resultobj;
29161 fail:
29162 return NULL;
29163 }
29164
29165
29166 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29167 PyObject *resultobj;
29168 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29169 PyObject *arg2 = (PyObject *) 0 ;
29170 PyObject *arg3 = (PyObject *) 0 ;
29171 PyObject * obj0 = 0 ;
29172 PyObject * obj1 = 0 ;
29173 PyObject * obj2 = 0 ;
29174 char *kwnames[] = {
29175 (char *) "self",(char *) "self",(char *) "_class", NULL
29176 };
29177
29178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29180 if (SWIG_arg_fail(1)) SWIG_fail;
29181 arg2 = obj1;
29182 arg3 = obj2;
29183 {
29184 PyThreadState* __tstate = wxPyBeginAllowThreads();
29185 (arg1)->_setCallbackInfo(arg2,arg3);
29186
29187 wxPyEndAllowThreads(__tstate);
29188 if (PyErr_Occurred()) SWIG_fail;
29189 }
29190 Py_INCREF(Py_None); resultobj = Py_None;
29191 return resultobj;
29192 fail:
29193 return NULL;
29194 }
29195
29196
29197 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29198 PyObject *resultobj;
29199 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29200 int arg2 ;
29201 int arg3 ;
29202 wxDragResult arg4 ;
29203 wxDragResult result;
29204 PyObject * obj0 = 0 ;
29205 PyObject * obj1 = 0 ;
29206 PyObject * obj2 = 0 ;
29207 PyObject * obj3 = 0 ;
29208 char *kwnames[] = {
29209 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29210 };
29211
29212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29214 if (SWIG_arg_fail(1)) SWIG_fail;
29215 {
29216 arg2 = (int)(SWIG_As_int(obj1));
29217 if (SWIG_arg_fail(2)) SWIG_fail;
29218 }
29219 {
29220 arg3 = (int)(SWIG_As_int(obj2));
29221 if (SWIG_arg_fail(3)) SWIG_fail;
29222 }
29223 {
29224 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29225 if (SWIG_arg_fail(4)) SWIG_fail;
29226 }
29227 {
29228 PyThreadState* __tstate = wxPyBeginAllowThreads();
29229 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29230
29231 wxPyEndAllowThreads(__tstate);
29232 if (PyErr_Occurred()) SWIG_fail;
29233 }
29234 resultobj = SWIG_From_int((result));
29235 return resultobj;
29236 fail:
29237 return NULL;
29238 }
29239
29240
29241 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29242 PyObject *resultobj;
29243 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29244 int arg2 ;
29245 int arg3 ;
29246 wxDragResult arg4 ;
29247 wxDragResult result;
29248 PyObject * obj0 = 0 ;
29249 PyObject * obj1 = 0 ;
29250 PyObject * obj2 = 0 ;
29251 PyObject * obj3 = 0 ;
29252 char *kwnames[] = {
29253 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29254 };
29255
29256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29258 if (SWIG_arg_fail(1)) SWIG_fail;
29259 {
29260 arg2 = (int)(SWIG_As_int(obj1));
29261 if (SWIG_arg_fail(2)) SWIG_fail;
29262 }
29263 {
29264 arg3 = (int)(SWIG_As_int(obj2));
29265 if (SWIG_arg_fail(3)) SWIG_fail;
29266 }
29267 {
29268 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29269 if (SWIG_arg_fail(4)) SWIG_fail;
29270 }
29271 {
29272 PyThreadState* __tstate = wxPyBeginAllowThreads();
29273 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29274
29275 wxPyEndAllowThreads(__tstate);
29276 if (PyErr_Occurred()) SWIG_fail;
29277 }
29278 resultobj = SWIG_From_int((result));
29279 return resultobj;
29280 fail:
29281 return NULL;
29282 }
29283
29284
29285 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29286 PyObject *resultobj;
29287 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29288 PyObject * obj0 = 0 ;
29289 char *kwnames[] = {
29290 (char *) "self", NULL
29291 };
29292
29293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29295 if (SWIG_arg_fail(1)) SWIG_fail;
29296 {
29297 PyThreadState* __tstate = wxPyBeginAllowThreads();
29298 (arg1)->base_OnLeave();
29299
29300 wxPyEndAllowThreads(__tstate);
29301 if (PyErr_Occurred()) SWIG_fail;
29302 }
29303 Py_INCREF(Py_None); resultobj = Py_None;
29304 return resultobj;
29305 fail:
29306 return NULL;
29307 }
29308
29309
29310 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29311 PyObject *resultobj;
29312 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29313 int arg2 ;
29314 int arg3 ;
29315 bool result;
29316 PyObject * obj0 = 0 ;
29317 PyObject * obj1 = 0 ;
29318 PyObject * obj2 = 0 ;
29319 char *kwnames[] = {
29320 (char *) "self",(char *) "x",(char *) "y", NULL
29321 };
29322
29323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29325 if (SWIG_arg_fail(1)) SWIG_fail;
29326 {
29327 arg2 = (int)(SWIG_As_int(obj1));
29328 if (SWIG_arg_fail(2)) SWIG_fail;
29329 }
29330 {
29331 arg3 = (int)(SWIG_As_int(obj2));
29332 if (SWIG_arg_fail(3)) SWIG_fail;
29333 }
29334 {
29335 PyThreadState* __tstate = wxPyBeginAllowThreads();
29336 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29337
29338 wxPyEndAllowThreads(__tstate);
29339 if (PyErr_Occurred()) SWIG_fail;
29340 }
29341 {
29342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29343 }
29344 return resultobj;
29345 fail:
29346 return NULL;
29347 }
29348
29349
29350 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29351 PyObject *resultobj;
29352 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29353 int arg2 ;
29354 int arg3 ;
29355 wxDragResult arg4 ;
29356 wxDragResult result;
29357 PyObject * obj0 = 0 ;
29358 PyObject * obj1 = 0 ;
29359 PyObject * obj2 = 0 ;
29360 PyObject * obj3 = 0 ;
29361 char *kwnames[] = {
29362 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29363 };
29364
29365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29367 if (SWIG_arg_fail(1)) SWIG_fail;
29368 {
29369 arg2 = (int)(SWIG_As_int(obj1));
29370 if (SWIG_arg_fail(2)) SWIG_fail;
29371 }
29372 {
29373 arg3 = (int)(SWIG_As_int(obj2));
29374 if (SWIG_arg_fail(3)) SWIG_fail;
29375 }
29376 {
29377 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29378 if (SWIG_arg_fail(4)) SWIG_fail;
29379 }
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29383
29384 wxPyEndAllowThreads(__tstate);
29385 if (PyErr_Occurred()) SWIG_fail;
29386 }
29387 resultobj = SWIG_From_int((result));
29388 return resultobj;
29389 fail:
29390 return NULL;
29391 }
29392
29393
29394 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29395 PyObject *obj;
29396 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29397 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29398 Py_INCREF(obj);
29399 return Py_BuildValue((char *)"");
29400 }
29401 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29402 PyObject *resultobj;
29403 wxClipboard *result;
29404 char *kwnames[] = {
29405 NULL
29406 };
29407
29408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29409 {
29410 PyThreadState* __tstate = wxPyBeginAllowThreads();
29411 result = (wxClipboard *)new wxClipboard();
29412
29413 wxPyEndAllowThreads(__tstate);
29414 if (PyErr_Occurred()) SWIG_fail;
29415 }
29416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29417 return resultobj;
29418 fail:
29419 return NULL;
29420 }
29421
29422
29423 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29424 PyObject *resultobj;
29425 wxClipboard *arg1 = (wxClipboard *) 0 ;
29426 PyObject * obj0 = 0 ;
29427 char *kwnames[] = {
29428 (char *) "self", NULL
29429 };
29430
29431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29433 if (SWIG_arg_fail(1)) SWIG_fail;
29434 {
29435 PyThreadState* __tstate = wxPyBeginAllowThreads();
29436 delete arg1;
29437
29438 wxPyEndAllowThreads(__tstate);
29439 if (PyErr_Occurred()) SWIG_fail;
29440 }
29441 Py_INCREF(Py_None); resultobj = Py_None;
29442 return resultobj;
29443 fail:
29444 return NULL;
29445 }
29446
29447
29448 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29449 PyObject *resultobj;
29450 wxClipboard *arg1 = (wxClipboard *) 0 ;
29451 bool result;
29452 PyObject * obj0 = 0 ;
29453 char *kwnames[] = {
29454 (char *) "self", NULL
29455 };
29456
29457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29459 if (SWIG_arg_fail(1)) SWIG_fail;
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 result = (bool)(arg1)->Open();
29463
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 {
29468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29469 }
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj;
29478 wxClipboard *arg1 = (wxClipboard *) 0 ;
29479 PyObject * obj0 = 0 ;
29480 char *kwnames[] = {
29481 (char *) "self", NULL
29482 };
29483
29484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29486 if (SWIG_arg_fail(1)) SWIG_fail;
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 (arg1)->Close();
29490
29491 wxPyEndAllowThreads(__tstate);
29492 if (PyErr_Occurred()) SWIG_fail;
29493 }
29494 Py_INCREF(Py_None); resultobj = Py_None;
29495 return resultobj;
29496 fail:
29497 return NULL;
29498 }
29499
29500
29501 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29502 PyObject *resultobj;
29503 wxClipboard *arg1 = (wxClipboard *) 0 ;
29504 bool result;
29505 PyObject * obj0 = 0 ;
29506 char *kwnames[] = {
29507 (char *) "self", NULL
29508 };
29509
29510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29512 if (SWIG_arg_fail(1)) SWIG_fail;
29513 {
29514 PyThreadState* __tstate = wxPyBeginAllowThreads();
29515 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29516
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 {
29521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29522 }
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29530 PyObject *resultobj;
29531 wxClipboard *arg1 = (wxClipboard *) 0 ;
29532 wxDataObject *arg2 = (wxDataObject *) 0 ;
29533 bool result;
29534 PyObject * obj0 = 0 ;
29535 PyObject * obj1 = 0 ;
29536 char *kwnames[] = {
29537 (char *) "self",(char *) "data", NULL
29538 };
29539
29540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29542 if (SWIG_arg_fail(1)) SWIG_fail;
29543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29544 if (SWIG_arg_fail(2)) SWIG_fail;
29545 {
29546 PyThreadState* __tstate = wxPyBeginAllowThreads();
29547 result = (bool)(arg1)->AddData(arg2);
29548
29549 wxPyEndAllowThreads(__tstate);
29550 if (PyErr_Occurred()) SWIG_fail;
29551 }
29552 {
29553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29554 }
29555 return resultobj;
29556 fail:
29557 return NULL;
29558 }
29559
29560
29561 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29562 PyObject *resultobj;
29563 wxClipboard *arg1 = (wxClipboard *) 0 ;
29564 wxDataObject *arg2 = (wxDataObject *) 0 ;
29565 bool result;
29566 PyObject * obj0 = 0 ;
29567 PyObject * obj1 = 0 ;
29568 char *kwnames[] = {
29569 (char *) "self",(char *) "data", NULL
29570 };
29571
29572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29574 if (SWIG_arg_fail(1)) SWIG_fail;
29575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29576 if (SWIG_arg_fail(2)) SWIG_fail;
29577 {
29578 PyThreadState* __tstate = wxPyBeginAllowThreads();
29579 result = (bool)(arg1)->SetData(arg2);
29580
29581 wxPyEndAllowThreads(__tstate);
29582 if (PyErr_Occurred()) SWIG_fail;
29583 }
29584 {
29585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29586 }
29587 return resultobj;
29588 fail:
29589 return NULL;
29590 }
29591
29592
29593 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29594 PyObject *resultobj;
29595 wxClipboard *arg1 = (wxClipboard *) 0 ;
29596 wxDataFormat *arg2 = 0 ;
29597 bool result;
29598 PyObject * obj0 = 0 ;
29599 PyObject * obj1 = 0 ;
29600 char *kwnames[] = {
29601 (char *) "self",(char *) "format", NULL
29602 };
29603
29604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29606 if (SWIG_arg_fail(1)) SWIG_fail;
29607 {
29608 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29609 if (SWIG_arg_fail(2)) SWIG_fail;
29610 if (arg2 == NULL) {
29611 SWIG_null_ref("wxDataFormat");
29612 }
29613 if (SWIG_arg_fail(2)) SWIG_fail;
29614 }
29615 {
29616 PyThreadState* __tstate = wxPyBeginAllowThreads();
29617 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29618
29619 wxPyEndAllowThreads(__tstate);
29620 if (PyErr_Occurred()) SWIG_fail;
29621 }
29622 {
29623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29624 }
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj;
29633 wxClipboard *arg1 = (wxClipboard *) 0 ;
29634 wxDataObject *arg2 = 0 ;
29635 bool result;
29636 PyObject * obj0 = 0 ;
29637 PyObject * obj1 = 0 ;
29638 char *kwnames[] = {
29639 (char *) "self",(char *) "data", NULL
29640 };
29641
29642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29644 if (SWIG_arg_fail(1)) SWIG_fail;
29645 {
29646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29647 if (SWIG_arg_fail(2)) SWIG_fail;
29648 if (arg2 == NULL) {
29649 SWIG_null_ref("wxDataObject");
29650 }
29651 if (SWIG_arg_fail(2)) SWIG_fail;
29652 }
29653 {
29654 PyThreadState* __tstate = wxPyBeginAllowThreads();
29655 result = (bool)(arg1)->GetData(*arg2);
29656
29657 wxPyEndAllowThreads(__tstate);
29658 if (PyErr_Occurred()) SWIG_fail;
29659 }
29660 {
29661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29662 }
29663 return resultobj;
29664 fail:
29665 return NULL;
29666 }
29667
29668
29669 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29670 PyObject *resultobj;
29671 wxClipboard *arg1 = (wxClipboard *) 0 ;
29672 PyObject * obj0 = 0 ;
29673 char *kwnames[] = {
29674 (char *) "self", NULL
29675 };
29676
29677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29679 if (SWIG_arg_fail(1)) SWIG_fail;
29680 {
29681 PyThreadState* __tstate = wxPyBeginAllowThreads();
29682 (arg1)->Clear();
29683
29684 wxPyEndAllowThreads(__tstate);
29685 if (PyErr_Occurred()) SWIG_fail;
29686 }
29687 Py_INCREF(Py_None); resultobj = Py_None;
29688 return resultobj;
29689 fail:
29690 return NULL;
29691 }
29692
29693
29694 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29695 PyObject *resultobj;
29696 wxClipboard *arg1 = (wxClipboard *) 0 ;
29697 bool result;
29698 PyObject * obj0 = 0 ;
29699 char *kwnames[] = {
29700 (char *) "self", NULL
29701 };
29702
29703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29705 if (SWIG_arg_fail(1)) SWIG_fail;
29706 {
29707 PyThreadState* __tstate = wxPyBeginAllowThreads();
29708 result = (bool)(arg1)->Flush();
29709
29710 wxPyEndAllowThreads(__tstate);
29711 if (PyErr_Occurred()) SWIG_fail;
29712 }
29713 {
29714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29715 }
29716 return resultobj;
29717 fail:
29718 return NULL;
29719 }
29720
29721
29722 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29723 PyObject *resultobj;
29724 wxClipboard *arg1 = (wxClipboard *) 0 ;
29725 bool arg2 = (bool) true ;
29726 PyObject * obj0 = 0 ;
29727 PyObject * obj1 = 0 ;
29728 char *kwnames[] = {
29729 (char *) "self",(char *) "primary", NULL
29730 };
29731
29732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29734 if (SWIG_arg_fail(1)) SWIG_fail;
29735 if (obj1) {
29736 {
29737 arg2 = (bool)(SWIG_As_bool(obj1));
29738 if (SWIG_arg_fail(2)) SWIG_fail;
29739 }
29740 }
29741 {
29742 PyThreadState* __tstate = wxPyBeginAllowThreads();
29743 (arg1)->UsePrimarySelection(arg2);
29744
29745 wxPyEndAllowThreads(__tstate);
29746 if (PyErr_Occurred()) SWIG_fail;
29747 }
29748 Py_INCREF(Py_None); resultobj = Py_None;
29749 return resultobj;
29750 fail:
29751 return NULL;
29752 }
29753
29754
29755 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29756 PyObject *resultobj;
29757 wxClipboard *result;
29758 char *kwnames[] = {
29759 NULL
29760 };
29761
29762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29763 {
29764 PyThreadState* __tstate = wxPyBeginAllowThreads();
29765 result = (wxClipboard *)wxClipboard::Get();
29766
29767 wxPyEndAllowThreads(__tstate);
29768 if (PyErr_Occurred()) SWIG_fail;
29769 }
29770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29771 return resultobj;
29772 fail:
29773 return NULL;
29774 }
29775
29776
29777 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29778 PyObject *obj;
29779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29780 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29781 Py_INCREF(obj);
29782 return Py_BuildValue((char *)"");
29783 }
29784 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29785 PyObject *resultobj;
29786 wxClipboard *arg1 = (wxClipboard *) NULL ;
29787 wxClipboardLocker *result;
29788 PyObject * obj0 = 0 ;
29789 char *kwnames[] = {
29790 (char *) "clipboard", NULL
29791 };
29792
29793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29794 if (obj0) {
29795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29796 if (SWIG_arg_fail(1)) SWIG_fail;
29797 }
29798 {
29799 PyThreadState* __tstate = wxPyBeginAllowThreads();
29800 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29801
29802 wxPyEndAllowThreads(__tstate);
29803 if (PyErr_Occurred()) SWIG_fail;
29804 }
29805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29806 return resultobj;
29807 fail:
29808 return NULL;
29809 }
29810
29811
29812 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29813 PyObject *resultobj;
29814 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29815 PyObject * obj0 = 0 ;
29816 char *kwnames[] = {
29817 (char *) "self", NULL
29818 };
29819
29820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29822 if (SWIG_arg_fail(1)) SWIG_fail;
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 delete arg1;
29826
29827 wxPyEndAllowThreads(__tstate);
29828 if (PyErr_Occurred()) SWIG_fail;
29829 }
29830 Py_INCREF(Py_None); resultobj = Py_None;
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29838 PyObject *resultobj;
29839 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29840 bool result;
29841 PyObject * obj0 = 0 ;
29842 char *kwnames[] = {
29843 (char *) "self", NULL
29844 };
29845
29846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29848 if (SWIG_arg_fail(1)) SWIG_fail;
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 result = (bool)wxClipboardLocker___nonzero__(arg1);
29852
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 {
29857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29858 }
29859 return resultobj;
29860 fail:
29861 return NULL;
29862 }
29863
29864
29865 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29866 PyObject *obj;
29867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29868 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29869 Py_INCREF(obj);
29870 return Py_BuildValue((char *)"");
29871 }
29872 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29873 PyObject *resultobj;
29874 int arg1 = (int) 0 ;
29875 int arg2 = (int) 0 ;
29876 int arg3 = (int) 0 ;
29877 int arg4 = (int) 0 ;
29878 wxVideoMode *result;
29879 PyObject * obj0 = 0 ;
29880 PyObject * obj1 = 0 ;
29881 PyObject * obj2 = 0 ;
29882 PyObject * obj3 = 0 ;
29883 char *kwnames[] = {
29884 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29885 };
29886
29887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29888 if (obj0) {
29889 {
29890 arg1 = (int)(SWIG_As_int(obj0));
29891 if (SWIG_arg_fail(1)) SWIG_fail;
29892 }
29893 }
29894 if (obj1) {
29895 {
29896 arg2 = (int)(SWIG_As_int(obj1));
29897 if (SWIG_arg_fail(2)) SWIG_fail;
29898 }
29899 }
29900 if (obj2) {
29901 {
29902 arg3 = (int)(SWIG_As_int(obj2));
29903 if (SWIG_arg_fail(3)) SWIG_fail;
29904 }
29905 }
29906 if (obj3) {
29907 {
29908 arg4 = (int)(SWIG_As_int(obj3));
29909 if (SWIG_arg_fail(4)) SWIG_fail;
29910 }
29911 }
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29915
29916 wxPyEndAllowThreads(__tstate);
29917 if (PyErr_Occurred()) SWIG_fail;
29918 }
29919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29920 return resultobj;
29921 fail:
29922 return NULL;
29923 }
29924
29925
29926 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29927 PyObject *resultobj;
29928 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29929 PyObject * obj0 = 0 ;
29930 char *kwnames[] = {
29931 (char *) "self", NULL
29932 };
29933
29934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29936 if (SWIG_arg_fail(1)) SWIG_fail;
29937 {
29938 PyThreadState* __tstate = wxPyBeginAllowThreads();
29939 delete arg1;
29940
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 Py_INCREF(Py_None); resultobj = Py_None;
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
29952 PyObject *resultobj;
29953 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29954 wxVideoMode *arg2 = 0 ;
29955 bool result;
29956 PyObject * obj0 = 0 ;
29957 PyObject * obj1 = 0 ;
29958 char *kwnames[] = {
29959 (char *) "self",(char *) "other", NULL
29960 };
29961
29962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
29963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29964 if (SWIG_arg_fail(1)) SWIG_fail;
29965 {
29966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29967 if (SWIG_arg_fail(2)) SWIG_fail;
29968 if (arg2 == NULL) {
29969 SWIG_null_ref("wxVideoMode");
29970 }
29971 if (SWIG_arg_fail(2)) SWIG_fail;
29972 }
29973 {
29974 PyThreadState* __tstate = wxPyBeginAllowThreads();
29975 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
29976
29977 wxPyEndAllowThreads(__tstate);
29978 if (PyErr_Occurred()) SWIG_fail;
29979 }
29980 {
29981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29982 }
29983 return resultobj;
29984 fail:
29985 return NULL;
29986 }
29987
29988
29989 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29990 PyObject *resultobj;
29991 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29992 int result;
29993 PyObject * obj0 = 0 ;
29994 char *kwnames[] = {
29995 (char *) "self", NULL
29996 };
29997
29998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
29999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30000 if (SWIG_arg_fail(1)) SWIG_fail;
30001 {
30002 PyThreadState* __tstate = wxPyBeginAllowThreads();
30003 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30004
30005 wxPyEndAllowThreads(__tstate);
30006 if (PyErr_Occurred()) SWIG_fail;
30007 }
30008 {
30009 resultobj = SWIG_From_int((int)(result));
30010 }
30011 return resultobj;
30012 fail:
30013 return NULL;
30014 }
30015
30016
30017 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30018 PyObject *resultobj;
30019 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30020 int result;
30021 PyObject * obj0 = 0 ;
30022 char *kwnames[] = {
30023 (char *) "self", NULL
30024 };
30025
30026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30028 if (SWIG_arg_fail(1)) SWIG_fail;
30029 {
30030 PyThreadState* __tstate = wxPyBeginAllowThreads();
30031 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30032
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 {
30037 resultobj = SWIG_From_int((int)(result));
30038 }
30039 return resultobj;
30040 fail:
30041 return NULL;
30042 }
30043
30044
30045 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30046 PyObject *resultobj;
30047 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30048 int result;
30049 PyObject * obj0 = 0 ;
30050 char *kwnames[] = {
30051 (char *) "self", NULL
30052 };
30053
30054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) 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 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30060
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 {
30065 resultobj = SWIG_From_int((int)(result));
30066 }
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30074 PyObject *resultobj;
30075 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30076 bool result;
30077 PyObject * obj0 = 0 ;
30078 char *kwnames[] = {
30079 (char *) "self", NULL
30080 };
30081
30082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30084 if (SWIG_arg_fail(1)) SWIG_fail;
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30088
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 {
30093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30094 }
30095 return resultobj;
30096 fail:
30097 return NULL;
30098 }
30099
30100
30101 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30102 PyObject *resultobj;
30103 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30104 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30105 bool result;
30106 PyObject * obj0 = 0 ;
30107 PyObject * obj1 = 0 ;
30108 char *kwnames[] = {
30109 (char *) "self",(char *) "other", NULL
30110 };
30111
30112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30114 if (SWIG_arg_fail(1)) SWIG_fail;
30115 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30116 if (SWIG_arg_fail(2)) SWIG_fail;
30117 {
30118 PyThreadState* __tstate = wxPyBeginAllowThreads();
30119 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30120
30121 wxPyEndAllowThreads(__tstate);
30122 if (PyErr_Occurred()) SWIG_fail;
30123 }
30124 {
30125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30126 }
30127 return resultobj;
30128 fail:
30129 return NULL;
30130 }
30131
30132
30133 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30134 PyObject *resultobj;
30135 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30136 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30137 bool result;
30138 PyObject * obj0 = 0 ;
30139 PyObject * obj1 = 0 ;
30140 char *kwnames[] = {
30141 (char *) "self",(char *) "other", NULL
30142 };
30143
30144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30146 if (SWIG_arg_fail(1)) SWIG_fail;
30147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30148 if (SWIG_arg_fail(2)) SWIG_fail;
30149 {
30150 PyThreadState* __tstate = wxPyBeginAllowThreads();
30151 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30152
30153 wxPyEndAllowThreads(__tstate);
30154 if (PyErr_Occurred()) SWIG_fail;
30155 }
30156 {
30157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30158 }
30159 return resultobj;
30160 fail:
30161 return NULL;
30162 }
30163
30164
30165 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30166 PyObject *resultobj;
30167 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30168 int arg2 ;
30169 PyObject * obj0 = 0 ;
30170 PyObject * obj1 = 0 ;
30171 char *kwnames[] = {
30172 (char *) "self",(char *) "w", NULL
30173 };
30174
30175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30177 if (SWIG_arg_fail(1)) SWIG_fail;
30178 {
30179 arg2 = (int)(SWIG_As_int(obj1));
30180 if (SWIG_arg_fail(2)) SWIG_fail;
30181 }
30182 if (arg1) (arg1)->w = arg2;
30183
30184 Py_INCREF(Py_None); resultobj = Py_None;
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj;
30193 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30194 int result;
30195 PyObject * obj0 = 0 ;
30196 char *kwnames[] = {
30197 (char *) "self", NULL
30198 };
30199
30200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30202 if (SWIG_arg_fail(1)) SWIG_fail;
30203 result = (int) ((arg1)->w);
30204
30205 {
30206 resultobj = SWIG_From_int((int)(result));
30207 }
30208 return resultobj;
30209 fail:
30210 return NULL;
30211 }
30212
30213
30214 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30215 PyObject *resultobj;
30216 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30217 int arg2 ;
30218 PyObject * obj0 = 0 ;
30219 PyObject * obj1 = 0 ;
30220 char *kwnames[] = {
30221 (char *) "self",(char *) "h", NULL
30222 };
30223
30224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30226 if (SWIG_arg_fail(1)) SWIG_fail;
30227 {
30228 arg2 = (int)(SWIG_As_int(obj1));
30229 if (SWIG_arg_fail(2)) SWIG_fail;
30230 }
30231 if (arg1) (arg1)->h = arg2;
30232
30233 Py_INCREF(Py_None); resultobj = Py_None;
30234 return resultobj;
30235 fail:
30236 return NULL;
30237 }
30238
30239
30240 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30241 PyObject *resultobj;
30242 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30243 int result;
30244 PyObject * obj0 = 0 ;
30245 char *kwnames[] = {
30246 (char *) "self", NULL
30247 };
30248
30249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30251 if (SWIG_arg_fail(1)) SWIG_fail;
30252 result = (int) ((arg1)->h);
30253
30254 {
30255 resultobj = SWIG_From_int((int)(result));
30256 }
30257 return resultobj;
30258 fail:
30259 return NULL;
30260 }
30261
30262
30263 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30264 PyObject *resultobj;
30265 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30266 int arg2 ;
30267 PyObject * obj0 = 0 ;
30268 PyObject * obj1 = 0 ;
30269 char *kwnames[] = {
30270 (char *) "self",(char *) "bpp", NULL
30271 };
30272
30273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30275 if (SWIG_arg_fail(1)) SWIG_fail;
30276 {
30277 arg2 = (int)(SWIG_As_int(obj1));
30278 if (SWIG_arg_fail(2)) SWIG_fail;
30279 }
30280 if (arg1) (arg1)->bpp = arg2;
30281
30282 Py_INCREF(Py_None); resultobj = Py_None;
30283 return resultobj;
30284 fail:
30285 return NULL;
30286 }
30287
30288
30289 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30290 PyObject *resultobj;
30291 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30292 int result;
30293 PyObject * obj0 = 0 ;
30294 char *kwnames[] = {
30295 (char *) "self", NULL
30296 };
30297
30298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30300 if (SWIG_arg_fail(1)) SWIG_fail;
30301 result = (int) ((arg1)->bpp);
30302
30303 {
30304 resultobj = SWIG_From_int((int)(result));
30305 }
30306 return resultobj;
30307 fail:
30308 return NULL;
30309 }
30310
30311
30312 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30313 PyObject *resultobj;
30314 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30315 int arg2 ;
30316 PyObject * obj0 = 0 ;
30317 PyObject * obj1 = 0 ;
30318 char *kwnames[] = {
30319 (char *) "self",(char *) "refresh", NULL
30320 };
30321
30322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30324 if (SWIG_arg_fail(1)) SWIG_fail;
30325 {
30326 arg2 = (int)(SWIG_As_int(obj1));
30327 if (SWIG_arg_fail(2)) SWIG_fail;
30328 }
30329 if (arg1) (arg1)->refresh = arg2;
30330
30331 Py_INCREF(Py_None); resultobj = Py_None;
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30339 PyObject *resultobj;
30340 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30341 int result;
30342 PyObject * obj0 = 0 ;
30343 char *kwnames[] = {
30344 (char *) "self", NULL
30345 };
30346
30347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30349 if (SWIG_arg_fail(1)) SWIG_fail;
30350 result = (int) ((arg1)->refresh);
30351
30352 {
30353 resultobj = SWIG_From_int((int)(result));
30354 }
30355 return resultobj;
30356 fail:
30357 return NULL;
30358 }
30359
30360
30361 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30362 PyObject *obj;
30363 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30364 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30365 Py_INCREF(obj);
30366 return Py_BuildValue((char *)"");
30367 }
30368 static int _wrap_DefaultVideoMode_set(PyObject *) {
30369 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30370 return 1;
30371 }
30372
30373
30374 static PyObject *_wrap_DefaultVideoMode_get(void) {
30375 PyObject *pyobj;
30376
30377 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30378 return pyobj;
30379 }
30380
30381
30382 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30383 PyObject *resultobj;
30384 size_t arg1 = (size_t) 0 ;
30385 wxDisplay *result;
30386 PyObject * obj0 = 0 ;
30387 char *kwnames[] = {
30388 (char *) "index", NULL
30389 };
30390
30391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30392 if (obj0) {
30393 {
30394 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30395 if (SWIG_arg_fail(1)) SWIG_fail;
30396 }
30397 }
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 result = (wxDisplay *)new wxDisplay(arg1);
30401
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30413 PyObject *resultobj;
30414 wxDisplay *arg1 = (wxDisplay *) 0 ;
30415 PyObject * obj0 = 0 ;
30416 char *kwnames[] = {
30417 (char *) "self", NULL
30418 };
30419
30420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30422 if (SWIG_arg_fail(1)) SWIG_fail;
30423 {
30424 PyThreadState* __tstate = wxPyBeginAllowThreads();
30425 delete arg1;
30426
30427 wxPyEndAllowThreads(__tstate);
30428 if (PyErr_Occurred()) SWIG_fail;
30429 }
30430 Py_INCREF(Py_None); resultobj = Py_None;
30431 return resultobj;
30432 fail:
30433 return NULL;
30434 }
30435
30436
30437 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30438 PyObject *resultobj;
30439 size_t result;
30440 char *kwnames[] = {
30441 NULL
30442 };
30443
30444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30445 {
30446 PyThreadState* __tstate = wxPyBeginAllowThreads();
30447 result = (size_t)wxDisplay::GetCount();
30448
30449 wxPyEndAllowThreads(__tstate);
30450 if (PyErr_Occurred()) SWIG_fail;
30451 }
30452 {
30453 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30454 }
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30462 PyObject *resultobj;
30463 wxPoint *arg1 = 0 ;
30464 int result;
30465 wxPoint temp1 ;
30466 PyObject * obj0 = 0 ;
30467 char *kwnames[] = {
30468 (char *) "pt", NULL
30469 };
30470
30471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30472 {
30473 arg1 = &temp1;
30474 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30475 }
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30479
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 {
30484 resultobj = SWIG_From_int((int)(result));
30485 }
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30493 PyObject *resultobj;
30494 wxWindow *arg1 = (wxWindow *) 0 ;
30495 int result;
30496 PyObject * obj0 = 0 ;
30497 char *kwnames[] = {
30498 (char *) "window", NULL
30499 };
30500
30501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30503 if (SWIG_arg_fail(1)) SWIG_fail;
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 result = (int)Display_GetFromWindow(arg1);
30507
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 {
30512 resultobj = SWIG_From_int((int)(result));
30513 }
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30521 PyObject *resultobj;
30522 wxDisplay *arg1 = (wxDisplay *) 0 ;
30523 bool result;
30524 PyObject * obj0 = 0 ;
30525 char *kwnames[] = {
30526 (char *) "self", NULL
30527 };
30528
30529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",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 = (bool)((wxDisplay const *)arg1)->IsOk();
30535
30536 wxPyEndAllowThreads(__tstate);
30537 if (PyErr_Occurred()) SWIG_fail;
30538 }
30539 {
30540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30541 }
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30549 PyObject *resultobj;
30550 wxDisplay *arg1 = (wxDisplay *) 0 ;
30551 wxRect result;
30552 PyObject * obj0 = 0 ;
30553 char *kwnames[] = {
30554 (char *) "self", NULL
30555 };
30556
30557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30559 if (SWIG_arg_fail(1)) SWIG_fail;
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 result = ((wxDisplay const *)arg1)->GetGeometry();
30563
30564 wxPyEndAllowThreads(__tstate);
30565 if (PyErr_Occurred()) SWIG_fail;
30566 }
30567 {
30568 wxRect * resultptr;
30569 resultptr = new wxRect((wxRect &)(result));
30570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30571 }
30572 return resultobj;
30573 fail:
30574 return NULL;
30575 }
30576
30577
30578 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30579 PyObject *resultobj;
30580 wxDisplay *arg1 = (wxDisplay *) 0 ;
30581 wxString result;
30582 PyObject * obj0 = 0 ;
30583 char *kwnames[] = {
30584 (char *) "self", NULL
30585 };
30586
30587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30589 if (SWIG_arg_fail(1)) SWIG_fail;
30590 {
30591 PyThreadState* __tstate = wxPyBeginAllowThreads();
30592 result = ((wxDisplay const *)arg1)->GetName();
30593
30594 wxPyEndAllowThreads(__tstate);
30595 if (PyErr_Occurred()) SWIG_fail;
30596 }
30597 {
30598 #if wxUSE_UNICODE
30599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30600 #else
30601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30602 #endif
30603 }
30604 return resultobj;
30605 fail:
30606 return NULL;
30607 }
30608
30609
30610 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30611 PyObject *resultobj;
30612 wxDisplay *arg1 = (wxDisplay *) 0 ;
30613 bool result;
30614 PyObject * obj0 = 0 ;
30615 char *kwnames[] = {
30616 (char *) "self", NULL
30617 };
30618
30619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30621 if (SWIG_arg_fail(1)) SWIG_fail;
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30625
30626 wxPyEndAllowThreads(__tstate);
30627 if (PyErr_Occurred()) SWIG_fail;
30628 }
30629 {
30630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30631 }
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30639 PyObject *resultobj;
30640 wxDisplay *arg1 = (wxDisplay *) 0 ;
30641 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30642 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30643 PyObject *result;
30644 PyObject * obj0 = 0 ;
30645 PyObject * obj1 = 0 ;
30646 char *kwnames[] = {
30647 (char *) "self",(char *) "mode", NULL
30648 };
30649
30650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30652 if (SWIG_arg_fail(1)) SWIG_fail;
30653 if (obj1) {
30654 {
30655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30656 if (SWIG_arg_fail(2)) SWIG_fail;
30657 if (arg2 == NULL) {
30658 SWIG_null_ref("wxVideoMode");
30659 }
30660 if (SWIG_arg_fail(2)) SWIG_fail;
30661 }
30662 }
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30666
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 resultobj = result;
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30678 PyObject *resultobj;
30679 wxDisplay *arg1 = (wxDisplay *) 0 ;
30680 wxVideoMode result;
30681 PyObject * obj0 = 0 ;
30682 char *kwnames[] = {
30683 (char *) "self", NULL
30684 };
30685
30686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30688 if (SWIG_arg_fail(1)) SWIG_fail;
30689 {
30690 PyThreadState* __tstate = wxPyBeginAllowThreads();
30691 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30692
30693 wxPyEndAllowThreads(__tstate);
30694 if (PyErr_Occurred()) SWIG_fail;
30695 }
30696 {
30697 wxVideoMode * resultptr;
30698 resultptr = new wxVideoMode((wxVideoMode &)(result));
30699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30700 }
30701 return resultobj;
30702 fail:
30703 return NULL;
30704 }
30705
30706
30707 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30708 PyObject *resultobj;
30709 wxDisplay *arg1 = (wxDisplay *) 0 ;
30710 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30711 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30712 bool result;
30713 PyObject * obj0 = 0 ;
30714 PyObject * obj1 = 0 ;
30715 char *kwnames[] = {
30716 (char *) "self",(char *) "mode", NULL
30717 };
30718
30719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30721 if (SWIG_arg_fail(1)) SWIG_fail;
30722 if (obj1) {
30723 {
30724 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30725 if (SWIG_arg_fail(2)) SWIG_fail;
30726 if (arg2 == NULL) {
30727 SWIG_null_ref("wxVideoMode");
30728 }
30729 if (SWIG_arg_fail(2)) SWIG_fail;
30730 }
30731 }
30732 {
30733 PyThreadState* __tstate = wxPyBeginAllowThreads();
30734 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30735
30736 wxPyEndAllowThreads(__tstate);
30737 if (PyErr_Occurred()) SWIG_fail;
30738 }
30739 {
30740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30741 }
30742 return resultobj;
30743 fail:
30744 return NULL;
30745 }
30746
30747
30748 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30749 PyObject *resultobj;
30750 wxDisplay *arg1 = (wxDisplay *) 0 ;
30751 PyObject * obj0 = 0 ;
30752 char *kwnames[] = {
30753 (char *) "self", NULL
30754 };
30755
30756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30758 if (SWIG_arg_fail(1)) SWIG_fail;
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 (arg1)->ResetMode();
30762
30763 wxPyEndAllowThreads(__tstate);
30764 if (PyErr_Occurred()) SWIG_fail;
30765 }
30766 Py_INCREF(Py_None); resultobj = Py_None;
30767 return resultobj;
30768 fail:
30769 return NULL;
30770 }
30771
30772
30773 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30774 PyObject *obj;
30775 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30776 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30777 Py_INCREF(obj);
30778 return Py_BuildValue((char *)"");
30779 }
30780 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj;
30782 wxStandardPaths *result;
30783 char *kwnames[] = {
30784 NULL
30785 };
30786
30787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30788 {
30789 PyThreadState* __tstate = wxPyBeginAllowThreads();
30790 result = (wxStandardPaths *)StandardPaths_Get();
30791
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30803 PyObject *resultobj;
30804 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30805 wxString result;
30806 PyObject * obj0 = 0 ;
30807 char *kwnames[] = {
30808 (char *) "self", NULL
30809 };
30810
30811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30813 if (SWIG_arg_fail(1)) SWIG_fail;
30814 {
30815 PyThreadState* __tstate = wxPyBeginAllowThreads();
30816 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30817
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 {
30822 #if wxUSE_UNICODE
30823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30824 #else
30825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30826 #endif
30827 }
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30835 PyObject *resultobj;
30836 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30837 wxString result;
30838 PyObject * obj0 = 0 ;
30839 char *kwnames[] = {
30840 (char *) "self", NULL
30841 };
30842
30843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30845 if (SWIG_arg_fail(1)) SWIG_fail;
30846 {
30847 PyThreadState* __tstate = wxPyBeginAllowThreads();
30848 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30849
30850 wxPyEndAllowThreads(__tstate);
30851 if (PyErr_Occurred()) SWIG_fail;
30852 }
30853 {
30854 #if wxUSE_UNICODE
30855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30856 #else
30857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30858 #endif
30859 }
30860 return resultobj;
30861 fail:
30862 return NULL;
30863 }
30864
30865
30866 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30867 PyObject *resultobj;
30868 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30869 wxString result;
30870 PyObject * obj0 = 0 ;
30871 char *kwnames[] = {
30872 (char *) "self", NULL
30873 };
30874
30875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30877 if (SWIG_arg_fail(1)) SWIG_fail;
30878 {
30879 PyThreadState* __tstate = wxPyBeginAllowThreads();
30880 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30881
30882 wxPyEndAllowThreads(__tstate);
30883 if (PyErr_Occurred()) SWIG_fail;
30884 }
30885 {
30886 #if wxUSE_UNICODE
30887 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30888 #else
30889 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30890 #endif
30891 }
30892 return resultobj;
30893 fail:
30894 return NULL;
30895 }
30896
30897
30898 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30899 PyObject *resultobj;
30900 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30901 wxString result;
30902 PyObject * obj0 = 0 ;
30903 char *kwnames[] = {
30904 (char *) "self", NULL
30905 };
30906
30907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30909 if (SWIG_arg_fail(1)) SWIG_fail;
30910 {
30911 PyThreadState* __tstate = wxPyBeginAllowThreads();
30912 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30913
30914 wxPyEndAllowThreads(__tstate);
30915 if (PyErr_Occurred()) SWIG_fail;
30916 }
30917 {
30918 #if wxUSE_UNICODE
30919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30920 #else
30921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30922 #endif
30923 }
30924 return resultobj;
30925 fail:
30926 return NULL;
30927 }
30928
30929
30930 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30931 PyObject *resultobj;
30932 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30933 wxString result;
30934 PyObject * obj0 = 0 ;
30935 char *kwnames[] = {
30936 (char *) "self", NULL
30937 };
30938
30939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30941 if (SWIG_arg_fail(1)) SWIG_fail;
30942 {
30943 PyThreadState* __tstate = wxPyBeginAllowThreads();
30944 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30945
30946 wxPyEndAllowThreads(__tstate);
30947 if (PyErr_Occurred()) SWIG_fail;
30948 }
30949 {
30950 #if wxUSE_UNICODE
30951 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30952 #else
30953 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30954 #endif
30955 }
30956 return resultobj;
30957 fail:
30958 return NULL;
30959 }
30960
30961
30962 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30963 PyObject *resultobj;
30964 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30965 wxString result;
30966 PyObject * obj0 = 0 ;
30967 char *kwnames[] = {
30968 (char *) "self", NULL
30969 };
30970
30971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
30972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30973 if (SWIG_arg_fail(1)) SWIG_fail;
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
30977
30978 wxPyEndAllowThreads(__tstate);
30979 if (PyErr_Occurred()) SWIG_fail;
30980 }
30981 {
30982 #if wxUSE_UNICODE
30983 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30984 #else
30985 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30986 #endif
30987 }
30988 return resultobj;
30989 fail:
30990 return NULL;
30991 }
30992
30993
30994 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
30995 PyObject *resultobj;
30996 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30997 wxString result;
30998 PyObject * obj0 = 0 ;
30999 char *kwnames[] = {
31000 (char *) "self", NULL
31001 };
31002
31003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31005 if (SWIG_arg_fail(1)) SWIG_fail;
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31009
31010 wxPyEndAllowThreads(__tstate);
31011 if (PyErr_Occurred()) SWIG_fail;
31012 }
31013 {
31014 #if wxUSE_UNICODE
31015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31016 #else
31017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31018 #endif
31019 }
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31027 PyObject *resultobj;
31028 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31029 wxString *arg2 = 0 ;
31030 bool temp2 = false ;
31031 PyObject * obj0 = 0 ;
31032 PyObject * obj1 = 0 ;
31033 char *kwnames[] = {
31034 (char *) "self",(char *) "prefix", NULL
31035 };
31036
31037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31039 if (SWIG_arg_fail(1)) SWIG_fail;
31040 {
31041 arg2 = wxString_in_helper(obj1);
31042 if (arg2 == NULL) SWIG_fail;
31043 temp2 = true;
31044 }
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31048
31049 wxPyEndAllowThreads(__tstate);
31050 if (PyErr_Occurred()) SWIG_fail;
31051 }
31052 Py_INCREF(Py_None); resultobj = Py_None;
31053 {
31054 if (temp2)
31055 delete arg2;
31056 }
31057 return resultobj;
31058 fail:
31059 {
31060 if (temp2)
31061 delete arg2;
31062 }
31063 return NULL;
31064 }
31065
31066
31067 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31068 PyObject *resultobj;
31069 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31070 wxString result;
31071 PyObject * obj0 = 0 ;
31072 char *kwnames[] = {
31073 (char *) "self", NULL
31074 };
31075
31076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31078 if (SWIG_arg_fail(1)) SWIG_fail;
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 result = wxStandardPaths_GetInstallPrefix(arg1);
31082
31083 wxPyEndAllowThreads(__tstate);
31084 if (PyErr_Occurred()) SWIG_fail;
31085 }
31086 {
31087 #if wxUSE_UNICODE
31088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31089 #else
31090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31091 #endif
31092 }
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31100 PyObject *obj;
31101 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31102 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31103 Py_INCREF(obj);
31104 return Py_BuildValue((char *)"");
31105 }
31106 static PyMethodDef SwigMethods[] = {
31107 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31111 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31112 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31113 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31114 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31115 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31119 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31120 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31121 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31125 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31126 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31127 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31128 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31129 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31130 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31131 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31132 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31133 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31135 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31136 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31137 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31138 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31139 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31140 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31144 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31150 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31151 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31152 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31154 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31155 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31156 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31157 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31158 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31159 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31160 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31161 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31162 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31168 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31182 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31183 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31185 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31187 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31188 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31193 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31207 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31209 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31214 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31217 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31220 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31226 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31240 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31246 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31251 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31254 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31268 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31271 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31272 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31275 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31302 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31304 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31306 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31308 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31315 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31321 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31335 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31339 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31342 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31359 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31367 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31414 { (char *)"JoystickEvent_m_pos_set", (PyCFunction) _wrap_JoystickEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"JoystickEvent_m_pos_get", (PyCFunction) _wrap_JoystickEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"JoystickEvent_m_zPosition_set", (PyCFunction) _wrap_JoystickEvent_m_zPosition_set, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"JoystickEvent_m_zPosition_get", (PyCFunction) _wrap_JoystickEvent_m_zPosition_get, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"JoystickEvent_m_buttonChange_set", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_set, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"JoystickEvent_m_buttonChange_get", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_get, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"JoystickEvent_m_buttonState_set", (PyCFunction) _wrap_JoystickEvent_m_buttonState_set, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"JoystickEvent_m_buttonState_get", (PyCFunction) _wrap_JoystickEvent_m_buttonState_get, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"JoystickEvent_m_joyStick_set", (PyCFunction) _wrap_JoystickEvent_m_joyStick_set, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"JoystickEvent_m_joyStick_get", (PyCFunction) _wrap_JoystickEvent_m_joyStick_get, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31442 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31452 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31468 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31484 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31498 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31507 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31550 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31553 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31556 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31560 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31653 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31654 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31655 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31656 { (char *)"DateTime___lt__", _wrap_DateTime___lt__, METH_VARARGS, NULL},
31657 { (char *)"DateTime___le__", _wrap_DateTime___le__, METH_VARARGS, NULL},
31658 { (char *)"DateTime___gt__", _wrap_DateTime___gt__, METH_VARARGS, NULL},
31659 { (char *)"DateTime___ge__", _wrap_DateTime___ge__, METH_VARARGS, NULL},
31660 { (char *)"DateTime___eq__", _wrap_DateTime___eq__, METH_VARARGS, NULL},
31661 { (char *)"DateTime___ne__", _wrap_DateTime___ne__, METH_VARARGS, NULL},
31662 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31673 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31718 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31752 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31760 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31761 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31766 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31775 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31782 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31785 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31788 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31793 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31796 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31800 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31803 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31807 { (char *)"new_CustomDataObject", (PyCFunction) _wrap_new_CustomDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31812 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31816 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31820 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31830 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31841 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31849 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31857 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31871 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31875 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31893 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31907 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31918 { NULL, NULL, 0, NULL }
31919 };
31920
31921
31922 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31923
31924 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31925 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31926 }
31927 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31928 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31929 }
31930 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31931 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31932 }
31933 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31934 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31935 }
31936 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31937 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31938 }
31939 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31940 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31941 }
31942 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31943 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31944 }
31945 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31946 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31947 }
31948 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31949 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31950 }
31951 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31952 return (void *)((wxEvent *) ((wxPyEvent *) x));
31953 }
31954 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31955 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31956 }
31957 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
31958 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
31959 }
31960 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
31961 return (void *)((wxEvent *) ((wxIdleEvent *) x));
31962 }
31963 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
31964 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
31965 }
31966 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
31967 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
31968 }
31969 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
31970 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
31971 }
31972 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
31973 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
31974 }
31975 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
31976 return (void *)((wxEvent *) ((wxActivateEvent *) x));
31977 }
31978 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
31979 return (void *)((wxEvent *) ((wxSizeEvent *) x));
31980 }
31981 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
31982 return (void *)((wxEvent *) ((wxMoveEvent *) x));
31983 }
31984 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
31985 return (void *)((wxEvent *) ((wxPaintEvent *) x));
31986 }
31987 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
31988 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
31989 }
31990 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
31991 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
31992 }
31993 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
31994 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
31995 }
31996 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
31997 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
31998 }
31999 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32000 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32001 }
32002 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32003 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32004 }
32005 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32006 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32007 }
32008 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32009 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32010 }
32011 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32012 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32013 }
32014 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32015 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32016 }
32017 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32018 return (void *)((wxEvent *) ((wxShowEvent *) x));
32019 }
32020 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32021 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32022 }
32023 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32024 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32025 }
32026 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32027 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32028 }
32029 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32030 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32031 }
32032 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32033 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32034 }
32035 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32036 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32037 }
32038 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32039 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32040 }
32041 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32042 return (void *)((wxConfigBase *) ((wxConfig *) x));
32043 }
32044 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32045 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32046 }
32047 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32048 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32049 }
32050 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32051 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32052 }
32053 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32054 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32055 }
32056 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32057 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32058 }
32059 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32060 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32061 }
32062 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32063 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32064 }
32065 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32066 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32067 }
32068 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32069 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32070 }
32071 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32072 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32073 }
32074 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32075 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32076 }
32077 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32078 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32079 }
32080 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32081 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32082 }
32083 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32084 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32085 }
32086 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32087 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32088 }
32089 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32090 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32091 }
32092 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32093 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32094 }
32095 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32096 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32097 }
32098 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32099 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32100 }
32101 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32102 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32103 }
32104 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32105 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32106 }
32107 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32108 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32109 }
32110 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32111 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32112 }
32113 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32114 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32115 }
32116 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32117 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32118 }
32119 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32120 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32121 }
32122 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32123 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32124 }
32125 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32126 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32127 }
32128 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32129 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32130 }
32131 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32132 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32133 }
32134 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32135 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32136 }
32137 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32138 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32139 }
32140 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32141 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32142 }
32143 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32144 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32145 }
32146 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32147 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32148 }
32149 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32150 return (void *)((wxObject *) ((wxSizerItem *) x));
32151 }
32152 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32153 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32154 }
32155 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32156 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32157 }
32158 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32159 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32160 }
32161 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32162 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32163 }
32164 static void *_p_wxSizerTo_p_wxObject(void *x) {
32165 return (void *)((wxObject *) ((wxSizer *) x));
32166 }
32167 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32168 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32169 }
32170 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32171 return (void *)((wxObject *) ((wxFileHistory *) x));
32172 }
32173 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32174 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32175 }
32176 static void *_p_wxEventTo_p_wxObject(void *x) {
32177 return (void *)((wxObject *) ((wxEvent *) x));
32178 }
32179 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32180 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32181 }
32182 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32183 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32184 }
32185 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32186 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32187 }
32188 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32189 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32190 }
32191 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32192 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32193 }
32194 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32195 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32196 }
32197 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32198 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32199 }
32200 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32201 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32202 }
32203 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32204 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32205 }
32206 static void *_p_wxControlTo_p_wxObject(void *x) {
32207 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32208 }
32209 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32210 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32211 }
32212 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32213 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32214 }
32215 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32216 return (void *)((wxObject *) ((wxFSFile *) x));
32217 }
32218 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32219 return (void *)((wxObject *) ((wxClipboard *) x));
32220 }
32221 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32222 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32223 }
32224 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32225 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32226 }
32227 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32228 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32229 }
32230 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32231 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32232 }
32233 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32234 return (void *)((wxObject *) ((wxToolTip *) x));
32235 }
32236 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32237 return (void *)((wxObject *) ((wxMenuItem *) x));
32238 }
32239 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32240 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32241 }
32242 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32243 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32244 }
32245 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32246 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32247 }
32248 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32249 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32250 }
32251 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32252 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32253 }
32254 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32255 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32256 }
32257 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32258 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32259 }
32260 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32261 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32262 }
32263 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32264 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32265 }
32266 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32267 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32268 }
32269 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32270 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32271 }
32272 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32273 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32274 }
32275 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32276 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32277 }
32278 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32279 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32280 }
32281 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32282 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32283 }
32284 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32285 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32286 }
32287 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32288 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32289 }
32290 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32291 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32292 }
32293 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32294 return (void *)((wxObject *) ((wxImageHandler *) x));
32295 }
32296 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32297 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32298 }
32299 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32300 return (void *)((wxObject *) ((wxEvtHandler *) x));
32301 }
32302 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32303 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32304 }
32305 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32306 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32307 }
32308 static void *_p_wxImageTo_p_wxObject(void *x) {
32309 return (void *)((wxObject *) ((wxImage *) x));
32310 }
32311 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32312 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32313 }
32314 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32315 return (void *)((wxObject *) ((wxSystemOptions *) x));
32316 }
32317 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32318 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32319 }
32320 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32321 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32322 }
32323 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32324 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32325 }
32326 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32327 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32328 }
32329 static void *_p_wxWindowTo_p_wxObject(void *x) {
32330 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32331 }
32332 static void *_p_wxMenuTo_p_wxObject(void *x) {
32333 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32334 }
32335 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32336 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32337 }
32338 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32339 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32340 }
32341 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32342 return (void *)((wxObject *) ((wxFileSystem *) x));
32343 }
32344 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32345 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32346 }
32347 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32348 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32349 }
32350 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32351 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32352 }
32353 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32354 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32355 }
32356 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32357 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32358 }
32359 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32360 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32361 }
32362 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32363 return (void *)((wxObject *) ((wxBusyInfo *) x));
32364 }
32365 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32366 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32367 }
32368 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32369 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32370 }
32371 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32372 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32373 }
32374 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32375 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32376 }
32377 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32378 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32379 }
32380 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32381 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32382 }
32383 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32384 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32385 }
32386 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32387 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32388 }
32389 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32390 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32391 }
32392 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32393 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32394 }
32395 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32396 return (void *)((wxLog *) ((wxLogStderr *) x));
32397 }
32398 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32399 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32400 }
32401 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32402 return (void *)((wxLog *) ((wxLogWindow *) x));
32403 }
32404 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32405 return (void *)((wxLog *) ((wxLogChain *) x));
32406 }
32407 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32408 return (void *)((wxLog *) ((wxLogGui *) x));
32409 }
32410 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32411 return (void *)((wxLog *) ((wxPyLog *) x));
32412 }
32413 static void *_p_wxControlTo_p_wxWindow(void *x) {
32414 return (void *)((wxWindow *) ((wxControl *) x));
32415 }
32416 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32417 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32418 }
32419 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32420 return (void *)((wxWindow *) ((wxMenuBar *) x));
32421 }
32422 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32423 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32424 }
32425 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32426 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32427 }
32428 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}};
32429 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}};
32430 static swig_type_info _swigt__p_wxMetafile[] = {{"_p_wxMetafile", 0, "wxMetafile *", 0, 0, 0, 0},{"_p_wxMetafile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32431 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}};
32432 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}};
32433 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}};
32434 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}};
32435 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}};
32436 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}};
32437 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}};
32438 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}};
32439 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}};
32440 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}};
32441 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}};
32442 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}};
32443 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}};
32444 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}};
32445 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}};
32446 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}};
32447 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}};
32448 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}};
32449 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}};
32450 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}};
32451 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}};
32452 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}};
32453 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}};
32454 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}};
32455 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}};
32456 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}};
32457 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}};
32458 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}};
32459 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}};
32460 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}};
32461 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}};
32462 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}};
32463 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}};
32464 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}};
32465 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}};
32466 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}};
32467 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}};
32468 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}};
32469 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}};
32470 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}};
32471 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}};
32472 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}};
32473 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}};
32474 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}};
32475 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}};
32476 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}};
32477 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}};
32478 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}};
32479 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}};
32480 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}};
32481 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}};
32482 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}};
32483 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}};
32484 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}};
32485 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}};
32486 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}};
32487 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}};
32488 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}};
32489 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}};
32490 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}};
32491 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}};
32492 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}};
32493 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}};
32494 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}};
32495 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}};
32496 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}};
32497 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}};
32498 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}};
32499 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}};
32500 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}};
32501 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}};
32502 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}};
32503 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}};
32504 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}};
32505 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}};
32506 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}};
32507 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}};
32508 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}};
32509 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}};
32510 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}};
32511 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}};
32512 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}};
32513 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}};
32514 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}};
32515 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}};
32516 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}};
32517 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}};
32518 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}};
32519 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}};
32520 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}};
32521 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}};
32522 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}};
32523 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}};
32524
32525 static swig_type_info *swig_types_initial[] = {
32526 _swigt__p_wxLogChain,
32527 _swigt__p_wxMutexGuiLocker,
32528 _swigt__p_wxMetafile,
32529 _swigt__p_wxFileHistory,
32530 _swigt__p_wxLog,
32531 _swigt__p_wxMenu,
32532 _swigt__p_wxEvent,
32533 _swigt__p_wxDateTime__TimeZone,
32534 _swigt__p_wxConfigBase,
32535 _swigt__p_wxDisplay,
32536 _swigt__p_wxFileType,
32537 _swigt__p_wxLogGui,
32538 _swigt__p_wxFont,
32539 _swigt__p_wxDataFormat,
32540 _swigt__p_wxTimerEvent,
32541 _swigt__p_wxCaret,
32542 _swigt__ptrdiff_t,
32543 _swigt__std__ptrdiff_t,
32544 _swigt__p_int,
32545 _swigt__p_wxSize,
32546 _swigt__p_wxClipboard,
32547 _swigt__p_wxStopWatch,
32548 _swigt__p_wxClipboardLocker,
32549 _swigt__p_wxIcon,
32550 _swigt__p_wxLogStderr,
32551 _swigt__p_wxLogTextCtrl,
32552 _swigt__p_wxTextCtrl,
32553 _swigt__p_wxBusyCursor,
32554 _swigt__p_wxBitmapDataObject,
32555 _swigt__p_wxTextDataObject,
32556 _swigt__p_wxDataObject,
32557 _swigt__p_wxPyTextDataObject,
32558 _swigt__p_wxPyBitmapDataObject,
32559 _swigt__p_wxFileDataObject,
32560 _swigt__p_wxCustomDataObject,
32561 _swigt__p_wxURLDataObject,
32562 _swigt__p_wxMetafileDataObject,
32563 _swigt__p_wxSound,
32564 _swigt__p_wxTimerRunner,
32565 _swigt__p_wxLogWindow,
32566 _swigt__p_wxTimeSpan,
32567 _swigt__p_wxArrayString,
32568 _swigt__p_wxWindowDisabler,
32569 _swigt__p_form_ops_t,
32570 _swigt__p_wxToolTip,
32571 _swigt__p_wxDataObjectComposite,
32572 _swigt__p_wxFileConfig,
32573 _swigt__p_wxSystemSettings,
32574 _swigt__p_wxVideoMode,
32575 _swigt__p_wxDataObjectSimple,
32576 _swigt__p_wxPyDataObjectSimple,
32577 _swigt__p_wxDuplexMode,
32578 _swigt__p_wxEvtHandler,
32579 _swigt__p_wxRect,
32580 _swigt__p_char,
32581 _swigt__p_wxSingleInstanceChecker,
32582 _swigt__p_wxStandardPaths,
32583 _swigt__p_wxFileTypeInfo,
32584 _swigt__p_wxFrame,
32585 _swigt__p_wxTimer,
32586 _swigt__p_wxPaperSize,
32587 _swigt__p_wxMimeTypesManager,
32588 _swigt__p_wxPyArtProvider,
32589 _swigt__p_wxPyTipProvider,
32590 _swigt__p_wxTipProvider,
32591 _swigt__p_wxJoystick,
32592 _swigt__p_wxSystemOptions,
32593 _swigt__p_wxPoint,
32594 _swigt__p_wxJoystickEvent,
32595 _swigt__p_wxCursor,
32596 _swigt__p_wxObject,
32597 _swigt__p_wxOutputStream,
32598 _swigt__p_wxDateTime,
32599 _swigt__p_wxPyDropSource,
32600 _swigt__p_unsigned_long,
32601 _swigt__p_wxKillError,
32602 _swigt__p_wxWindow,
32603 _swigt__p_wxString,
32604 _swigt__p_wxPyProcess,
32605 _swigt__p_wxBitmap,
32606 _swigt__p_wxConfig,
32607 _swigt__unsigned_int,
32608 _swigt__p_unsigned_int,
32609 _swigt__p_unsigned_char,
32610 _swigt__p_wxChar,
32611 _swigt__p_wxBusyInfo,
32612 _swigt__p_wxPyDropTarget,
32613 _swigt__p_wxPyTextDropTarget,
32614 _swigt__p_wxPyFileDropTarget,
32615 _swigt__p_wxProcessEvent,
32616 _swigt__p_wxPyLog,
32617 _swigt__p_wxLogNull,
32618 _swigt__p_wxColour,
32619 _swigt__p_wxPyTimer,
32620 _swigt__p_wxConfigPathChanger,
32621 _swigt__p_wxDateSpan,
32622 0
32623 };
32624
32625
32626 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32627
32628 static swig_const_info swig_const_table[] = {
32629 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32630 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32631 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32632 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32633 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32634 {0, 0, 0, 0.0, 0, 0}};
32635
32636 #ifdef __cplusplus
32637 }
32638 #endif
32639
32640
32641 #ifdef __cplusplus
32642 extern "C" {
32643 #endif
32644
32645 /* Python-specific SWIG API */
32646 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32647 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32648 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32649
32650 /* -----------------------------------------------------------------------------
32651 * global variable support code.
32652 * ----------------------------------------------------------------------------- */
32653
32654 typedef struct swig_globalvar {
32655 char *name; /* Name of global variable */
32656 PyObject *(*get_attr)(); /* Return the current value */
32657 int (*set_attr)(PyObject *); /* Set the value */
32658 struct swig_globalvar *next;
32659 } swig_globalvar;
32660
32661 typedef struct swig_varlinkobject {
32662 PyObject_HEAD
32663 swig_globalvar *vars;
32664 } swig_varlinkobject;
32665
32666 static PyObject *
32667 swig_varlink_repr(swig_varlinkobject *v) {
32668 v = v;
32669 return PyString_FromString("<Swig global variables>");
32670 }
32671
32672 static int
32673 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32674 swig_globalvar *var;
32675 flags = flags;
32676 fprintf(fp,"Swig global variables { ");
32677 for (var = v->vars; var; var=var->next) {
32678 fprintf(fp,"%s", var->name);
32679 if (var->next) fprintf(fp,", ");
32680 }
32681 fprintf(fp," }\n");
32682 return 0;
32683 }
32684
32685 static PyObject *
32686 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32687 swig_globalvar *var = v->vars;
32688 while (var) {
32689 if (strcmp(var->name,n) == 0) {
32690 return (*var->get_attr)();
32691 }
32692 var = var->next;
32693 }
32694 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32695 return NULL;
32696 }
32697
32698 static int
32699 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32700 swig_globalvar *var = v->vars;
32701 while (var) {
32702 if (strcmp(var->name,n) == 0) {
32703 return (*var->set_attr)(p);
32704 }
32705 var = var->next;
32706 }
32707 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32708 return 1;
32709 }
32710
32711 static PyTypeObject varlinktype = {
32712 PyObject_HEAD_INIT(0)
32713 0, /* Number of items in variable part (ob_size) */
32714 (char *)"swigvarlink", /* Type name (tp_name) */
32715 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32716 0, /* Itemsize (tp_itemsize) */
32717 0, /* Deallocator (tp_dealloc) */
32718 (printfunc) swig_varlink_print, /* Print (tp_print) */
32719 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32720 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32721 0, /* tp_compare */
32722 (reprfunc) swig_varlink_repr, /* tp_repr */
32723 0, /* tp_as_number */
32724 0, /* tp_as_sequence */
32725 0, /* tp_as_mapping */
32726 0, /* tp_hash */
32727 0, /* tp_call */
32728 0, /* tp_str */
32729 0, /* tp_getattro */
32730 0, /* tp_setattro */
32731 0, /* tp_as_buffer */
32732 0, /* tp_flags */
32733 0, /* tp_doc */
32734 #if PY_VERSION_HEX >= 0x02000000
32735 0, /* tp_traverse */
32736 0, /* tp_clear */
32737 #endif
32738 #if PY_VERSION_HEX >= 0x02010000
32739 0, /* tp_richcompare */
32740 0, /* tp_weaklistoffset */
32741 #endif
32742 #if PY_VERSION_HEX >= 0x02020000
32743 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32744 #endif
32745 #if PY_VERSION_HEX >= 0x02030000
32746 0, /* tp_del */
32747 #endif
32748 #ifdef COUNT_ALLOCS
32749 0,0,0,0 /* tp_alloc -> tp_next */
32750 #endif
32751 };
32752
32753 /* Create a variable linking object for use later */
32754 static PyObject *
32755 SWIG_Python_newvarlink(void) {
32756 swig_varlinkobject *result = 0;
32757 result = PyMem_NEW(swig_varlinkobject,1);
32758 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32759 result->ob_type = &varlinktype;
32760 result->vars = 0;
32761 result->ob_refcnt = 0;
32762 Py_XINCREF((PyObject *) result);
32763 return ((PyObject*) result);
32764 }
32765
32766 static void
32767 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32768 swig_varlinkobject *v;
32769 swig_globalvar *gv;
32770 v= (swig_varlinkobject *) p;
32771 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32772 gv->name = (char *) malloc(strlen(name)+1);
32773 strcpy(gv->name,name);
32774 gv->get_attr = get_attr;
32775 gv->set_attr = set_attr;
32776 gv->next = v->vars;
32777 v->vars = gv;
32778 }
32779
32780 /* -----------------------------------------------------------------------------
32781 * constants/methods manipulation
32782 * ----------------------------------------------------------------------------- */
32783
32784 /* Install Constants */
32785 static void
32786 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32787 PyObject *obj = 0;
32788 size_t i;
32789 for (i = 0; constants[i].type; i++) {
32790 switch(constants[i].type) {
32791 case SWIG_PY_INT:
32792 obj = PyInt_FromLong(constants[i].lvalue);
32793 break;
32794 case SWIG_PY_FLOAT:
32795 obj = PyFloat_FromDouble(constants[i].dvalue);
32796 break;
32797 case SWIG_PY_STRING:
32798 if (constants[i].pvalue) {
32799 obj = PyString_FromString((char *) constants[i].pvalue);
32800 } else {
32801 Py_INCREF(Py_None);
32802 obj = Py_None;
32803 }
32804 break;
32805 case SWIG_PY_POINTER:
32806 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32807 break;
32808 case SWIG_PY_BINARY:
32809 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32810 break;
32811 default:
32812 obj = 0;
32813 break;
32814 }
32815 if (obj) {
32816 PyDict_SetItemString(d,constants[i].name,obj);
32817 Py_DECREF(obj);
32818 }
32819 }
32820 }
32821
32822 /* -----------------------------------------------------------------------------*/
32823 /* Fix SwigMethods to carry the callback ptrs when needed */
32824 /* -----------------------------------------------------------------------------*/
32825
32826 static void
32827 SWIG_Python_FixMethods(PyMethodDef *methods,
32828 swig_const_info *const_table,
32829 swig_type_info **types,
32830 swig_type_info **types_initial) {
32831 size_t i;
32832 for (i = 0; methods[i].ml_name; ++i) {
32833 char *c = methods[i].ml_doc;
32834 if (c && (c = strstr(c, "swig_ptr: "))) {
32835 int j;
32836 swig_const_info *ci = 0;
32837 char *name = c + 10;
32838 for (j = 0; const_table[j].type; j++) {
32839 if (strncmp(const_table[j].name, name,
32840 strlen(const_table[j].name)) == 0) {
32841 ci = &(const_table[j]);
32842 break;
32843 }
32844 }
32845 if (ci) {
32846 size_t shift = (ci->ptype) - types;
32847 swig_type_info *ty = types_initial[shift];
32848 size_t ldoc = (c - methods[i].ml_doc);
32849 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32850 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32851 char *buff = ndoc;
32852 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32853 strncpy(buff, methods[i].ml_doc, ldoc);
32854 buff += ldoc;
32855 strncpy(buff, "swig_ptr: ", 10);
32856 buff += 10;
32857 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32858 methods[i].ml_doc = ndoc;
32859 }
32860 }
32861 }
32862 }
32863
32864 /* -----------------------------------------------------------------------------*
32865 * Initialize type list
32866 * -----------------------------------------------------------------------------*/
32867
32868 #if PY_MAJOR_VERSION < 2
32869 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32870 is copied out of Python/modsupport.c in python version 2.3.4 */
32871 static int
32872 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32873 {
32874 PyObject *dict;
32875 if (!PyModule_Check(m)) {
32876 PyErr_SetString(PyExc_TypeError,
32877 "PyModule_AddObject() needs module as first arg");
32878 return -1;
32879 }
32880 if (!o) {
32881 PyErr_SetString(PyExc_TypeError,
32882 "PyModule_AddObject() needs non-NULL value");
32883 return -1;
32884 }
32885
32886 dict = PyModule_GetDict(m);
32887 if (dict == NULL) {
32888 /* Internal error -- modules must have a dict! */
32889 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32890 PyModule_GetName(m));
32891 return -1;
32892 }
32893 if (PyDict_SetItemString(dict, name, o))
32894 return -1;
32895 Py_DECREF(o);
32896 return 0;
32897 }
32898 #endif
32899
32900 static swig_type_info **
32901 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32902 static PyMethodDef swig_empty_runtime_method_table[] = {
32903 {
32904 NULL, NULL, 0, NULL
32905 }
32906 };/* Sentinel */
32907
32908 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32909 swig_empty_runtime_method_table);
32910 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32911 if (pointer && module) {
32912 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32913 }
32914 return type_list_handle;
32915 }
32916
32917 static swig_type_info **
32918 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32919 swig_type_info **type_pointer;
32920
32921 /* first check if module already created */
32922 type_pointer = SWIG_Python_GetTypeListHandle();
32923 if (type_pointer) {
32924 return type_pointer;
32925 } else {
32926 /* create a new module and variable */
32927 return SWIG_Python_SetTypeListHandle(type_list_handle);
32928 }
32929 }
32930
32931 #ifdef __cplusplus
32932 }
32933 #endif
32934
32935 /* -----------------------------------------------------------------------------*
32936 * Partial Init method
32937 * -----------------------------------------------------------------------------*/
32938
32939 #ifdef SWIG_LINK_RUNTIME
32940 #ifdef __cplusplus
32941 extern "C"
32942 #endif
32943 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32944 #endif
32945
32946 #ifdef __cplusplus
32947 extern "C"
32948 #endif
32949 SWIGEXPORT(void) SWIG_init(void) {
32950 static PyObject *SWIG_globals = 0;
32951 static int typeinit = 0;
32952 PyObject *m, *d;
32953 int i;
32954 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
32955
32956 /* Fix SwigMethods to carry the callback ptrs when needed */
32957 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
32958
32959 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32960 d = PyModule_GetDict(m);
32961
32962 if (!typeinit) {
32963 #ifdef SWIG_LINK_RUNTIME
32964 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
32965 #else
32966 # ifndef SWIG_STATIC_RUNTIME
32967 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
32968 # endif
32969 #endif
32970 for (i = 0; swig_types_initial[i]; i++) {
32971 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
32972 }
32973 typeinit = 1;
32974 }
32975 SWIG_InstallConstants(d,swig_const_table);
32976
32977 {
32978 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
32979 }
32980 {
32981 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
32982 }
32983 {
32984 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
32985 }
32986 {
32987 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
32988 }
32989 {
32990 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
32991 }
32992 {
32993 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
32994 }
32995 {
32996 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
32997 }
32998 {
32999 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33000 }
33001 {
33002 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33003 }
33004 {
33005 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33006 }
33007 {
33008 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33009 }
33010 {
33011 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33012 }
33013 {
33014 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33015 }
33016 {
33017 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33018 }
33019 {
33020 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33021 }
33022 {
33023 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33024 }
33025 {
33026 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33027 }
33028 {
33029 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33030 }
33031 {
33032 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33033 }
33034 {
33035 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33036 }
33037 {
33038 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33039 }
33040 {
33041 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33042 }
33043 {
33044 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33045 }
33046 {
33047 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33048 }
33049 {
33050 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33051 }
33052 {
33053 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33054 }
33055 {
33056 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33057 }
33058 {
33059 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33060 }
33061 {
33062 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33063 }
33064 {
33065 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33066 }
33067 {
33068 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33069 }
33070 {
33071 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33072 }
33073 {
33074 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33075 }
33076 {
33077 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33078 }
33079 {
33080 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33081 }
33082 {
33083 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33084 }
33085 {
33086 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33087 }
33088 {
33089 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33090 }
33091 {
33092 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33093 }
33094 {
33095 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33096 }
33097 {
33098 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33099 }
33100 {
33101 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33102 }
33103 {
33104 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33105 }
33106 {
33107 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33108 }
33109 {
33110 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33111 }
33112 {
33113 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33114 }
33115 {
33116 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33117 }
33118 {
33119 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33120 }
33121 {
33122 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33123 }
33124 {
33125 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33126 }
33127 {
33128 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33129 }
33130 {
33131 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33132 }
33133 {
33134 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33135 }
33136 {
33137 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33138 }
33139 {
33140 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33141 }
33142 {
33143 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33144 }
33145 {
33146 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33147 }
33148 {
33149 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33150 }
33151 {
33152 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33153 }
33154 {
33155 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33156 }
33157 {
33158 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33159 }
33160 {
33161 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33162 }
33163 {
33164 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33165 }
33166 {
33167 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33168 }
33169 {
33170 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33171 }
33172 {
33173 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33174 }
33175 {
33176 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33177 }
33178 {
33179 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33180 }
33181 {
33182 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33183 }
33184 {
33185 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33186 }
33187 {
33188 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33189 }
33190 {
33191 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33192 }
33193 {
33194 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33195 }
33196 {
33197 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33198 }
33199 {
33200 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33201 }
33202 {
33203 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33204 }
33205 {
33206 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33207 }
33208 {
33209 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33210 }
33211 {
33212 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33213 }
33214 {
33215 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33216 }
33217 {
33218 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33219 }
33220 {
33221 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33222 }
33223 {
33224 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33225 }
33226 {
33227 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33228 }
33229 {
33230 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33231 }
33232 {
33233 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33234 }
33235 {
33236 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33237 }
33238 {
33239 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33240 }
33241 {
33242 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33243 }
33244 {
33245 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33246 }
33247 {
33248 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33249 }
33250 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33251 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33252 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33253 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33254 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33255 {
33256 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33257 }
33258 {
33259 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33260 }
33261 {
33262 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33263 }
33264 {
33265 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33266 }
33267 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33268
33269 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33270
33271 {
33272 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33273 }
33274 {
33275 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33276 }
33277 {
33278 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33279 }
33280 {
33281 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33282 }
33283 {
33284 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33285 }
33286 {
33287 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33288 }
33289 {
33290 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33291 }
33292 {
33293 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33294 }
33295 {
33296 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33297 }
33298 {
33299 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33300 }
33301 {
33302 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33303 }
33304 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33305 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33306 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33307 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33308 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33309 {
33310 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33311 }
33312 {
33313 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33314 }
33315 {
33316 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33317 }
33318 {
33319 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33320 }
33321 {
33322 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33323 }
33324 {
33325 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33326 }
33327 {
33328 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33329 }
33330 {
33331 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33332 }
33333 {
33334 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33335 }
33336 {
33337 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33338 }
33339 {
33340 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33341 }
33342 {
33343 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33344 }
33345 {
33346 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33347 }
33348 {
33349 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33350 }
33351 {
33352 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33353 }
33354 {
33355 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33356 }
33357 {
33358 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33359 }
33360 {
33361 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33362 }
33363 {
33364 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33365 }
33366 {
33367 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33368 }
33369 {
33370 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33371 }
33372 {
33373 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33374 }
33375 {
33376 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33377 }
33378 {
33379 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33380 }
33381 {
33382 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33383 }
33384 {
33385 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33386 }
33387 {
33388 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33389 }
33390 {
33391 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33392 }
33393 {
33394 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33401 }
33402 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33403 {
33404 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33405 }
33406 {
33407 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33408 }
33409 {
33410 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33411 }
33412 {
33413 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33414 }
33415 {
33416 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33417 }
33418
33419 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33420
33421 {
33422 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33423 }
33424 {
33425 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33426 }
33427 {
33428 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33429 }
33430 {
33431 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33432 }
33433 {
33434 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33435 }
33436 {
33437 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33438 }
33439 {
33440 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33441 }
33442 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33443 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33444 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33445 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33446 {
33447 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33469 }
33470 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33471 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33472 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33473 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33474 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33475 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33476 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33477 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33478 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33479 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33480 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33481 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33482 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33483 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33484 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33485 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33486 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33487 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33488 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33489 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33490 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33491 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33492 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33493 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33494 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33495 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33496 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33497 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33498 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33499 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33500 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33501 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33502 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33503 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33504 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33505 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33506 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33507 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33508 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33509 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33510 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33511 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33512 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33513 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33514 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33515
33516 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33517
33518 {
33519 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33544 }
33545 SWIG_addvarlink(SWIG_globals,(char*)"DateFormatStr",_wrap_DateFormatStr_get, _wrap_DateFormatStr_set);
33546 SWIG_addvarlink(SWIG_globals,(char*)"TimeSpanFormatStr",_wrap_TimeSpanFormatStr_get, _wrap_TimeSpanFormatStr_set);
33547 {
33548 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33549 }
33550 {
33551 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33624 }
33625 {
33626 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33627 }
33628 {
33629 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33630 }
33631 {
33632 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33633 }
33634 {
33635 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33636 }
33637 {
33638 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33639 }
33640 {
33641 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33645 }
33646 {
33647 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33648 }
33649 {
33650 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33684 }
33685 {
33686 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33687 }
33688 {
33689 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33690 }
33691 {
33692 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33693 }
33694 {
33695 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33696 }
33697 {
33698 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33699 }
33700 {
33701 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33705 }
33706 {
33707 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33708 }
33709 {
33710 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33711 }
33712 {
33713 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33717 }
33718 {
33719 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33720 }
33721 {
33722 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33726 }
33727 {
33728 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33738 }
33739 {
33740 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33741 }
33742 {
33743 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33744 }
33745 {
33746 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33747 }
33748 {
33749 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33759 }
33760 {
33761 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33762 }
33763 {
33764 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33765 }
33766 {
33767 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33768 }
33769 {
33770 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33771 }
33772 {
33773 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33774 }
33775 {
33776 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33777 }
33778 {
33779 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33780 }
33781 {
33782 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33783 }
33784 {
33785 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33786 }
33787 {
33788 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33789 }
33790 {
33791 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33792 }
33793 {
33794 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33795 }
33796 {
33797 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33798 }
33799 {
33800 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33801 }
33802 {
33803 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33804 }
33805 {
33806 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33807 }
33808 {
33809 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33819 }
33820 {
33821 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33822 }
33823 {
33824 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33825 }
33826 {
33827 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33828 }
33829 {
33830 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33831 }
33832 {
33833 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33834 }
33835 {
33836 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33837 }
33838 {
33839 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33840 }
33841 {
33842 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33843 }
33844 {
33845 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33846 }
33847 {
33848 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33849 }
33850 {
33851 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33888 }
33889 {
33890 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34011 }
34012 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34013 {
34014 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34072 }
34073 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34074 {
34075 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34109 }
34110
34111 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34112 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34113 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34114 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34115
34116 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34117 }
34118
wxWidgets (Impactor)