]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added more tests for wxFileConfig creation: adding new entries/groups in different...
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 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_wxDC swig_types[22]
1364 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1365 #define SWIGTYPE_p_wxIcon swig_types[24]
1366 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1367 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1369 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1370 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1379 #define SWIGTYPE_p_wxSound swig_types[38]
1380 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1381 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1382 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1383 #define SWIGTYPE_p_wxArrayString swig_types[42]
1384 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxToolTip swig_types[45]
1387 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1390 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1391 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1393 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1394 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1395 #define SWIGTYPE_p_wxRect swig_types[54]
1396 #define SWIGTYPE_p_char swig_types[55]
1397 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1398 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1399 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1400 #define SWIGTYPE_p_wxFrame swig_types[59]
1401 #define SWIGTYPE_p_wxTimer swig_types[60]
1402 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1403 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1404 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1405 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1407 #define SWIGTYPE_p_wxJoystick swig_types[66]
1408 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1409 #define SWIGTYPE_p_wxPoint swig_types[68]
1410 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1411 #define SWIGTYPE_p_wxCursor swig_types[70]
1412 #define SWIGTYPE_p_wxObject swig_types[71]
1413 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1414 #define SWIGTYPE_p_wxDateTime swig_types[73]
1415 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1416 #define SWIGTYPE_p_unsigned_long swig_types[75]
1417 #define SWIGTYPE_p_wxKillError swig_types[76]
1418 #define SWIGTYPE_p_wxWindow swig_types[77]
1419 #define SWIGTYPE_p_wxString swig_types[78]
1420 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1421 #define SWIGTYPE_p_wxBitmap swig_types[80]
1422 #define SWIGTYPE_p_wxConfig swig_types[81]
1423 #define SWIGTYPE_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_int swig_types[83]
1425 #define SWIGTYPE_p_unsigned_char swig_types[84]
1426 #define SWIGTYPE_p_wxChar swig_types[85]
1427 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1428 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1431 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPyLog swig_types[91]
1433 #define SWIGTYPE_p_wxLogNull swig_types[92]
1434 #define SWIGTYPE_p_wxColour swig_types[93]
1435 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1436 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1437 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1438 static swig_type_info *swig_types[98];
1439
1440 /* -------- TYPES TABLE (END) -------- */
1441
1442
1443 /*-----------------------------------------------
1444 @(target):= _misc_.so
1445 ------------------------------------------------*/
1446 #define SWIG_init init_misc_
1447
1448 #define SWIG_name "_misc_"
1449
1450 #include "wx/wxPython/wxPython.h"
1451 #include "wx/wxPython/pyclasses.h"
1452 #include "wx/wxPython/pyistream.h"
1453
1454 static const wxString wxPyEmptyString(wxEmptyString);
1455
1456
1457
1458 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1459 #define SWIG_From_int PyInt_FromLong
1460 /*@@*/
1461
1462
1463 #include <limits.h>
1464
1465
1466 SWIGINTERN int
1467 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1468 const char *errmsg)
1469 {
1470 if (value < min_value) {
1471 if (errmsg) {
1472 PyErr_Format(PyExc_OverflowError,
1473 "value %ld is less than '%s' minimum %ld",
1474 value, errmsg, min_value);
1475 }
1476 return 0;
1477 } else if (value > max_value) {
1478 if (errmsg) {
1479 PyErr_Format(PyExc_OverflowError,
1480 "value %ld is greater than '%s' maximum %ld",
1481 value, errmsg, max_value);
1482 }
1483 return 0;
1484 }
1485 return 1;
1486 }
1487
1488
1489 SWIGINTERN int
1490 SWIG_AsVal_long(PyObject* obj, long* val)
1491 {
1492 if (PyNumber_Check(obj)) {
1493 if (val) *val = PyInt_AsLong(obj);
1494 return 1;
1495 }
1496 else {
1497 SWIG_type_error("number", obj);
1498 }
1499 return 0;
1500 }
1501
1502
1503 #if INT_MAX != LONG_MAX
1504 SWIGINTERN int
1505 SWIG_AsVal_int(PyObject *obj, int *val)
1506 {
1507 const char* errmsg = val ? "int" : (char*)0;
1508 long v;
1509 if (SWIG_AsVal_long(obj, &v)) {
1510 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1511 if (val) *val = (int)(v);
1512 return 1;
1513 } else {
1514 return 0;
1515 }
1516 } else {
1517 PyErr_Clear();
1518 }
1519 if (val) {
1520 SWIG_type_error(errmsg, obj);
1521 }
1522 return 0;
1523 }
1524 #else
1525 SWIGINTERNSHORT int
1526 SWIG_AsVal_int(PyObject *obj, int *val)
1527 {
1528 return SWIG_AsVal_long(obj,(long*)val);
1529 }
1530 #endif
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_As_int(PyObject* obj)
1535 {
1536 int v;
1537 if (!SWIG_AsVal_int(obj, &v)) {
1538 /*
1539 this is needed to make valgrind/purify happier.
1540 */
1541 memset((void*)&v, 0, sizeof(int));
1542 }
1543 return v;
1544 }
1545
1546
1547 SWIGINTERNSHORT int
1548 SWIG_Check_int(PyObject* obj)
1549 {
1550 return SWIG_AsVal_int(obj, (int*)0);
1551 }
1552
1553 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1554
1555 #include <wx/stockitem.h>
1556
1557 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1558 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1559 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1560
1561 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1562 #define SWIG_From_long PyInt_FromLong
1563 /*@@*/
1564
1565
1566 SWIGINTERNSHORT long
1567 SWIG_As_long(PyObject* obj)
1568 {
1569 long v;
1570 if (!SWIG_AsVal_long(obj, &v)) {
1571 /*
1572 this is needed to make valgrind/purify happier.
1573 */
1574 memset((void*)&v, 0, sizeof(long));
1575 }
1576 return v;
1577 }
1578
1579
1580 SWIGINTERNSHORT int
1581 SWIG_Check_long(PyObject* obj)
1582 {
1583 return SWIG_AsVal_long(obj, (long*)0);
1584 }
1585
1586
1587 SWIGINTERN int
1588 SWIG_AsVal_bool(PyObject *obj, bool *val)
1589 {
1590 if (obj == Py_True) {
1591 if (val) *val = true;
1592 return 1;
1593 }
1594 if (obj == Py_False) {
1595 if (val) *val = false;
1596 return 1;
1597 }
1598 int res = 0;
1599 if (SWIG_AsVal_int(obj, &res)) {
1600 if (val) *val = res ? true : false;
1601 return 1;
1602 } else {
1603 PyErr_Clear();
1604 }
1605 if (val) {
1606 SWIG_type_error("bool", obj);
1607 }
1608 return 0;
1609 }
1610
1611
1612 SWIGINTERNSHORT bool
1613 SWIG_As_bool(PyObject* obj)
1614 {
1615 bool v;
1616 if (!SWIG_AsVal_bool(obj, &v)) {
1617 /*
1618 this is needed to make valgrind/purify happier.
1619 */
1620 memset((void*)&v, 0, sizeof(bool));
1621 }
1622 return v;
1623 }
1624
1625
1626 SWIGINTERNSHORT int
1627 SWIG_Check_bool(PyObject* obj)
1628 {
1629 return SWIG_AsVal_bool(obj, (bool*)0);
1630 }
1631
1632
1633 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1634 PyObject* o2;
1635 PyObject* o3;
1636
1637 if (!target) {
1638 target = o;
1639 } else if (target == Py_None) {
1640 Py_DECREF(Py_None);
1641 target = o;
1642 } else {
1643 if (!PyTuple_Check(target)) {
1644 o2 = target;
1645 target = PyTuple_New(1);
1646 PyTuple_SetItem(target, 0, o2);
1647 }
1648 o3 = PyTuple_New(1);
1649 PyTuple_SetItem(o3, 0, o);
1650
1651 o2 = target;
1652 target = PySequence_Concat(o2, o3);
1653 Py_DECREF(o2);
1654 Py_DECREF(o3);
1655 }
1656 return target;
1657 }
1658
1659
1660
1661 SWIGINTERN int
1662 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1663 {
1664 long v = 0;
1665 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1666 SWIG_type_error("unsigned number", obj);
1667 }
1668 else if (val)
1669 *val = (unsigned long)v;
1670 return 1;
1671 }
1672
1673
1674 SWIGINTERNSHORT unsigned long
1675 SWIG_As_unsigned_SS_long(PyObject* obj)
1676 {
1677 unsigned long v;
1678 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1679 /*
1680 this is needed to make valgrind/purify happier.
1681 */
1682 memset((void*)&v, 0, sizeof(unsigned long));
1683 }
1684 return v;
1685 }
1686
1687
1688 SWIGINTERNSHORT int
1689 SWIG_Check_unsigned_SS_long(PyObject* obj)
1690 {
1691 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1692 }
1693
1694
1695 SWIGINTERNSHORT PyObject*
1696 SWIG_From_unsigned_SS_long(unsigned long value)
1697 {
1698 return (value > LONG_MAX) ?
1699 PyLong_FromUnsignedLong(value)
1700 : PyInt_FromLong((long)(value));
1701 }
1702
1703
1704 bool wxThread_IsMain() {
1705 #ifdef WXP_WITH_THREAD
1706 return wxThread::IsMain();
1707 #else
1708 return true;
1709 #endif
1710 }
1711
1712 static void wxCaret_Destroy(wxCaret *self){
1713 delete self;
1714 }
1715
1716 #include <wx/snglinst.h>
1717
1718
1719 #ifdef __WXMSW__
1720 #include <wx/msw/private.h>
1721 #include <wx/dynload.h>
1722 #endif
1723
1724
1725
1726 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1727 #if 0
1728 , int method
1729 #endif
1730 )
1731 {
1732 #ifdef __WXMSW__
1733 #if 0
1734 switch (method)
1735 {
1736 case 1:
1737 // This one only partially works. Appears to be an undocumented
1738 // "standard" convention that not all widgets adhear to. For
1739 // example, for some widgets backgrounds or non-client areas may
1740 // not be painted.
1741 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1742 break;
1743
1744 case 2:
1745 #endif
1746 // This one works much better, nearly all widgets and their
1747 // children are captured correctly[**]. Prior to the big
1748 // background erase changes that Vadim did in 2004-2005 this
1749 // method failed badly on XP with Themes activated, most native
1750 // widgets draw only partially, if at all. Without themes it
1751 // worked just like on Win2k. After those changes this method
1752 // works very well.
1753 //
1754 // ** For example the radio buttons in a wxRadioBox are not its
1755 // children by default, but you can capture it via the panel
1756 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1757 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1758 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1759 PRF_ERASEBKGND | PRF_OWNED );
1760 return true;
1761 #if 0
1762 break;
1763
1764 case 3:
1765 // This one is only defined in the latest SDK and is only
1766 // available on XP. MSDN says it is similar to sending WM_PRINT
1767 // so I expect that it will work similar to the above. Since it
1768 // is avaialble only on XP, it can't be compiled like this and
1769 // will have to be loaded dynamically.
1770 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1771
1772 // fall through
1773
1774 case 4:
1775 // Use PrintWindow if available, or fallback to WM_PRINT
1776 // otherwise. Unfortunately using PrintWindow is even worse than
1777 // WM_PRINT. For most native widgets nothing is drawn to the dc
1778 // at all, with or without Themes.
1779 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1780 static bool s_triedToLoad = false;
1781 static PrintWindow_t pfnPrintWindow = NULL;
1782 if ( !s_triedToLoad )
1783 {
1784
1785 s_triedToLoad = true;
1786 wxDynamicLibrary dllUser32(_T("user32.dll"));
1787 if ( dllUser32.IsLoaded() )
1788 {
1789 wxLogNull nolog; // Don't report errors here
1790 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1791 }
1792 }
1793 if (pfnPrintWindow)
1794 {
1795 //printf("Using PrintWindow\n");
1796 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1797 }
1798 else
1799 {
1800 //printf("Using WM_PRINT\n");
1801 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1802 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1803 PRF_ERASEBKGND | PRF_OWNED );
1804 }
1805 }
1806 #endif // 0
1807 #else
1808 return false;
1809 #endif // __WXMSW__
1810 }
1811
1812
1813
1814 #include <wx/tipdlg.h>
1815
1816
1817 class wxPyTipProvider : public wxTipProvider {
1818 public:
1819 wxPyTipProvider(size_t currentTip)
1820 : wxTipProvider(currentTip) {}
1821
1822 DEC_PYCALLBACK_STRING__pure(GetTip);
1823 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1824 PYPRIVATE;
1825 };
1826
1827 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1828 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1829
1830
1831 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1832
1833 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1834
1835 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1836 : wxTimer(owner, id)
1837 {
1838 if (owner == NULL) SetOwner(this);
1839 }
1840
1841
1842 void wxPyTimer::Notify() {
1843 bool found;
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1846 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1847 wxPyEndBlockThreads(blocked);
1848 if (! found)
1849 wxTimer::Notify();
1850 }
1851 void wxPyTimer::base_Notify() {
1852 wxTimer::Notify();
1853 }
1854
1855
1856
1857 SWIGINTERN PyObject *
1858 SWIG_FromCharPtr(const char* cptr)
1859 {
1860 if (cptr) {
1861 size_t size = strlen(cptr);
1862 if (size > INT_MAX) {
1863 return SWIG_NewPointerObj((char*)(cptr),
1864 SWIG_TypeQuery("char *"), 0);
1865 } else {
1866 if (size != 0) {
1867 return PyString_FromStringAndSize(cptr, size);
1868 } else {
1869 return PyString_FromString(cptr);
1870 }
1871 }
1872 }
1873 Py_INCREF(Py_None);
1874 return Py_None;
1875 }
1876
1877
1878 SWIGINTERNSHORT int
1879 SWIG_CheckUnsignedLongInRange(unsigned long value,
1880 unsigned long max_value,
1881 const char *errmsg)
1882 {
1883 if (value > max_value) {
1884 if (errmsg) {
1885 PyErr_Format(PyExc_OverflowError,
1886 "value %lu is greater than '%s' minimum %lu",
1887 value, errmsg, max_value);
1888 }
1889 return 0;
1890 }
1891 return 1;
1892 }
1893
1894
1895 #if UINT_MAX != ULONG_MAX
1896 SWIGINTERN int
1897 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1898 {
1899 const char* errmsg = val ? "unsigned int" : (char*)0;
1900 unsigned long v;
1901 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1902 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1903 if (val) *val = (unsigned int)(v);
1904 return 1;
1905 }
1906 } else {
1907 PyErr_Clear();
1908 }
1909 if (val) {
1910 SWIG_type_error(errmsg, obj);
1911 }
1912 return 0;
1913 }
1914 #else
1915 SWIGINTERNSHORT unsigned int
1916 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1917 {
1918 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1919 }
1920 #endif
1921
1922
1923 SWIGINTERNSHORT unsigned int
1924 SWIG_As_unsigned_SS_int(PyObject* obj)
1925 {
1926 unsigned int v;
1927 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1928 /*
1929 this is needed to make valgrind/purify happier.
1930 */
1931 memset((void*)&v, 0, sizeof(unsigned int));
1932 }
1933 return v;
1934 }
1935
1936
1937 SWIGINTERNSHORT int
1938 SWIG_Check_unsigned_SS_int(PyObject* obj)
1939 {
1940 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1941 }
1942
1943 static wxString Log_TimeStamp(){
1944 wxString msg;
1945 wxLog::TimeStamp(&msg);
1946 return msg;
1947 }
1948 static void wxLog_Destroy(wxLog *self){ delete self; }
1949 // Make somce wrappers that double any % signs so they are 'escaped'
1950 void wxPyLogFatalError(const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogFatalError(m);
1955 }
1956
1957 void wxPyLogError(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogError(m);
1962 }
1963
1964 void wxPyLogWarning(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogWarning(m);
1969 }
1970
1971 void wxPyLogMessage(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogMessage(m);
1976 }
1977
1978 void wxPyLogInfo(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogInfo(m);
1983 }
1984
1985 void wxPyLogDebug(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogDebug(m);
1990 }
1991
1992 void wxPyLogVerbose(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogVerbose(m);
1997 }
1998
1999 void wxPyLogStatus(const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogStatus(m);
2004 }
2005
2006 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogStatus(pFrame, m);
2011 }
2012
2013 void wxPyLogSysError(const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogSysError(m);
2018 }
2019
2020 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogGeneric(level, m);
2025 }
2026
2027 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogTrace(mask, m);
2032 }
2033
2034 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2035 {
2036 wxString m(msg);
2037 m.Replace(wxT("%"), wxT("%%"));
2038 wxLogTrace(mask, m);
2039 }
2040
2041
2042
2043 // A wxLog class that can be derived from in wxPython
2044 class wxPyLog : public wxLog {
2045 public:
2046 wxPyLog() : wxLog() {}
2047
2048 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2049 bool found;
2050 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2051 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2052 PyObject* s = wx2PyString(szString);
2053 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2054 Py_DECREF(s);
2055 }
2056 wxPyEndBlockThreads(blocked);
2057 if (! found)
2058 wxLog::DoLog(level, szString, t);
2059 }
2060
2061 virtual void DoLogString(const wxChar *szString, time_t t) {
2062 bool found;
2063 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2064 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2065 PyObject* s = wx2PyString(szString);
2066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2067 Py_DECREF(s);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 if (! found)
2071 wxLog::DoLogString(szString, t);
2072 }
2073
2074 PYPRIVATE;
2075 };
2076
2077
2078
2079
2080 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2081
2082
2083 #include <wx/joystick.h>
2084
2085
2086 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2087 // A C++ stub class for wxJoystick for platforms that don't have it.
2088 class wxJoystick : public wxObject {
2089 public:
2090 wxJoystick(int joystick = wxJOYSTICK1) {
2091 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2092 PyErr_SetString(PyExc_NotImplementedError,
2093 "wxJoystick is not available on this platform.");
2094 wxPyEndBlockThreads(blocked);
2095 }
2096 wxPoint GetPosition() { return wxPoint(-1,-1); }
2097 int GetZPosition() { return -1; }
2098 int GetButtonState() { return -1; }
2099 int GetPOVPosition() { return -1; }
2100 int GetPOVCTSPosition() { return -1; }
2101 int GetRudderPosition() { return -1; }
2102 int GetUPosition() { return -1; }
2103 int GetVPosition() { return -1; }
2104 int GetMovementThreshold() { return -1; }
2105 void SetMovementThreshold(int threshold) {}
2106
2107 bool IsOk(void) { return false; }
2108 int GetNumberJoysticks() { return -1; }
2109 int GetManufacturerId() { return -1; }
2110 int GetProductId() { return -1; }
2111 wxString GetProductName() { return wxEmptyString; }
2112 int GetXMin() { return -1; }
2113 int GetYMin() { return -1; }
2114 int GetZMin() { return -1; }
2115 int GetXMax() { return -1; }
2116 int GetYMax() { return -1; }
2117 int GetZMax() { return -1; }
2118 int GetNumberButtons() { return -1; }
2119 int GetNumberAxes() { return -1; }
2120 int GetMaxButtons() { return -1; }
2121 int GetMaxAxes() { return -1; }
2122 int GetPollingMin() { return -1; }
2123 int GetPollingMax() { return -1; }
2124 int GetRudderMin() { return -1; }
2125 int GetRudderMax() { return -1; }
2126 int GetUMin() { return -1; }
2127 int GetUMax() { return -1; }
2128 int GetVMin() { return -1; }
2129 int GetVMax() { return -1; }
2130
2131 bool HasRudder() { return false; }
2132 bool HasZ() { return false; }
2133 bool HasU() { return false; }
2134 bool HasV() { return false; }
2135 bool HasPOV() { return false; }
2136 bool HasPOV4Dir() { return false; }
2137 bool HasPOVCTS() { return false; }
2138
2139 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2140 bool ReleaseCapture() { return false; }
2141 };
2142 #endif
2143
2144
2145 #include <wx/sound.h>
2146
2147
2148 #if !wxUSE_SOUND
2149 // A C++ stub class for wxWave for platforms that don't have it.
2150 class wxSound : public wxObject
2151 {
2152 public:
2153 wxSound() {
2154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2155 PyErr_SetString(PyExc_NotImplementedError,
2156 "wxSound is not available on this platform.");
2157 wxPyEndBlockThreads(blocked);
2158 }
2159 wxSound(const wxString&/*, bool*/) {
2160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(int, const wxByte*) {
2166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171
2172 ~wxSound() {};
2173
2174 bool Create(const wxString&/*, bool*/) { return false; }
2175 bool Create(int, const wxByte*) { return false; };
2176 bool IsOk() { return false; };
2177 bool Play(unsigned) const { return false; }
2178 static bool Play(const wxString&, unsigned) { return false; }
2179 static void Stop() {}
2180 };
2181
2182 #endif
2183
2184 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2185 if (fileName.Length() == 0)
2186 return new wxSound;
2187 else
2188 return new wxSound(fileName);
2189 }
2190 static wxSound *new_wxSound(PyObject *data){
2191 unsigned char* buffer; int size;
2192 wxSound *sound = NULL;
2193
2194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2195 if (!PyArg_Parse(data, "t#", &buffer, &size))
2196 goto done;
2197 sound = new wxSound(size, buffer);
2198 done:
2199 wxPyEndBlockThreads(blocked);
2200 return sound;
2201 }
2202 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2203 #ifndef __WXMAC__
2204 unsigned char* buffer;
2205 int size;
2206 bool rv = false;
2207
2208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2209 if (!PyArg_Parse(data, "t#", &buffer, &size))
2210 goto done;
2211 rv = self->Create(size, buffer);
2212 done:
2213 wxPyEndBlockThreads(blocked);
2214 return rv;
2215 #else
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 PyErr_SetString(PyExc_NotImplementedError,
2218 "Create from data is not available on this platform.");
2219 wxPyEndBlockThreads(blocked);
2220 return false;
2221 #endif
2222 }
2223
2224 #include <wx/mimetype.h>
2225
2226 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2227 wxString str;
2228 if (self->GetMimeType(&str))
2229 return wx2PyString(str);
2230 else
2231 RETURN_NONE();
2232 }
2233 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2234 wxArrayString arr;
2235 if (self->GetMimeTypes(arr))
2236 return wxArrayString2PyList_helper(arr);
2237 else
2238 RETURN_NONE();
2239 }
2240 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2241 wxArrayString arr;
2242 if (self->GetExtensions(arr))
2243 return wxArrayString2PyList_helper(arr);
2244 else
2245 RETURN_NONE();
2246 }
2247 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2248 wxIconLocation loc;
2249 if (self->GetIcon(&loc))
2250 return new wxIcon(loc);
2251 else
2252 return NULL;
2253 }
2254 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2255 wxIconLocation loc;
2256 if (self->GetIcon(&loc)) {
2257 wxString iconFile = loc.GetFileName();
2258 int iconIndex = -1;
2259
2260 iconIndex = loc.GetIndex();
2261
2262 // Make a tuple and put the values in it
2263 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2264 PyObject* tuple = PyTuple_New(3);
2265 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2266 wxT("wxIcon"), true));
2267 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2268 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2269 wxPyEndBlockThreads(blocked);
2270 return tuple;
2271 }
2272 else
2273 RETURN_NONE();
2274 }
2275 static PyObject *wxFileType_GetDescription(wxFileType *self){
2276 wxString str;
2277 if (self->GetDescription(&str))
2278 return wx2PyString(str);
2279 else
2280 RETURN_NONE();
2281 }
2282 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2283 wxString str;
2284 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2285 return wx2PyString(str);
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2290 wxString str;
2291 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2292 return wx2PyString(str);
2293 else
2294 RETURN_NONE();
2295 }
2296 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2297 wxArrayString verbs;
2298 wxArrayString commands;
2299 if (self->GetAllCommands(&verbs, &commands,
2300 wxFileType::MessageParameters(filename, mimetype))) {
2301 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2302 PyObject* tuple = PyTuple_New(2);
2303 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2304 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2305 wxPyEndBlockThreads(blocked);
2306 return tuple;
2307 }
2308 else
2309 RETURN_NONE();
2310 }
2311 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2312 return wxFileType::ExpandCommand(command,
2313 wxFileType::MessageParameters(filename, mimetype));
2314 }
2315 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2316 wxArrayString arr;
2317 self->EnumAllFileTypes(arr);
2318 return wxArrayString2PyList_helper(arr);
2319 }
2320
2321 #include <wx/artprov.h>
2322
2323 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2324 static const wxString wxPyART_MENU(wxART_MENU);
2325 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2326 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2327 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2328 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2329 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2330 static const wxString wxPyART_OTHER(wxART_OTHER);
2331 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2332 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2333 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2334 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2335 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2336 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2337 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2338 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2339 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2340 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2341 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2342 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2343 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2344 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2345 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2346 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2347 static const wxString wxPyART_PRINT(wxART_PRINT);
2348 static const wxString wxPyART_HELP(wxART_HELP);
2349 static const wxString wxPyART_TIP(wxART_TIP);
2350 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2351 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2352 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2353 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2354 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2355 static const wxString wxPyART_CDROM(wxART_CDROM);
2356 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2357 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2358 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2359 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2360 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2361 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2362 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2363 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2364 static const wxString wxPyART_ERROR(wxART_ERROR);
2365 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2366 static const wxString wxPyART_WARNING(wxART_WARNING);
2367 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2368 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2369 static const wxString wxPyART_COPY(wxART_COPY);
2370 static const wxString wxPyART_CUT(wxART_CUT);
2371 static const wxString wxPyART_PASTE(wxART_PASTE);
2372 static const wxString wxPyART_DELETE(wxART_DELETE);
2373 static const wxString wxPyART_UNDO(wxART_UNDO);
2374 static const wxString wxPyART_REDO(wxART_REDO);
2375 static const wxString wxPyART_QUIT(wxART_QUIT);
2376 static const wxString wxPyART_FIND(wxART_FIND);
2377 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2378 // Python aware wxArtProvider
2379 class wxPyArtProvider : public wxArtProvider {
2380 public:
2381
2382 virtual wxBitmap CreateBitmap(const wxArtID& id,
2383 const wxArtClient& client,
2384 const wxSize& size) {
2385 wxBitmap rval = wxNullBitmap;
2386 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2387 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2388 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2389 PyObject* ro;
2390 wxBitmap* ptr;
2391 PyObject* s1, *s2;
2392 s1 = wx2PyString(id);
2393 s2 = wx2PyString(client);
2394 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2395 Py_DECREF(so);
2396 Py_DECREF(s1);
2397 Py_DECREF(s2);
2398 if (ro) {
2399 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2400 rval = *ptr;
2401 Py_DECREF(ro);
2402 }
2403 }
2404 wxPyEndBlockThreads(blocked);
2405 return rval;
2406 }
2407
2408 PYPRIVATE;
2409 };
2410
2411 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2412
2413
2414
2415 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2416 PyObject* ret = PyTuple_New(3);
2417 if (ret) {
2418 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2419 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2420 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2421 }
2422 return ret;
2423 }
2424
2425 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2426 bool cont;
2427 long index = 0;
2428 wxString value;
2429
2430 cont = self->GetFirstGroup(value, index);
2431 return __EnumerationHelper(cont, value, index);
2432 }
2433 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2434 bool cont;
2435 wxString value;
2436
2437 cont = self->GetNextGroup(value, index);
2438 return __EnumerationHelper(cont, value, index);
2439 }
2440 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2441 bool cont;
2442 long index = 0;
2443 wxString value;
2444
2445 cont = self->GetFirstEntry(value, index);
2446 return __EnumerationHelper(cont, value, index);
2447 }
2448 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2449 bool cont;
2450 wxString value;
2451
2452 cont = self->GetNextEntry(value, index);
2453 return __EnumerationHelper(cont, value, index);
2454 }
2455 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2456 long rv;
2457 self->Read(key, &rv, defaultVal);
2458 return rv;
2459 }
2460
2461 SWIGINTERN int
2462 SWIG_AsVal_double(PyObject *obj, double* val)
2463 {
2464 if (PyNumber_Check(obj)) {
2465 if (val) *val = PyFloat_AsDouble(obj);
2466 return 1;
2467 }
2468 else {
2469 SWIG_type_error("number", obj);
2470 }
2471 return 0;
2472 }
2473
2474
2475 SWIGINTERNSHORT double
2476 SWIG_As_double(PyObject* obj)
2477 {
2478 double v;
2479 if (!SWIG_AsVal_double(obj, &v)) {
2480 /*
2481 this is needed to make valgrind/purify happier.
2482 */
2483 memset((void*)&v, 0, sizeof(double));
2484 }
2485 return v;
2486 }
2487
2488
2489 SWIGINTERNSHORT int
2490 SWIG_Check_double(PyObject* obj)
2491 {
2492 return SWIG_AsVal_double(obj, (double*)0);
2493 }
2494
2495 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2496 double rv;
2497 self->Read(key, &rv, defaultVal);
2498 return rv;
2499 }
2500
2501 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2502 #define SWIG_From_double PyFloat_FromDouble
2503 /*@@*/
2504
2505 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2506 bool rv;
2507 self->Read(key, &rv, defaultVal);
2508 return rv;
2509 }
2510
2511 #include <wx/datetime.h>
2512
2513 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2514 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2515
2516 #define LOCAL_TZ wxDateTime::Local
2517
2518 static PyObject *DateTime_GetAmPmStrings(){
2519 wxString am;
2520 wxString pm;
2521 wxDateTime::GetAmPmStrings(&am, &pm);
2522 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2523 PyObject* tup = PyTuple_New(2);
2524 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2525 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2526 wxPyEndBlockThreads(blocked);
2527 return tup;
2528 }
2529
2530 #if UINT_MAX < LONG_MAX
2531 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2532 #define SWIG_From_unsigned_SS_int SWIG_From_long
2533 /*@@*/
2534 #else
2535 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2536 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2537 /*@@*/
2538 #endif
2539
2540 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2541 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2542 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2543 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2544 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2545 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2546 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2547 return (*self < *other);
2548 }
2549 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2550 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2551 return (*self <= *other);
2552 }
2553 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2554 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2555 return (*self > *other);
2556 }
2557 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2558 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2559 return (*self >= *other);
2560 }
2561 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2562 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2563 return (*self == *other);
2564 }
2565 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2566 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2567 return (*self != *other);
2568 }
2569 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2570 const wxChar* rv;
2571 const wxChar* _date = date;
2572 rv = self->ParseRfc822Date(_date);
2573 if (rv == NULL) return -1;
2574 return rv - _date;
2575 }
2576 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2577 const wxChar* rv;
2578 const wxChar* _date = date;
2579 rv = self->ParseFormat(_date, format, dateDef);
2580 if (rv == NULL) return -1;
2581 return rv - _date;
2582 }
2583 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2584 const wxChar* rv;
2585 const wxChar* _datetime = datetime;
2586 rv = self->ParseDateTime(_datetime);
2587 if (rv == NULL) return -1;
2588 return rv - _datetime;
2589 }
2590 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2591 const wxChar* rv;
2592 const wxChar* _date = date;
2593 rv = self->ParseDate(_date);
2594 if (rv == NULL) return -1;
2595 return rv - _date;
2596 }
2597 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2598 const wxChar* rv;
2599 const wxChar* _time = time;
2600 rv = self->ParseTime(_time);
2601 if (rv == NULL) return -1;
2602 return rv - _time;
2603 }
2604 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2605 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2606 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2607 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2608 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2609 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2610 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2611 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2612 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2613 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2614 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2615 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2616 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2617 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2618 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2619 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2620
2621 #include <wx/dataobj.h>
2622
2623 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2624 size_t count = self->GetFormatCount(dir);
2625 wxDataFormat* formats = new wxDataFormat[count];
2626 self->GetAllFormats(formats, dir);
2627
2628 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2629 PyObject* list = PyList_New(count);
2630 for (size_t i=0; i<count; i++) {
2631 wxDataFormat* format = new wxDataFormat(formats[i]);
2632 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2633 PyList_Append(list, obj);
2634 Py_DECREF(obj);
2635 }
2636 wxPyEndBlockThreads(blocked);
2637 delete [] formats;
2638 return list;
2639 }
2640 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2641 PyObject* rval = NULL;
2642 size_t size = self->GetDataSize(format);
2643 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2644 if (size) {
2645 char* buf = new char[size];
2646 if (self->GetDataHere(format, buf))
2647 rval = PyString_FromStringAndSize(buf, size);
2648 delete [] buf;
2649 }
2650 if (! rval) {
2651 rval = Py_None;
2652 Py_INCREF(rval);
2653 }
2654 wxPyEndBlockThreads(blocked);
2655 return rval;
2656 }
2657 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2658 bool rval;
2659 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2660 if (PyString_Check(data)) {
2661 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2662 }
2663 else {
2664 // raise a TypeError if not a string
2665 PyErr_SetString(PyExc_TypeError, "String expected.");
2666 rval = false;
2667 }
2668 wxPyEndBlockThreads(blocked);
2669 return rval;
2670 }
2671 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2672 PyObject* rval = NULL;
2673 size_t size = self->GetDataSize();
2674 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2675 if (size) {
2676 char* buf = new char[size];
2677 if (self->GetDataHere(buf))
2678 rval = PyString_FromStringAndSize(buf, size);
2679 delete [] buf;
2680 }
2681 if (! rval) {
2682 rval = Py_None;
2683 Py_INCREF(rval);
2684 }
2685 wxPyEndBlockThreads(blocked);
2686 return rval;
2687 }
2688 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2689 bool rval;
2690 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2691 if (PyString_Check(data)) {
2692 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2693 }
2694 else {
2695 // raise a TypeError if not a string
2696 PyErr_SetString(PyExc_TypeError, "String expected.");
2697 rval = false;
2698 }
2699 wxPyEndBlockThreads(blocked);
2700 return rval;
2701 }
2702 // Create a new class for wxPython to use
2703 class wxPyDataObjectSimple : public wxDataObjectSimple {
2704 public:
2705 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2706 : wxDataObjectSimple(format) {}
2707
2708 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2709 bool GetDataHere(void *buf) const;
2710 bool SetData(size_t len, const void *buf) const;
2711 PYPRIVATE;
2712 };
2713
2714 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2715
2716 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2717 // We need to get the data for this object and write it to buf. I think
2718 // the best way to do this for wxPython is to have the Python method
2719 // return either a string or None and then act appropriately with the
2720 // C++ version.
2721
2722 bool rval = false;
2723 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2724 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2725 PyObject* ro;
2726 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2727 if (ro) {
2728 rval = (ro != Py_None && PyString_Check(ro));
2729 if (rval)
2730 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2731 Py_DECREF(ro);
2732 }
2733 }
2734 wxPyEndBlockThreads(blocked);
2735 return rval;
2736 }
2737
2738 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2739 // For this one we simply need to make a string from buf and len
2740 // and send it to the Python method.
2741 bool rval = false;
2742 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2743 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2744 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2745 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2746 Py_DECREF(data);
2747 }
2748 wxPyEndBlockThreads(blocked);
2749 return rval;
2750 }
2751
2752 // Create a new class for wxPython to use
2753 class wxPyTextDataObject : public wxTextDataObject {
2754 public:
2755 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2756 : wxTextDataObject(text) {}
2757
2758 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2759 DEC_PYCALLBACK_STRING__const(GetText);
2760 DEC_PYCALLBACK__STRING(SetText);
2761 PYPRIVATE;
2762 };
2763
2764 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2765 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2766 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2767
2768
2769 // Create a new class for wxPython to use
2770 class wxPyBitmapDataObject : public wxBitmapDataObject {
2771 public:
2772 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2773 : wxBitmapDataObject(bitmap) {}
2774
2775 wxBitmap GetBitmap() const;
2776 void SetBitmap(const wxBitmap& bitmap);
2777 PYPRIVATE;
2778 };
2779
2780 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2781 wxBitmap* rval = &wxNullBitmap;
2782 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2783 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2784 PyObject* ro;
2785 wxBitmap* ptr;
2786 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2787 if (ro) {
2788 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2789 rval = ptr;
2790 Py_DECREF(ro);
2791 }
2792 }
2793 wxPyEndBlockThreads(blocked);
2794 return *rval;
2795 }
2796
2797 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2798 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2799 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2800 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2801 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2802 Py_DECREF(bo);
2803 }
2804 wxPyEndBlockThreads(blocked);
2805 }
2806
2807 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2808 return new wxCustomDataObject(wxDataFormat(formatName));
2809 }
2810 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2811 bool rval;
2812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2813 if (PyString_Check(data)) {
2814 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2815 }
2816 else {
2817 // raise a TypeError if not a string
2818 PyErr_SetString(PyExc_TypeError, "String expected.");
2819 rval = false;
2820 }
2821 wxPyEndBlockThreads(blocked);
2822 return rval;
2823 }
2824 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2825 PyObject* obj;
2826 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2827 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2828 wxPyEndBlockThreads(blocked);
2829 return obj;
2830 }
2831
2832 #include <wx/metafile.h>
2833
2834
2835 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2836
2837
2838 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2839 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2840 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2841 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2842 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2843
2844
2845 class wxPyTextDropTarget : public wxTextDropTarget {
2846 public:
2847 wxPyTextDropTarget() {}
2848
2849 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2850
2851 DEC_PYCALLBACK__(OnLeave);
2852 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2853 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2854 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2855 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2856
2857 PYPRIVATE;
2858 };
2859
2860 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2861 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2862 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2864 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2865 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2866
2867
2868
2869 class wxPyFileDropTarget : public wxFileDropTarget {
2870 public:
2871 wxPyFileDropTarget() {}
2872
2873 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2874
2875 DEC_PYCALLBACK__(OnLeave);
2876 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2878 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2879 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2880
2881 PYPRIVATE;
2882 };
2883
2884 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2885 const wxArrayString& filenames) {
2886 bool rval = false;
2887 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2888 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2889 PyObject* list = wxArrayString2PyList_helper(filenames);
2890 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2891 Py_DECREF(list);
2892 }
2893 wxPyEndBlockThreads(blocked);
2894 return rval;
2895 }
2896
2897
2898
2899 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2900 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2901 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2902 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2903 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2904
2905
2906
2907
2908 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2909
2910 #include <wx/display.h>
2911
2912 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2913 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2914
2915 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2916 #if !wxUSE_DISPLAY
2917 #include <wx/dynarray.h>
2918 #include <wx/vidmode.h>
2919
2920 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2921 #include "wx/arrimpl.cpp"
2922 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2923 const wxVideoMode wxDefaultVideoMode;
2924
2925 class wxDisplay
2926 {
2927 public:
2928 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2929 ~wxDisplay() {}
2930
2931 static size_t GetCount()
2932 { wxPyRaiseNotImplemented(); return 0; }
2933
2934 static int GetFromPoint(const wxPoint& pt)
2935 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2936 static int GetFromWindow(wxWindow *window)
2937 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2938
2939 virtual bool IsOk() const { return false; }
2940 virtual wxRect GetGeometry() const { wxRect r; return r; }
2941 virtual wxString GetName() const { return wxEmptyString; }
2942 bool IsPrimary() const { return false; }
2943
2944 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2945 { wxArrayVideoModes a; return a; }
2946
2947 virtual wxVideoMode GetCurrentMode() const
2948 { return wxDefaultVideoMode; }
2949
2950 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2951 { return false; }
2952
2953 void ResetMode() {}
2954 };
2955 #endif
2956
2957 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2958 PyObject* pyList = NULL;
2959 wxArrayVideoModes arr = self->GetModes(mode);
2960 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2961 pyList = PyList_New(0);
2962 for (int i=0; i < arr.GetCount(); i++) {
2963 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2964 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2965 PyList_Append(pyList, pyObj);
2966 Py_DECREF(pyObj);
2967 }
2968 wxPyEndBlockThreads(blocked);
2969 return pyList;
2970 }
2971
2972 #include <wx/stdpaths.h>
2973
2974 static wxStandardPaths *StandardPaths_Get(){
2975 return (wxStandardPaths*) &wxStandardPaths::Get();
2976 }
2977 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2978 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2979 #ifdef __cplusplus
2980 extern "C" {
2981 #endif
2982 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2983 PyObject *resultobj;
2984 wxSystemColour arg1 ;
2985 wxColour result;
2986 PyObject * obj0 = 0 ;
2987 char *kwnames[] = {
2988 (char *) "index", NULL
2989 };
2990
2991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2992 {
2993 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2994 if (SWIG_arg_fail(1)) SWIG_fail;
2995 }
2996 {
2997 if (!wxPyCheckForApp()) SWIG_fail;
2998 PyThreadState* __tstate = wxPyBeginAllowThreads();
2999 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3000
3001 wxPyEndAllowThreads(__tstate);
3002 if (PyErr_Occurred()) SWIG_fail;
3003 }
3004 {
3005 wxColour * resultptr;
3006 resultptr = new wxColour((wxColour &)(result));
3007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3008 }
3009 return resultobj;
3010 fail:
3011 return NULL;
3012 }
3013
3014
3015 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3016 PyObject *resultobj;
3017 wxSystemFont arg1 ;
3018 wxFont result;
3019 PyObject * obj0 = 0 ;
3020 char *kwnames[] = {
3021 (char *) "index", NULL
3022 };
3023
3024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3025 {
3026 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3027 if (SWIG_arg_fail(1)) SWIG_fail;
3028 }
3029 {
3030 if (!wxPyCheckForApp()) SWIG_fail;
3031 PyThreadState* __tstate = wxPyBeginAllowThreads();
3032 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3033
3034 wxPyEndAllowThreads(__tstate);
3035 if (PyErr_Occurred()) SWIG_fail;
3036 }
3037 {
3038 wxFont * resultptr;
3039 resultptr = new wxFont((wxFont &)(result));
3040 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3041 }
3042 return resultobj;
3043 fail:
3044 return NULL;
3045 }
3046
3047
3048 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3049 PyObject *resultobj;
3050 wxSystemMetric arg1 ;
3051 wxWindow *arg2 = (wxWindow *) NULL ;
3052 int result;
3053 PyObject * obj0 = 0 ;
3054 PyObject * obj1 = 0 ;
3055 char *kwnames[] = {
3056 (char *) "index",(char *) "win", NULL
3057 };
3058
3059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3060 {
3061 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3062 if (SWIG_arg_fail(1)) SWIG_fail;
3063 }
3064 if (obj1) {
3065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3066 if (SWIG_arg_fail(2)) SWIG_fail;
3067 }
3068 {
3069 if (!wxPyCheckForApp()) SWIG_fail;
3070 PyThreadState* __tstate = wxPyBeginAllowThreads();
3071 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3072
3073 wxPyEndAllowThreads(__tstate);
3074 if (PyErr_Occurred()) SWIG_fail;
3075 }
3076 {
3077 resultobj = SWIG_From_int((int)(result));
3078 }
3079 return resultobj;
3080 fail:
3081 return NULL;
3082 }
3083
3084
3085 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3086 PyObject *resultobj;
3087 wxSystemFeature arg1 ;
3088 bool result;
3089 PyObject * obj0 = 0 ;
3090 char *kwnames[] = {
3091 (char *) "index", NULL
3092 };
3093
3094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3095 {
3096 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3097 if (SWIG_arg_fail(1)) SWIG_fail;
3098 }
3099 {
3100 if (!wxPyCheckForApp()) SWIG_fail;
3101 PyThreadState* __tstate = wxPyBeginAllowThreads();
3102 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3103
3104 wxPyEndAllowThreads(__tstate);
3105 if (PyErr_Occurred()) SWIG_fail;
3106 }
3107 {
3108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3109 }
3110 return resultobj;
3111 fail:
3112 return NULL;
3113 }
3114
3115
3116 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3117 PyObject *resultobj;
3118 wxSystemScreenType result;
3119 char *kwnames[] = {
3120 NULL
3121 };
3122
3123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3124 {
3125 if (!wxPyCheckForApp()) SWIG_fail;
3126 PyThreadState* __tstate = wxPyBeginAllowThreads();
3127 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3128
3129 wxPyEndAllowThreads(__tstate);
3130 if (PyErr_Occurred()) SWIG_fail;
3131 }
3132 resultobj = SWIG_From_int((result));
3133 return resultobj;
3134 fail:
3135 return NULL;
3136 }
3137
3138
3139 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3140 PyObject *resultobj;
3141 wxSystemScreenType arg1 ;
3142 PyObject * obj0 = 0 ;
3143 char *kwnames[] = {
3144 (char *) "screen", NULL
3145 };
3146
3147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3148 {
3149 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3150 if (SWIG_arg_fail(1)) SWIG_fail;
3151 }
3152 {
3153 if (!wxPyCheckForApp()) SWIG_fail;
3154 PyThreadState* __tstate = wxPyBeginAllowThreads();
3155 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3156
3157 wxPyEndAllowThreads(__tstate);
3158 if (PyErr_Occurred()) SWIG_fail;
3159 }
3160 Py_INCREF(Py_None); resultobj = Py_None;
3161 return resultobj;
3162 fail:
3163 return NULL;
3164 }
3165
3166
3167 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3168 PyObject *obj;
3169 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3170 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3171 Py_INCREF(obj);
3172 return Py_BuildValue((char *)"");
3173 }
3174 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3175 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3176 return 1;
3177 }
3178
3179
3180 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3181 PyObject *pyobj;
3182
3183 {
3184 #if wxUSE_UNICODE
3185 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3186 #else
3187 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3188 #endif
3189 }
3190 return pyobj;
3191 }
3192
3193
3194 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3195 PyObject *resultobj;
3196 wxSystemOptions *result;
3197 char *kwnames[] = {
3198 NULL
3199 };
3200
3201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3202 {
3203 PyThreadState* __tstate = wxPyBeginAllowThreads();
3204 result = (wxSystemOptions *)new wxSystemOptions();
3205
3206 wxPyEndAllowThreads(__tstate);
3207 if (PyErr_Occurred()) SWIG_fail;
3208 }
3209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3210 return resultobj;
3211 fail:
3212 return NULL;
3213 }
3214
3215
3216 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3217 PyObject *resultobj;
3218 wxString *arg1 = 0 ;
3219 wxString *arg2 = 0 ;
3220 bool temp1 = false ;
3221 bool temp2 = false ;
3222 PyObject * obj0 = 0 ;
3223 PyObject * obj1 = 0 ;
3224 char *kwnames[] = {
3225 (char *) "name",(char *) "value", NULL
3226 };
3227
3228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3229 {
3230 arg1 = wxString_in_helper(obj0);
3231 if (arg1 == NULL) SWIG_fail;
3232 temp1 = true;
3233 }
3234 {
3235 arg2 = wxString_in_helper(obj1);
3236 if (arg2 == NULL) SWIG_fail;
3237 temp2 = true;
3238 }
3239 {
3240 PyThreadState* __tstate = wxPyBeginAllowThreads();
3241 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3242
3243 wxPyEndAllowThreads(__tstate);
3244 if (PyErr_Occurred()) SWIG_fail;
3245 }
3246 Py_INCREF(Py_None); resultobj = Py_None;
3247 {
3248 if (temp1)
3249 delete arg1;
3250 }
3251 {
3252 if (temp2)
3253 delete arg2;
3254 }
3255 return resultobj;
3256 fail:
3257 {
3258 if (temp1)
3259 delete arg1;
3260 }
3261 {
3262 if (temp2)
3263 delete arg2;
3264 }
3265 return NULL;
3266 }
3267
3268
3269 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3270 PyObject *resultobj;
3271 wxString *arg1 = 0 ;
3272 int arg2 ;
3273 bool temp1 = false ;
3274 PyObject * obj0 = 0 ;
3275 PyObject * obj1 = 0 ;
3276 char *kwnames[] = {
3277 (char *) "name",(char *) "value", NULL
3278 };
3279
3280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3281 {
3282 arg1 = wxString_in_helper(obj0);
3283 if (arg1 == NULL) SWIG_fail;
3284 temp1 = true;
3285 }
3286 {
3287 arg2 = (int)(SWIG_As_int(obj1));
3288 if (SWIG_arg_fail(2)) SWIG_fail;
3289 }
3290 {
3291 PyThreadState* __tstate = wxPyBeginAllowThreads();
3292 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3293
3294 wxPyEndAllowThreads(__tstate);
3295 if (PyErr_Occurred()) SWIG_fail;
3296 }
3297 Py_INCREF(Py_None); resultobj = Py_None;
3298 {
3299 if (temp1)
3300 delete arg1;
3301 }
3302 return resultobj;
3303 fail:
3304 {
3305 if (temp1)
3306 delete arg1;
3307 }
3308 return NULL;
3309 }
3310
3311
3312 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3313 PyObject *resultobj;
3314 wxString *arg1 = 0 ;
3315 wxString result;
3316 bool temp1 = false ;
3317 PyObject * obj0 = 0 ;
3318 char *kwnames[] = {
3319 (char *) "name", NULL
3320 };
3321
3322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3323 {
3324 arg1 = wxString_in_helper(obj0);
3325 if (arg1 == NULL) SWIG_fail;
3326 temp1 = true;
3327 }
3328 {
3329 PyThreadState* __tstate = wxPyBeginAllowThreads();
3330 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3331
3332 wxPyEndAllowThreads(__tstate);
3333 if (PyErr_Occurred()) SWIG_fail;
3334 }
3335 {
3336 #if wxUSE_UNICODE
3337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3338 #else
3339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3340 #endif
3341 }
3342 {
3343 if (temp1)
3344 delete arg1;
3345 }
3346 return resultobj;
3347 fail:
3348 {
3349 if (temp1)
3350 delete arg1;
3351 }
3352 return NULL;
3353 }
3354
3355
3356 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3357 PyObject *resultobj;
3358 wxString *arg1 = 0 ;
3359 int result;
3360 bool temp1 = false ;
3361 PyObject * obj0 = 0 ;
3362 char *kwnames[] = {
3363 (char *) "name", NULL
3364 };
3365
3366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3367 {
3368 arg1 = wxString_in_helper(obj0);
3369 if (arg1 == NULL) SWIG_fail;
3370 temp1 = true;
3371 }
3372 {
3373 PyThreadState* __tstate = wxPyBeginAllowThreads();
3374 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3375
3376 wxPyEndAllowThreads(__tstate);
3377 if (PyErr_Occurred()) SWIG_fail;
3378 }
3379 {
3380 resultobj = SWIG_From_int((int)(result));
3381 }
3382 {
3383 if (temp1)
3384 delete arg1;
3385 }
3386 return resultobj;
3387 fail:
3388 {
3389 if (temp1)
3390 delete arg1;
3391 }
3392 return NULL;
3393 }
3394
3395
3396 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3397 PyObject *resultobj;
3398 wxString *arg1 = 0 ;
3399 bool result;
3400 bool temp1 = false ;
3401 PyObject * obj0 = 0 ;
3402 char *kwnames[] = {
3403 (char *) "name", NULL
3404 };
3405
3406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3407 {
3408 arg1 = wxString_in_helper(obj0);
3409 if (arg1 == NULL) SWIG_fail;
3410 temp1 = true;
3411 }
3412 {
3413 PyThreadState* __tstate = wxPyBeginAllowThreads();
3414 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3415
3416 wxPyEndAllowThreads(__tstate);
3417 if (PyErr_Occurred()) SWIG_fail;
3418 }
3419 {
3420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3421 }
3422 {
3423 if (temp1)
3424 delete arg1;
3425 }
3426 return resultobj;
3427 fail:
3428 {
3429 if (temp1)
3430 delete arg1;
3431 }
3432 return NULL;
3433 }
3434
3435
3436 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3437 PyObject *resultobj;
3438 wxString *arg1 = 0 ;
3439 bool result;
3440 bool temp1 = false ;
3441 PyObject * obj0 = 0 ;
3442 char *kwnames[] = {
3443 (char *) "name", NULL
3444 };
3445
3446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3447 {
3448 arg1 = wxString_in_helper(obj0);
3449 if (arg1 == NULL) SWIG_fail;
3450 temp1 = true;
3451 }
3452 {
3453 PyThreadState* __tstate = wxPyBeginAllowThreads();
3454 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3455
3456 wxPyEndAllowThreads(__tstate);
3457 if (PyErr_Occurred()) SWIG_fail;
3458 }
3459 {
3460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3461 }
3462 {
3463 if (temp1)
3464 delete arg1;
3465 }
3466 return resultobj;
3467 fail:
3468 {
3469 if (temp1)
3470 delete arg1;
3471 }
3472 return NULL;
3473 }
3474
3475
3476 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3477 PyObject *obj;
3478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3479 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3480 Py_INCREF(obj);
3481 return Py_BuildValue((char *)"");
3482 }
3483 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3484 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3485 return 1;
3486 }
3487
3488
3489 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3490 PyObject *pyobj;
3491
3492 {
3493 #if wxUSE_UNICODE
3494 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3495 #else
3496 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3497 #endif
3498 }
3499 return pyobj;
3500 }
3501
3502
3503 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3504 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3505 return 1;
3506 }
3507
3508
3509 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3510 PyObject *pyobj;
3511
3512 {
3513 #if wxUSE_UNICODE
3514 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3515 #else
3516 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3517 #endif
3518 }
3519 return pyobj;
3520 }
3521
3522
3523 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3524 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3525 return 1;
3526 }
3527
3528
3529 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3530 PyObject *pyobj;
3531
3532 {
3533 #if wxUSE_UNICODE
3534 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3535 #else
3536 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3537 #endif
3538 }
3539 return pyobj;
3540 }
3541
3542
3543 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3544 PyObject *resultobj;
3545 long result;
3546 char *kwnames[] = {
3547 NULL
3548 };
3549
3550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3551 {
3552 PyThreadState* __tstate = wxPyBeginAllowThreads();
3553 result = (long)wxNewId();
3554
3555 wxPyEndAllowThreads(__tstate);
3556 if (PyErr_Occurred()) SWIG_fail;
3557 }
3558 {
3559 resultobj = SWIG_From_long((long)(result));
3560 }
3561 return resultobj;
3562 fail:
3563 return NULL;
3564 }
3565
3566
3567 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3568 PyObject *resultobj;
3569 long arg1 ;
3570 PyObject * obj0 = 0 ;
3571 char *kwnames[] = {
3572 (char *) "id", NULL
3573 };
3574
3575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3576 {
3577 arg1 = (long)(SWIG_As_long(obj0));
3578 if (SWIG_arg_fail(1)) SWIG_fail;
3579 }
3580 {
3581 PyThreadState* __tstate = wxPyBeginAllowThreads();
3582 wxRegisterId(arg1);
3583
3584 wxPyEndAllowThreads(__tstate);
3585 if (PyErr_Occurred()) SWIG_fail;
3586 }
3587 Py_INCREF(Py_None); resultobj = Py_None;
3588 return resultobj;
3589 fail:
3590 return NULL;
3591 }
3592
3593
3594 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3595 PyObject *resultobj;
3596 long result;
3597 char *kwnames[] = {
3598 NULL
3599 };
3600
3601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3602 {
3603 PyThreadState* __tstate = wxPyBeginAllowThreads();
3604 result = (long)wxGetCurrentId();
3605
3606 wxPyEndAllowThreads(__tstate);
3607 if (PyErr_Occurred()) SWIG_fail;
3608 }
3609 {
3610 resultobj = SWIG_From_long((long)(result));
3611 }
3612 return resultobj;
3613 fail:
3614 return NULL;
3615 }
3616
3617
3618 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3619 PyObject *resultobj;
3620 int arg1 ;
3621 bool result;
3622 PyObject * obj0 = 0 ;
3623 char *kwnames[] = {
3624 (char *) "id", NULL
3625 };
3626
3627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3628 {
3629 arg1 = (int)(SWIG_As_int(obj0));
3630 if (SWIG_arg_fail(1)) SWIG_fail;
3631 }
3632 {
3633 PyThreadState* __tstate = wxPyBeginAllowThreads();
3634 result = (bool)wxIsStockID(arg1);
3635
3636 wxPyEndAllowThreads(__tstate);
3637 if (PyErr_Occurred()) SWIG_fail;
3638 }
3639 {
3640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3641 }
3642 return resultobj;
3643 fail:
3644 return NULL;
3645 }
3646
3647
3648 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3649 PyObject *resultobj;
3650 int arg1 ;
3651 wxString *arg2 = 0 ;
3652 bool result;
3653 bool temp2 = false ;
3654 PyObject * obj0 = 0 ;
3655 PyObject * obj1 = 0 ;
3656 char *kwnames[] = {
3657 (char *) "id",(char *) "label", NULL
3658 };
3659
3660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3661 {
3662 arg1 = (int)(SWIG_As_int(obj0));
3663 if (SWIG_arg_fail(1)) SWIG_fail;
3664 }
3665 {
3666 arg2 = wxString_in_helper(obj1);
3667 if (arg2 == NULL) SWIG_fail;
3668 temp2 = true;
3669 }
3670 {
3671 PyThreadState* __tstate = wxPyBeginAllowThreads();
3672 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3673
3674 wxPyEndAllowThreads(__tstate);
3675 if (PyErr_Occurred()) SWIG_fail;
3676 }
3677 {
3678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3679 }
3680 {
3681 if (temp2)
3682 delete arg2;
3683 }
3684 return resultobj;
3685 fail:
3686 {
3687 if (temp2)
3688 delete arg2;
3689 }
3690 return NULL;
3691 }
3692
3693
3694 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3695 PyObject *resultobj;
3696 int arg1 ;
3697 bool arg2 = (bool) true ;
3698 wxString arg3 = (wxString) wxPyEmptyString ;
3699 wxString result;
3700 PyObject * obj0 = 0 ;
3701 PyObject * obj1 = 0 ;
3702 PyObject * obj2 = 0 ;
3703 char *kwnames[] = {
3704 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3705 };
3706
3707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3708 {
3709 arg1 = (int)(SWIG_As_int(obj0));
3710 if (SWIG_arg_fail(1)) SWIG_fail;
3711 }
3712 if (obj1) {
3713 {
3714 arg2 = (bool)(SWIG_As_bool(obj1));
3715 if (SWIG_arg_fail(2)) SWIG_fail;
3716 }
3717 }
3718 if (obj2) {
3719 {
3720 wxString* sptr = wxString_in_helper(obj2);
3721 if (sptr == NULL) SWIG_fail;
3722 arg3 = *sptr;
3723 delete sptr;
3724 }
3725 }
3726 {
3727 PyThreadState* __tstate = wxPyBeginAllowThreads();
3728 result = wxGetStockLabel(arg1,arg2,arg3);
3729
3730 wxPyEndAllowThreads(__tstate);
3731 if (PyErr_Occurred()) SWIG_fail;
3732 }
3733 {
3734 #if wxUSE_UNICODE
3735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3736 #else
3737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3738 #endif
3739 }
3740 return resultobj;
3741 fail:
3742 return NULL;
3743 }
3744
3745
3746 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3747 PyObject *resultobj;
3748 char *kwnames[] = {
3749 NULL
3750 };
3751
3752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3753 {
3754 if (!wxPyCheckForApp()) SWIG_fail;
3755 PyThreadState* __tstate = wxPyBeginAllowThreads();
3756 wxBell();
3757
3758 wxPyEndAllowThreads(__tstate);
3759 if (PyErr_Occurred()) SWIG_fail;
3760 }
3761 Py_INCREF(Py_None); resultobj = Py_None;
3762 return resultobj;
3763 fail:
3764 return NULL;
3765 }
3766
3767
3768 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3769 PyObject *resultobj;
3770 char *kwnames[] = {
3771 NULL
3772 };
3773
3774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3775 {
3776 if (!wxPyCheckForApp()) SWIG_fail;
3777 PyThreadState* __tstate = wxPyBeginAllowThreads();
3778 wxEndBusyCursor();
3779
3780 wxPyEndAllowThreads(__tstate);
3781 if (PyErr_Occurred()) SWIG_fail;
3782 }
3783 Py_INCREF(Py_None); resultobj = Py_None;
3784 return resultobj;
3785 fail:
3786 return NULL;
3787 }
3788
3789
3790 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3791 PyObject *resultobj;
3792 bool arg1 = (bool) true ;
3793 long result;
3794 PyObject * obj0 = 0 ;
3795 char *kwnames[] = {
3796 (char *) "resetTimer", NULL
3797 };
3798
3799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3800 if (obj0) {
3801 {
3802 arg1 = (bool)(SWIG_As_bool(obj0));
3803 if (SWIG_arg_fail(1)) SWIG_fail;
3804 }
3805 }
3806 {
3807 PyThreadState* __tstate = wxPyBeginAllowThreads();
3808 result = (long)wxGetElapsedTime(arg1);
3809
3810 wxPyEndAllowThreads(__tstate);
3811 if (PyErr_Occurred()) SWIG_fail;
3812 }
3813 {
3814 resultobj = SWIG_From_long((long)(result));
3815 }
3816 return resultobj;
3817 fail:
3818 return NULL;
3819 }
3820
3821
3822 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3823 PyObject *resultobj;
3824 int *arg1 = (int *) 0 ;
3825 int *arg2 = (int *) 0 ;
3826 int temp1 ;
3827 int res1 = 0 ;
3828 int temp2 ;
3829 int res2 = 0 ;
3830 char *kwnames[] = {
3831 NULL
3832 };
3833
3834 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3835 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3837 {
3838 if (!wxPyCheckForApp()) SWIG_fail;
3839 PyThreadState* __tstate = wxPyBeginAllowThreads();
3840 wxGetMousePosition(arg1,arg2);
3841
3842 wxPyEndAllowThreads(__tstate);
3843 if (PyErr_Occurred()) SWIG_fail;
3844 }
3845 Py_INCREF(Py_None); resultobj = Py_None;
3846 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3847 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3848 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3849 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3850 return resultobj;
3851 fail:
3852 return NULL;
3853 }
3854
3855
3856 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3857 PyObject *resultobj;
3858 bool result;
3859 char *kwnames[] = {
3860 NULL
3861 };
3862
3863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3864 {
3865 PyThreadState* __tstate = wxPyBeginAllowThreads();
3866 result = (bool)wxIsBusy();
3867
3868 wxPyEndAllowThreads(__tstate);
3869 if (PyErr_Occurred()) SWIG_fail;
3870 }
3871 {
3872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3873 }
3874 return resultobj;
3875 fail:
3876 return NULL;
3877 }
3878
3879
3880 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3881 PyObject *resultobj;
3882 wxString result;
3883 char *kwnames[] = {
3884 NULL
3885 };
3886
3887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3888 {
3889 PyThreadState* __tstate = wxPyBeginAllowThreads();
3890 result = wxNow();
3891
3892 wxPyEndAllowThreads(__tstate);
3893 if (PyErr_Occurred()) SWIG_fail;
3894 }
3895 {
3896 #if wxUSE_UNICODE
3897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3898 #else
3899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3900 #endif
3901 }
3902 return resultobj;
3903 fail:
3904 return NULL;
3905 }
3906
3907
3908 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3909 PyObject *resultobj;
3910 wxString const &arg1_defvalue = wxPyEmptyString ;
3911 wxString *arg1 = (wxString *) &arg1_defvalue ;
3912 bool result;
3913 bool temp1 = false ;
3914 PyObject * obj0 = 0 ;
3915 char *kwnames[] = {
3916 (char *) "command", NULL
3917 };
3918
3919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3920 if (obj0) {
3921 {
3922 arg1 = wxString_in_helper(obj0);
3923 if (arg1 == NULL) SWIG_fail;
3924 temp1 = true;
3925 }
3926 }
3927 {
3928 PyThreadState* __tstate = wxPyBeginAllowThreads();
3929 result = (bool)wxShell((wxString const &)*arg1);
3930
3931 wxPyEndAllowThreads(__tstate);
3932 if (PyErr_Occurred()) SWIG_fail;
3933 }
3934 {
3935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3936 }
3937 {
3938 if (temp1)
3939 delete arg1;
3940 }
3941 return resultobj;
3942 fail:
3943 {
3944 if (temp1)
3945 delete arg1;
3946 }
3947 return NULL;
3948 }
3949
3950
3951 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3952 PyObject *resultobj;
3953 char *kwnames[] = {
3954 NULL
3955 };
3956
3957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3958 {
3959 PyThreadState* __tstate = wxPyBeginAllowThreads();
3960 wxStartTimer();
3961
3962 wxPyEndAllowThreads(__tstate);
3963 if (PyErr_Occurred()) SWIG_fail;
3964 }
3965 Py_INCREF(Py_None); resultobj = Py_None;
3966 return resultobj;
3967 fail:
3968 return NULL;
3969 }
3970
3971
3972 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3973 PyObject *resultobj;
3974 int *arg1 = (int *) 0 ;
3975 int *arg2 = (int *) 0 ;
3976 int result;
3977 int temp1 ;
3978 int res1 = 0 ;
3979 int temp2 ;
3980 int res2 = 0 ;
3981 char *kwnames[] = {
3982 NULL
3983 };
3984
3985 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3986 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3988 {
3989 PyThreadState* __tstate = wxPyBeginAllowThreads();
3990 result = (int)wxGetOsVersion(arg1,arg2);
3991
3992 wxPyEndAllowThreads(__tstate);
3993 if (PyErr_Occurred()) SWIG_fail;
3994 }
3995 {
3996 resultobj = SWIG_From_int((int)(result));
3997 }
3998 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3999 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4000 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4001 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4002 return resultobj;
4003 fail:
4004 return NULL;
4005 }
4006
4007
4008 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4009 PyObject *resultobj;
4010 wxString result;
4011 char *kwnames[] = {
4012 NULL
4013 };
4014
4015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4016 {
4017 PyThreadState* __tstate = wxPyBeginAllowThreads();
4018 result = wxGetOsDescription();
4019
4020 wxPyEndAllowThreads(__tstate);
4021 if (PyErr_Occurred()) SWIG_fail;
4022 }
4023 {
4024 #if wxUSE_UNICODE
4025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4026 #else
4027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4028 #endif
4029 }
4030 return resultobj;
4031 fail:
4032 return NULL;
4033 }
4034
4035
4036 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4037 PyObject *resultobj;
4038 long result;
4039 char *kwnames[] = {
4040 NULL
4041 };
4042
4043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4044 {
4045 PyThreadState* __tstate = wxPyBeginAllowThreads();
4046 result = (long)wxGetFreeMemory();
4047
4048 wxPyEndAllowThreads(__tstate);
4049 if (PyErr_Occurred()) SWIG_fail;
4050 }
4051 {
4052 resultobj = SWIG_From_long((long)(result));
4053 }
4054 return resultobj;
4055 fail:
4056 return NULL;
4057 }
4058
4059
4060 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4061 PyObject *resultobj;
4062 wxShutdownFlags arg1 ;
4063 bool result;
4064 PyObject * obj0 = 0 ;
4065 char *kwnames[] = {
4066 (char *) "wFlags", NULL
4067 };
4068
4069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4070 {
4071 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4072 if (SWIG_arg_fail(1)) SWIG_fail;
4073 }
4074 {
4075 if (!wxPyCheckForApp()) SWIG_fail;
4076 PyThreadState* __tstate = wxPyBeginAllowThreads();
4077 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4078
4079 wxPyEndAllowThreads(__tstate);
4080 if (PyErr_Occurred()) SWIG_fail;
4081 }
4082 {
4083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4084 }
4085 return resultobj;
4086 fail:
4087 return NULL;
4088 }
4089
4090
4091 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4092 PyObject *resultobj;
4093 int arg1 ;
4094 PyObject * obj0 = 0 ;
4095 char *kwnames[] = {
4096 (char *) "secs", NULL
4097 };
4098
4099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4100 {
4101 arg1 = (int)(SWIG_As_int(obj0));
4102 if (SWIG_arg_fail(1)) SWIG_fail;
4103 }
4104 {
4105 PyThreadState* __tstate = wxPyBeginAllowThreads();
4106 wxSleep(arg1);
4107
4108 wxPyEndAllowThreads(__tstate);
4109 if (PyErr_Occurred()) SWIG_fail;
4110 }
4111 Py_INCREF(Py_None); resultobj = Py_None;
4112 return resultobj;
4113 fail:
4114 return NULL;
4115 }
4116
4117
4118 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4119 PyObject *resultobj;
4120 unsigned long arg1 ;
4121 PyObject * obj0 = 0 ;
4122 char *kwnames[] = {
4123 (char *) "milliseconds", NULL
4124 };
4125
4126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4127 {
4128 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4129 if (SWIG_arg_fail(1)) SWIG_fail;
4130 }
4131 {
4132 PyThreadState* __tstate = wxPyBeginAllowThreads();
4133 wxMilliSleep(arg1);
4134
4135 wxPyEndAllowThreads(__tstate);
4136 if (PyErr_Occurred()) SWIG_fail;
4137 }
4138 Py_INCREF(Py_None); resultobj = Py_None;
4139 return resultobj;
4140 fail:
4141 return NULL;
4142 }
4143
4144
4145 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4146 PyObject *resultobj;
4147 unsigned long arg1 ;
4148 PyObject * obj0 = 0 ;
4149 char *kwnames[] = {
4150 (char *) "microseconds", NULL
4151 };
4152
4153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4154 {
4155 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4156 if (SWIG_arg_fail(1)) SWIG_fail;
4157 }
4158 {
4159 PyThreadState* __tstate = wxPyBeginAllowThreads();
4160 wxMicroSleep(arg1);
4161
4162 wxPyEndAllowThreads(__tstate);
4163 if (PyErr_Occurred()) SWIG_fail;
4164 }
4165 Py_INCREF(Py_None); resultobj = Py_None;
4166 return resultobj;
4167 fail:
4168 return NULL;
4169 }
4170
4171
4172 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4173 PyObject *resultobj;
4174 bool arg1 ;
4175 PyObject * obj0 = 0 ;
4176 char *kwnames[] = {
4177 (char *) "enable", NULL
4178 };
4179
4180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4181 {
4182 arg1 = (bool)(SWIG_As_bool(obj0));
4183 if (SWIG_arg_fail(1)) SWIG_fail;
4184 }
4185 {
4186 PyThreadState* __tstate = wxPyBeginAllowThreads();
4187 wxEnableTopLevelWindows(arg1);
4188
4189 wxPyEndAllowThreads(__tstate);
4190 if (PyErr_Occurred()) SWIG_fail;
4191 }
4192 Py_INCREF(Py_None); resultobj = Py_None;
4193 return resultobj;
4194 fail:
4195 return NULL;
4196 }
4197
4198
4199 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4200 PyObject *resultobj;
4201 wxString *arg1 = 0 ;
4202 wxString result;
4203 bool temp1 = false ;
4204 PyObject * obj0 = 0 ;
4205 char *kwnames[] = {
4206 (char *) "in", NULL
4207 };
4208
4209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4210 {
4211 arg1 = wxString_in_helper(obj0);
4212 if (arg1 == NULL) SWIG_fail;
4213 temp1 = true;
4214 }
4215 {
4216 PyThreadState* __tstate = wxPyBeginAllowThreads();
4217 result = wxStripMenuCodes((wxString const &)*arg1);
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 {
4230 if (temp1)
4231 delete arg1;
4232 }
4233 return resultobj;
4234 fail:
4235 {
4236 if (temp1)
4237 delete arg1;
4238 }
4239 return NULL;
4240 }
4241
4242
4243 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4244 PyObject *resultobj;
4245 wxString result;
4246 char *kwnames[] = {
4247 NULL
4248 };
4249
4250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4251 {
4252 PyThreadState* __tstate = wxPyBeginAllowThreads();
4253 result = wxGetEmailAddress();
4254
4255 wxPyEndAllowThreads(__tstate);
4256 if (PyErr_Occurred()) SWIG_fail;
4257 }
4258 {
4259 #if wxUSE_UNICODE
4260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4261 #else
4262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4263 #endif
4264 }
4265 return resultobj;
4266 fail:
4267 return NULL;
4268 }
4269
4270
4271 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4272 PyObject *resultobj;
4273 wxString result;
4274 char *kwnames[] = {
4275 NULL
4276 };
4277
4278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4279 {
4280 PyThreadState* __tstate = wxPyBeginAllowThreads();
4281 result = wxGetHostName();
4282
4283 wxPyEndAllowThreads(__tstate);
4284 if (PyErr_Occurred()) SWIG_fail;
4285 }
4286 {
4287 #if wxUSE_UNICODE
4288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4289 #else
4290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4291 #endif
4292 }
4293 return resultobj;
4294 fail:
4295 return NULL;
4296 }
4297
4298
4299 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4300 PyObject *resultobj;
4301 wxString result;
4302 char *kwnames[] = {
4303 NULL
4304 };
4305
4306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4307 {
4308 PyThreadState* __tstate = wxPyBeginAllowThreads();
4309 result = wxGetFullHostName();
4310
4311 wxPyEndAllowThreads(__tstate);
4312 if (PyErr_Occurred()) SWIG_fail;
4313 }
4314 {
4315 #if wxUSE_UNICODE
4316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4317 #else
4318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4319 #endif
4320 }
4321 return resultobj;
4322 fail:
4323 return NULL;
4324 }
4325
4326
4327 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4328 PyObject *resultobj;
4329 wxString result;
4330 char *kwnames[] = {
4331 NULL
4332 };
4333
4334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4335 {
4336 PyThreadState* __tstate = wxPyBeginAllowThreads();
4337 result = wxGetUserId();
4338
4339 wxPyEndAllowThreads(__tstate);
4340 if (PyErr_Occurred()) SWIG_fail;
4341 }
4342 {
4343 #if wxUSE_UNICODE
4344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4345 #else
4346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4347 #endif
4348 }
4349 return resultobj;
4350 fail:
4351 return NULL;
4352 }
4353
4354
4355 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4356 PyObject *resultobj;
4357 wxString result;
4358 char *kwnames[] = {
4359 NULL
4360 };
4361
4362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4363 {
4364 PyThreadState* __tstate = wxPyBeginAllowThreads();
4365 result = wxGetUserName();
4366
4367 wxPyEndAllowThreads(__tstate);
4368 if (PyErr_Occurred()) SWIG_fail;
4369 }
4370 {
4371 #if wxUSE_UNICODE
4372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4373 #else
4374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4375 #endif
4376 }
4377 return resultobj;
4378 fail:
4379 return NULL;
4380 }
4381
4382
4383 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4384 PyObject *resultobj;
4385 wxString result;
4386 char *kwnames[] = {
4387 NULL
4388 };
4389
4390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4391 {
4392 PyThreadState* __tstate = wxPyBeginAllowThreads();
4393 result = wxGetHomeDir();
4394
4395 wxPyEndAllowThreads(__tstate);
4396 if (PyErr_Occurred()) SWIG_fail;
4397 }
4398 {
4399 #if wxUSE_UNICODE
4400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4401 #else
4402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4403 #endif
4404 }
4405 return resultobj;
4406 fail:
4407 return NULL;
4408 }
4409
4410
4411 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4412 PyObject *resultobj;
4413 wxString const &arg1_defvalue = wxPyEmptyString ;
4414 wxString *arg1 = (wxString *) &arg1_defvalue ;
4415 wxString result;
4416 bool temp1 = false ;
4417 PyObject * obj0 = 0 ;
4418 char *kwnames[] = {
4419 (char *) "user", NULL
4420 };
4421
4422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4423 if (obj0) {
4424 {
4425 arg1 = wxString_in_helper(obj0);
4426 if (arg1 == NULL) SWIG_fail;
4427 temp1 = true;
4428 }
4429 }
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = wxGetUserHome((wxString const &)*arg1);
4433
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 {
4438 #if wxUSE_UNICODE
4439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4440 #else
4441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4442 #endif
4443 }
4444 {
4445 if (temp1)
4446 delete arg1;
4447 }
4448 return resultobj;
4449 fail:
4450 {
4451 if (temp1)
4452 delete arg1;
4453 }
4454 return NULL;
4455 }
4456
4457
4458 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4459 PyObject *resultobj;
4460 unsigned long result;
4461 char *kwnames[] = {
4462 NULL
4463 };
4464
4465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4466 {
4467 PyThreadState* __tstate = wxPyBeginAllowThreads();
4468 result = (unsigned long)wxGetProcessId();
4469
4470 wxPyEndAllowThreads(__tstate);
4471 if (PyErr_Occurred()) SWIG_fail;
4472 }
4473 {
4474 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4475 }
4476 return resultobj;
4477 fail:
4478 return NULL;
4479 }
4480
4481
4482 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4483 PyObject *resultobj;
4484 char *kwnames[] = {
4485 NULL
4486 };
4487
4488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4489 {
4490 PyThreadState* __tstate = wxPyBeginAllowThreads();
4491 wxTrap();
4492
4493 wxPyEndAllowThreads(__tstate);
4494 if (PyErr_Occurred()) SWIG_fail;
4495 }
4496 Py_INCREF(Py_None); resultobj = Py_None;
4497 return resultobj;
4498 fail:
4499 return NULL;
4500 }
4501
4502
4503 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4504 PyObject *resultobj;
4505 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4506 wxString *arg1 = (wxString *) &arg1_defvalue ;
4507 wxString const &arg2_defvalue = wxPyEmptyString ;
4508 wxString *arg2 = (wxString *) &arg2_defvalue ;
4509 wxString const &arg3_defvalue = wxPyEmptyString ;
4510 wxString *arg3 = (wxString *) &arg3_defvalue ;
4511 wxString const &arg4_defvalue = wxPyEmptyString ;
4512 wxString *arg4 = (wxString *) &arg4_defvalue ;
4513 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4514 wxString *arg5 = (wxString *) &arg5_defvalue ;
4515 int arg6 = (int) 0 ;
4516 wxWindow *arg7 = (wxWindow *) NULL ;
4517 int arg8 = (int) -1 ;
4518 int arg9 = (int) -1 ;
4519 wxString result;
4520 bool temp1 = false ;
4521 bool temp2 = false ;
4522 bool temp3 = false ;
4523 bool temp4 = false ;
4524 bool temp5 = false ;
4525 PyObject * obj0 = 0 ;
4526 PyObject * obj1 = 0 ;
4527 PyObject * obj2 = 0 ;
4528 PyObject * obj3 = 0 ;
4529 PyObject * obj4 = 0 ;
4530 PyObject * obj5 = 0 ;
4531 PyObject * obj6 = 0 ;
4532 PyObject * obj7 = 0 ;
4533 PyObject * obj8 = 0 ;
4534 char *kwnames[] = {
4535 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4536 };
4537
4538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4539 if (obj0) {
4540 {
4541 arg1 = wxString_in_helper(obj0);
4542 if (arg1 == NULL) SWIG_fail;
4543 temp1 = true;
4544 }
4545 }
4546 if (obj1) {
4547 {
4548 arg2 = wxString_in_helper(obj1);
4549 if (arg2 == NULL) SWIG_fail;
4550 temp2 = true;
4551 }
4552 }
4553 if (obj2) {
4554 {
4555 arg3 = wxString_in_helper(obj2);
4556 if (arg3 == NULL) SWIG_fail;
4557 temp3 = true;
4558 }
4559 }
4560 if (obj3) {
4561 {
4562 arg4 = wxString_in_helper(obj3);
4563 if (arg4 == NULL) SWIG_fail;
4564 temp4 = true;
4565 }
4566 }
4567 if (obj4) {
4568 {
4569 arg5 = wxString_in_helper(obj4);
4570 if (arg5 == NULL) SWIG_fail;
4571 temp5 = true;
4572 }
4573 }
4574 if (obj5) {
4575 {
4576 arg6 = (int)(SWIG_As_int(obj5));
4577 if (SWIG_arg_fail(6)) SWIG_fail;
4578 }
4579 }
4580 if (obj6) {
4581 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4582 if (SWIG_arg_fail(7)) SWIG_fail;
4583 }
4584 if (obj7) {
4585 {
4586 arg8 = (int)(SWIG_As_int(obj7));
4587 if (SWIG_arg_fail(8)) SWIG_fail;
4588 }
4589 }
4590 if (obj8) {
4591 {
4592 arg9 = (int)(SWIG_As_int(obj8));
4593 if (SWIG_arg_fail(9)) SWIG_fail;
4594 }
4595 }
4596 {
4597 if (!wxPyCheckForApp()) SWIG_fail;
4598 PyThreadState* __tstate = wxPyBeginAllowThreads();
4599 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4600
4601 wxPyEndAllowThreads(__tstate);
4602 if (PyErr_Occurred()) SWIG_fail;
4603 }
4604 {
4605 #if wxUSE_UNICODE
4606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4607 #else
4608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4609 #endif
4610 }
4611 {
4612 if (temp1)
4613 delete arg1;
4614 }
4615 {
4616 if (temp2)
4617 delete arg2;
4618 }
4619 {
4620 if (temp3)
4621 delete arg3;
4622 }
4623 {
4624 if (temp4)
4625 delete arg4;
4626 }
4627 {
4628 if (temp5)
4629 delete arg5;
4630 }
4631 return resultobj;
4632 fail:
4633 {
4634 if (temp1)
4635 delete arg1;
4636 }
4637 {
4638 if (temp2)
4639 delete arg2;
4640 }
4641 {
4642 if (temp3)
4643 delete arg3;
4644 }
4645 {
4646 if (temp4)
4647 delete arg4;
4648 }
4649 {
4650 if (temp5)
4651 delete arg5;
4652 }
4653 return NULL;
4654 }
4655
4656
4657 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj;
4659 wxString *arg1 = 0 ;
4660 wxString *arg2 = 0 ;
4661 wxString const &arg3_defvalue = wxPyEmptyString ;
4662 wxString *arg3 = (wxString *) &arg3_defvalue ;
4663 wxWindow *arg4 = (wxWindow *) NULL ;
4664 wxString result;
4665 bool temp1 = false ;
4666 bool temp2 = false ;
4667 bool temp3 = false ;
4668 PyObject * obj0 = 0 ;
4669 PyObject * obj1 = 0 ;
4670 PyObject * obj2 = 0 ;
4671 PyObject * obj3 = 0 ;
4672 char *kwnames[] = {
4673 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4674 };
4675
4676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4677 {
4678 arg1 = wxString_in_helper(obj0);
4679 if (arg1 == NULL) SWIG_fail;
4680 temp1 = true;
4681 }
4682 {
4683 arg2 = wxString_in_helper(obj1);
4684 if (arg2 == NULL) SWIG_fail;
4685 temp2 = true;
4686 }
4687 if (obj2) {
4688 {
4689 arg3 = wxString_in_helper(obj2);
4690 if (arg3 == NULL) SWIG_fail;
4691 temp3 = true;
4692 }
4693 }
4694 if (obj3) {
4695 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4696 if (SWIG_arg_fail(4)) SWIG_fail;
4697 }
4698 {
4699 if (!wxPyCheckForApp()) SWIG_fail;
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4702
4703 wxPyEndAllowThreads(__tstate);
4704 if (PyErr_Occurred()) SWIG_fail;
4705 }
4706 {
4707 #if wxUSE_UNICODE
4708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4709 #else
4710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4711 #endif
4712 }
4713 {
4714 if (temp1)
4715 delete arg1;
4716 }
4717 {
4718 if (temp2)
4719 delete arg2;
4720 }
4721 {
4722 if (temp3)
4723 delete arg3;
4724 }
4725 return resultobj;
4726 fail:
4727 {
4728 if (temp1)
4729 delete arg1;
4730 }
4731 {
4732 if (temp2)
4733 delete arg2;
4734 }
4735 {
4736 if (temp3)
4737 delete arg3;
4738 }
4739 return NULL;
4740 }
4741
4742
4743 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4744 PyObject *resultobj;
4745 wxString *arg1 = 0 ;
4746 wxString *arg2 = 0 ;
4747 wxString const &arg3_defvalue = wxPyEmptyString ;
4748 wxString *arg3 = (wxString *) &arg3_defvalue ;
4749 wxWindow *arg4 = (wxWindow *) NULL ;
4750 wxString result;
4751 bool temp1 = false ;
4752 bool temp2 = false ;
4753 bool temp3 = false ;
4754 PyObject * obj0 = 0 ;
4755 PyObject * obj1 = 0 ;
4756 PyObject * obj2 = 0 ;
4757 PyObject * obj3 = 0 ;
4758 char *kwnames[] = {
4759 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4760 };
4761
4762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4763 {
4764 arg1 = wxString_in_helper(obj0);
4765 if (arg1 == NULL) SWIG_fail;
4766 temp1 = true;
4767 }
4768 {
4769 arg2 = wxString_in_helper(obj1);
4770 if (arg2 == NULL) SWIG_fail;
4771 temp2 = true;
4772 }
4773 if (obj2) {
4774 {
4775 arg3 = wxString_in_helper(obj2);
4776 if (arg3 == NULL) SWIG_fail;
4777 temp3 = true;
4778 }
4779 }
4780 if (obj3) {
4781 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4782 if (SWIG_arg_fail(4)) SWIG_fail;
4783 }
4784 {
4785 if (!wxPyCheckForApp()) SWIG_fail;
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4788
4789 wxPyEndAllowThreads(__tstate);
4790 if (PyErr_Occurred()) SWIG_fail;
4791 }
4792 {
4793 #if wxUSE_UNICODE
4794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4795 #else
4796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4797 #endif
4798 }
4799 {
4800 if (temp1)
4801 delete arg1;
4802 }
4803 {
4804 if (temp2)
4805 delete arg2;
4806 }
4807 {
4808 if (temp3)
4809 delete arg3;
4810 }
4811 return resultobj;
4812 fail:
4813 {
4814 if (temp1)
4815 delete arg1;
4816 }
4817 {
4818 if (temp2)
4819 delete arg2;
4820 }
4821 {
4822 if (temp3)
4823 delete arg3;
4824 }
4825 return NULL;
4826 }
4827
4828
4829 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4830 PyObject *resultobj;
4831 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4832 wxString *arg1 = (wxString *) &arg1_defvalue ;
4833 wxString const &arg2_defvalue = wxPyEmptyString ;
4834 wxString *arg2 = (wxString *) &arg2_defvalue ;
4835 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4836 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4837 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4838 wxWindow *arg5 = (wxWindow *) NULL ;
4839 wxString result;
4840 bool temp1 = false ;
4841 bool temp2 = false ;
4842 wxPoint temp4 ;
4843 PyObject * obj0 = 0 ;
4844 PyObject * obj1 = 0 ;
4845 PyObject * obj2 = 0 ;
4846 PyObject * obj3 = 0 ;
4847 PyObject * obj4 = 0 ;
4848 char *kwnames[] = {
4849 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4850 };
4851
4852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4853 if (obj0) {
4854 {
4855 arg1 = wxString_in_helper(obj0);
4856 if (arg1 == NULL) SWIG_fail;
4857 temp1 = true;
4858 }
4859 }
4860 if (obj1) {
4861 {
4862 arg2 = wxString_in_helper(obj1);
4863 if (arg2 == NULL) SWIG_fail;
4864 temp2 = true;
4865 }
4866 }
4867 if (obj2) {
4868 {
4869 arg3 = (long)(SWIG_As_long(obj2));
4870 if (SWIG_arg_fail(3)) SWIG_fail;
4871 }
4872 }
4873 if (obj3) {
4874 {
4875 arg4 = &temp4;
4876 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4877 }
4878 }
4879 if (obj4) {
4880 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4881 if (SWIG_arg_fail(5)) SWIG_fail;
4882 }
4883 {
4884 if (!wxPyCheckForApp()) SWIG_fail;
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4887
4888 wxPyEndAllowThreads(__tstate);
4889 if (PyErr_Occurred()) SWIG_fail;
4890 }
4891 {
4892 #if wxUSE_UNICODE
4893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4894 #else
4895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4896 #endif
4897 }
4898 {
4899 if (temp1)
4900 delete arg1;
4901 }
4902 {
4903 if (temp2)
4904 delete arg2;
4905 }
4906 return resultobj;
4907 fail:
4908 {
4909 if (temp1)
4910 delete arg1;
4911 }
4912 {
4913 if (temp2)
4914 delete arg2;
4915 }
4916 return NULL;
4917 }
4918
4919
4920 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4921 PyObject *resultobj;
4922 wxString *arg1 = 0 ;
4923 wxString const &arg2_defvalue = wxPyEmptyString ;
4924 wxString *arg2 = (wxString *) &arg2_defvalue ;
4925 wxString const &arg3_defvalue = wxPyEmptyString ;
4926 wxString *arg3 = (wxString *) &arg3_defvalue ;
4927 wxWindow *arg4 = (wxWindow *) NULL ;
4928 int arg5 = (int) -1 ;
4929 int arg6 = (int) -1 ;
4930 bool arg7 = (bool) true ;
4931 wxString result;
4932 bool temp1 = false ;
4933 bool temp2 = false ;
4934 bool temp3 = false ;
4935 PyObject * obj0 = 0 ;
4936 PyObject * obj1 = 0 ;
4937 PyObject * obj2 = 0 ;
4938 PyObject * obj3 = 0 ;
4939 PyObject * obj4 = 0 ;
4940 PyObject * obj5 = 0 ;
4941 PyObject * obj6 = 0 ;
4942 char *kwnames[] = {
4943 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4944 };
4945
4946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4947 {
4948 arg1 = wxString_in_helper(obj0);
4949 if (arg1 == NULL) SWIG_fail;
4950 temp1 = true;
4951 }
4952 if (obj1) {
4953 {
4954 arg2 = wxString_in_helper(obj1);
4955 if (arg2 == NULL) SWIG_fail;
4956 temp2 = true;
4957 }
4958 }
4959 if (obj2) {
4960 {
4961 arg3 = wxString_in_helper(obj2);
4962 if (arg3 == NULL) SWIG_fail;
4963 temp3 = true;
4964 }
4965 }
4966 if (obj3) {
4967 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4968 if (SWIG_arg_fail(4)) SWIG_fail;
4969 }
4970 if (obj4) {
4971 {
4972 arg5 = (int)(SWIG_As_int(obj4));
4973 if (SWIG_arg_fail(5)) SWIG_fail;
4974 }
4975 }
4976 if (obj5) {
4977 {
4978 arg6 = (int)(SWIG_As_int(obj5));
4979 if (SWIG_arg_fail(6)) SWIG_fail;
4980 }
4981 }
4982 if (obj6) {
4983 {
4984 arg7 = (bool)(SWIG_As_bool(obj6));
4985 if (SWIG_arg_fail(7)) SWIG_fail;
4986 }
4987 }
4988 {
4989 if (!wxPyCheckForApp()) SWIG_fail;
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4992
4993 wxPyEndAllowThreads(__tstate);
4994 if (PyErr_Occurred()) SWIG_fail;
4995 }
4996 {
4997 #if wxUSE_UNICODE
4998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4999 #else
5000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5001 #endif
5002 }
5003 {
5004 if (temp1)
5005 delete arg1;
5006 }
5007 {
5008 if (temp2)
5009 delete arg2;
5010 }
5011 {
5012 if (temp3)
5013 delete arg3;
5014 }
5015 return resultobj;
5016 fail:
5017 {
5018 if (temp1)
5019 delete arg1;
5020 }
5021 {
5022 if (temp2)
5023 delete arg2;
5024 }
5025 {
5026 if (temp3)
5027 delete arg3;
5028 }
5029 return NULL;
5030 }
5031
5032
5033 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5034 PyObject *resultobj;
5035 wxString *arg1 = 0 ;
5036 wxString const &arg2_defvalue = wxPyEmptyString ;
5037 wxString *arg2 = (wxString *) &arg2_defvalue ;
5038 wxString const &arg3_defvalue = wxPyEmptyString ;
5039 wxString *arg3 = (wxString *) &arg3_defvalue ;
5040 wxWindow *arg4 = (wxWindow *) NULL ;
5041 wxString result;
5042 bool temp1 = false ;
5043 bool temp2 = false ;
5044 bool temp3 = false ;
5045 PyObject * obj0 = 0 ;
5046 PyObject * obj1 = 0 ;
5047 PyObject * obj2 = 0 ;
5048 PyObject * obj3 = 0 ;
5049 char *kwnames[] = {
5050 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5051 };
5052
5053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5054 {
5055 arg1 = wxString_in_helper(obj0);
5056 if (arg1 == NULL) SWIG_fail;
5057 temp1 = true;
5058 }
5059 if (obj1) {
5060 {
5061 arg2 = wxString_in_helper(obj1);
5062 if (arg2 == NULL) SWIG_fail;
5063 temp2 = true;
5064 }
5065 }
5066 if (obj2) {
5067 {
5068 arg3 = wxString_in_helper(obj2);
5069 if (arg3 == NULL) SWIG_fail;
5070 temp3 = true;
5071 }
5072 }
5073 if (obj3) {
5074 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5075 if (SWIG_arg_fail(4)) SWIG_fail;
5076 }
5077 {
5078 if (!wxPyCheckForApp()) SWIG_fail;
5079 PyThreadState* __tstate = wxPyBeginAllowThreads();
5080 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5081
5082 wxPyEndAllowThreads(__tstate);
5083 if (PyErr_Occurred()) SWIG_fail;
5084 }
5085 {
5086 #if wxUSE_UNICODE
5087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5088 #else
5089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5090 #endif
5091 }
5092 {
5093 if (temp1)
5094 delete arg1;
5095 }
5096 {
5097 if (temp2)
5098 delete arg2;
5099 }
5100 {
5101 if (temp3)
5102 delete arg3;
5103 }
5104 return resultobj;
5105 fail:
5106 {
5107 if (temp1)
5108 delete arg1;
5109 }
5110 {
5111 if (temp2)
5112 delete arg2;
5113 }
5114 {
5115 if (temp3)
5116 delete arg3;
5117 }
5118 return NULL;
5119 }
5120
5121
5122 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5123 PyObject *resultobj;
5124 wxString *arg1 = 0 ;
5125 wxString *arg2 = 0 ;
5126 int arg3 ;
5127 wxString *arg4 = (wxString *) 0 ;
5128 wxWindow *arg5 = (wxWindow *) NULL ;
5129 int arg6 = (int) -1 ;
5130 int arg7 = (int) -1 ;
5131 bool arg8 = (bool) true ;
5132 int arg9 = (int) 150 ;
5133 int arg10 = (int) 200 ;
5134 wxString result;
5135 bool temp1 = false ;
5136 bool temp2 = false ;
5137 PyObject * obj0 = 0 ;
5138 PyObject * obj1 = 0 ;
5139 PyObject * obj2 = 0 ;
5140 PyObject * obj3 = 0 ;
5141 PyObject * obj4 = 0 ;
5142 PyObject * obj5 = 0 ;
5143 PyObject * obj6 = 0 ;
5144 PyObject * obj7 = 0 ;
5145 PyObject * obj8 = 0 ;
5146 char *kwnames[] = {
5147 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5148 };
5149
5150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5151 {
5152 arg1 = wxString_in_helper(obj0);
5153 if (arg1 == NULL) SWIG_fail;
5154 temp1 = true;
5155 }
5156 {
5157 arg2 = wxString_in_helper(obj1);
5158 if (arg2 == NULL) SWIG_fail;
5159 temp2 = true;
5160 }
5161 {
5162 arg3 = PyList_Size(obj2);
5163 arg4 = wxString_LIST_helper(obj2);
5164 if (arg4 == NULL) SWIG_fail;
5165 }
5166 if (obj3) {
5167 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5168 if (SWIG_arg_fail(5)) SWIG_fail;
5169 }
5170 if (obj4) {
5171 {
5172 arg6 = (int)(SWIG_As_int(obj4));
5173 if (SWIG_arg_fail(6)) SWIG_fail;
5174 }
5175 }
5176 if (obj5) {
5177 {
5178 arg7 = (int)(SWIG_As_int(obj5));
5179 if (SWIG_arg_fail(7)) SWIG_fail;
5180 }
5181 }
5182 if (obj6) {
5183 {
5184 arg8 = (bool)(SWIG_As_bool(obj6));
5185 if (SWIG_arg_fail(8)) SWIG_fail;
5186 }
5187 }
5188 if (obj7) {
5189 {
5190 arg9 = (int)(SWIG_As_int(obj7));
5191 if (SWIG_arg_fail(9)) SWIG_fail;
5192 }
5193 }
5194 if (obj8) {
5195 {
5196 arg10 = (int)(SWIG_As_int(obj8));
5197 if (SWIG_arg_fail(10)) SWIG_fail;
5198 }
5199 }
5200 {
5201 if (!wxPyCheckForApp()) SWIG_fail;
5202 PyThreadState* __tstate = wxPyBeginAllowThreads();
5203 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5204
5205 wxPyEndAllowThreads(__tstate);
5206 if (PyErr_Occurred()) SWIG_fail;
5207 }
5208 {
5209 #if wxUSE_UNICODE
5210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5211 #else
5212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5213 #endif
5214 }
5215 {
5216 if (temp1)
5217 delete arg1;
5218 }
5219 {
5220 if (temp2)
5221 delete arg2;
5222 }
5223 {
5224 if (arg4) delete [] arg4;
5225 }
5226 return resultobj;
5227 fail:
5228 {
5229 if (temp1)
5230 delete arg1;
5231 }
5232 {
5233 if (temp2)
5234 delete arg2;
5235 }
5236 {
5237 if (arg4) delete [] arg4;
5238 }
5239 return NULL;
5240 }
5241
5242
5243 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5244 PyObject *resultobj;
5245 wxString *arg1 = 0 ;
5246 wxString *arg2 = 0 ;
5247 int arg3 ;
5248 wxString *arg4 = (wxString *) 0 ;
5249 wxWindow *arg5 = (wxWindow *) NULL ;
5250 int arg6 = (int) -1 ;
5251 int arg7 = (int) -1 ;
5252 bool arg8 = (bool) true ;
5253 int arg9 = (int) 150 ;
5254 int arg10 = (int) 200 ;
5255 int result;
5256 bool temp1 = false ;
5257 bool temp2 = false ;
5258 PyObject * obj0 = 0 ;
5259 PyObject * obj1 = 0 ;
5260 PyObject * obj2 = 0 ;
5261 PyObject * obj3 = 0 ;
5262 PyObject * obj4 = 0 ;
5263 PyObject * obj5 = 0 ;
5264 PyObject * obj6 = 0 ;
5265 PyObject * obj7 = 0 ;
5266 PyObject * obj8 = 0 ;
5267 char *kwnames[] = {
5268 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5269 };
5270
5271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5272 {
5273 arg1 = wxString_in_helper(obj0);
5274 if (arg1 == NULL) SWIG_fail;
5275 temp1 = true;
5276 }
5277 {
5278 arg2 = wxString_in_helper(obj1);
5279 if (arg2 == NULL) SWIG_fail;
5280 temp2 = true;
5281 }
5282 {
5283 arg3 = PyList_Size(obj2);
5284 arg4 = wxString_LIST_helper(obj2);
5285 if (arg4 == NULL) SWIG_fail;
5286 }
5287 if (obj3) {
5288 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5289 if (SWIG_arg_fail(5)) SWIG_fail;
5290 }
5291 if (obj4) {
5292 {
5293 arg6 = (int)(SWIG_As_int(obj4));
5294 if (SWIG_arg_fail(6)) SWIG_fail;
5295 }
5296 }
5297 if (obj5) {
5298 {
5299 arg7 = (int)(SWIG_As_int(obj5));
5300 if (SWIG_arg_fail(7)) SWIG_fail;
5301 }
5302 }
5303 if (obj6) {
5304 {
5305 arg8 = (bool)(SWIG_As_bool(obj6));
5306 if (SWIG_arg_fail(8)) SWIG_fail;
5307 }
5308 }
5309 if (obj7) {
5310 {
5311 arg9 = (int)(SWIG_As_int(obj7));
5312 if (SWIG_arg_fail(9)) SWIG_fail;
5313 }
5314 }
5315 if (obj8) {
5316 {
5317 arg10 = (int)(SWIG_As_int(obj8));
5318 if (SWIG_arg_fail(10)) SWIG_fail;
5319 }
5320 }
5321 {
5322 if (!wxPyCheckForApp()) SWIG_fail;
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5325
5326 wxPyEndAllowThreads(__tstate);
5327 if (PyErr_Occurred()) SWIG_fail;
5328 }
5329 {
5330 resultobj = SWIG_From_int((int)(result));
5331 }
5332 {
5333 if (temp1)
5334 delete arg1;
5335 }
5336 {
5337 if (temp2)
5338 delete arg2;
5339 }
5340 {
5341 if (arg4) delete [] arg4;
5342 }
5343 return resultobj;
5344 fail:
5345 {
5346 if (temp1)
5347 delete arg1;
5348 }
5349 {
5350 if (temp2)
5351 delete arg2;
5352 }
5353 {
5354 if (arg4) delete [] arg4;
5355 }
5356 return NULL;
5357 }
5358
5359
5360 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5361 PyObject *resultobj;
5362 wxString *arg1 = 0 ;
5363 wxString const &arg2_defvalue = wxPyEmptyString ;
5364 wxString *arg2 = (wxString *) &arg2_defvalue ;
5365 int arg3 = (int) wxOK|wxCENTRE ;
5366 wxWindow *arg4 = (wxWindow *) NULL ;
5367 int arg5 = (int) -1 ;
5368 int arg6 = (int) -1 ;
5369 int result;
5370 bool temp1 = false ;
5371 bool temp2 = false ;
5372 PyObject * obj0 = 0 ;
5373 PyObject * obj1 = 0 ;
5374 PyObject * obj2 = 0 ;
5375 PyObject * obj3 = 0 ;
5376 PyObject * obj4 = 0 ;
5377 PyObject * obj5 = 0 ;
5378 char *kwnames[] = {
5379 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5380 };
5381
5382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5383 {
5384 arg1 = wxString_in_helper(obj0);
5385 if (arg1 == NULL) SWIG_fail;
5386 temp1 = true;
5387 }
5388 if (obj1) {
5389 {
5390 arg2 = wxString_in_helper(obj1);
5391 if (arg2 == NULL) SWIG_fail;
5392 temp2 = true;
5393 }
5394 }
5395 if (obj2) {
5396 {
5397 arg3 = (int)(SWIG_As_int(obj2));
5398 if (SWIG_arg_fail(3)) SWIG_fail;
5399 }
5400 }
5401 if (obj3) {
5402 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5403 if (SWIG_arg_fail(4)) SWIG_fail;
5404 }
5405 if (obj4) {
5406 {
5407 arg5 = (int)(SWIG_As_int(obj4));
5408 if (SWIG_arg_fail(5)) SWIG_fail;
5409 }
5410 }
5411 if (obj5) {
5412 {
5413 arg6 = (int)(SWIG_As_int(obj5));
5414 if (SWIG_arg_fail(6)) SWIG_fail;
5415 }
5416 }
5417 {
5418 if (!wxPyCheckForApp()) SWIG_fail;
5419 PyThreadState* __tstate = wxPyBeginAllowThreads();
5420 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5421
5422 wxPyEndAllowThreads(__tstate);
5423 if (PyErr_Occurred()) SWIG_fail;
5424 }
5425 {
5426 resultobj = SWIG_From_int((int)(result));
5427 }
5428 {
5429 if (temp1)
5430 delete arg1;
5431 }
5432 {
5433 if (temp2)
5434 delete arg2;
5435 }
5436 return resultobj;
5437 fail:
5438 {
5439 if (temp1)
5440 delete arg1;
5441 }
5442 {
5443 if (temp2)
5444 delete arg2;
5445 }
5446 return NULL;
5447 }
5448
5449
5450 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5451 PyObject *resultobj;
5452 wxString *arg1 = 0 ;
5453 wxString *arg2 = 0 ;
5454 wxString *arg3 = 0 ;
5455 long arg4 ;
5456 long arg5 = (long) 0 ;
5457 long arg6 = (long) 100 ;
5458 wxWindow *arg7 = (wxWindow *) NULL ;
5459 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5460 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5461 long result;
5462 bool temp1 = false ;
5463 bool temp2 = false ;
5464 bool temp3 = false ;
5465 wxPoint temp8 ;
5466 PyObject * obj0 = 0 ;
5467 PyObject * obj1 = 0 ;
5468 PyObject * obj2 = 0 ;
5469 PyObject * obj3 = 0 ;
5470 PyObject * obj4 = 0 ;
5471 PyObject * obj5 = 0 ;
5472 PyObject * obj6 = 0 ;
5473 PyObject * obj7 = 0 ;
5474 char *kwnames[] = {
5475 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5476 };
5477
5478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5479 {
5480 arg1 = wxString_in_helper(obj0);
5481 if (arg1 == NULL) SWIG_fail;
5482 temp1 = true;
5483 }
5484 {
5485 arg2 = wxString_in_helper(obj1);
5486 if (arg2 == NULL) SWIG_fail;
5487 temp2 = true;
5488 }
5489 {
5490 arg3 = wxString_in_helper(obj2);
5491 if (arg3 == NULL) SWIG_fail;
5492 temp3 = true;
5493 }
5494 {
5495 arg4 = (long)(SWIG_As_long(obj3));
5496 if (SWIG_arg_fail(4)) SWIG_fail;
5497 }
5498 if (obj4) {
5499 {
5500 arg5 = (long)(SWIG_As_long(obj4));
5501 if (SWIG_arg_fail(5)) SWIG_fail;
5502 }
5503 }
5504 if (obj5) {
5505 {
5506 arg6 = (long)(SWIG_As_long(obj5));
5507 if (SWIG_arg_fail(6)) SWIG_fail;
5508 }
5509 }
5510 if (obj6) {
5511 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5512 if (SWIG_arg_fail(7)) SWIG_fail;
5513 }
5514 if (obj7) {
5515 {
5516 arg8 = &temp8;
5517 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5518 }
5519 }
5520 {
5521 if (!wxPyCheckForApp()) SWIG_fail;
5522 PyThreadState* __tstate = wxPyBeginAllowThreads();
5523 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5524
5525 wxPyEndAllowThreads(__tstate);
5526 if (PyErr_Occurred()) SWIG_fail;
5527 }
5528 {
5529 resultobj = SWIG_From_long((long)(result));
5530 }
5531 {
5532 if (temp1)
5533 delete arg1;
5534 }
5535 {
5536 if (temp2)
5537 delete arg2;
5538 }
5539 {
5540 if (temp3)
5541 delete arg3;
5542 }
5543 return resultobj;
5544 fail:
5545 {
5546 if (temp1)
5547 delete arg1;
5548 }
5549 {
5550 if (temp2)
5551 delete arg2;
5552 }
5553 {
5554 if (temp3)
5555 delete arg3;
5556 }
5557 return NULL;
5558 }
5559
5560
5561 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5562 PyObject *resultobj;
5563 bool result;
5564 char *kwnames[] = {
5565 NULL
5566 };
5567
5568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5569 {
5570 if (!wxPyCheckForApp()) SWIG_fail;
5571 PyThreadState* __tstate = wxPyBeginAllowThreads();
5572 result = (bool)wxColourDisplay();
5573
5574 wxPyEndAllowThreads(__tstate);
5575 if (PyErr_Occurred()) SWIG_fail;
5576 }
5577 {
5578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5579 }
5580 return resultobj;
5581 fail:
5582 return NULL;
5583 }
5584
5585
5586 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5587 PyObject *resultobj;
5588 int result;
5589 char *kwnames[] = {
5590 NULL
5591 };
5592
5593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5594 {
5595 if (!wxPyCheckForApp()) SWIG_fail;
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 result = (int)wxDisplayDepth();
5598
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 {
5603 resultobj = SWIG_From_int((int)(result));
5604 }
5605 return resultobj;
5606 fail:
5607 return NULL;
5608 }
5609
5610
5611 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5612 PyObject *resultobj;
5613 int result;
5614 char *kwnames[] = {
5615 NULL
5616 };
5617
5618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5619 {
5620 if (!wxPyCheckForApp()) SWIG_fail;
5621 PyThreadState* __tstate = wxPyBeginAllowThreads();
5622 result = (int)wxGetDisplayDepth();
5623
5624 wxPyEndAllowThreads(__tstate);
5625 if (PyErr_Occurred()) SWIG_fail;
5626 }
5627 {
5628 resultobj = SWIG_From_int((int)(result));
5629 }
5630 return resultobj;
5631 fail:
5632 return NULL;
5633 }
5634
5635
5636 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5637 PyObject *resultobj;
5638 int *arg1 = (int *) 0 ;
5639 int *arg2 = (int *) 0 ;
5640 int temp1 ;
5641 int res1 = 0 ;
5642 int temp2 ;
5643 int res2 = 0 ;
5644 char *kwnames[] = {
5645 NULL
5646 };
5647
5648 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5649 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5651 {
5652 if (!wxPyCheckForApp()) SWIG_fail;
5653 PyThreadState* __tstate = wxPyBeginAllowThreads();
5654 wxDisplaySize(arg1,arg2);
5655
5656 wxPyEndAllowThreads(__tstate);
5657 if (PyErr_Occurred()) SWIG_fail;
5658 }
5659 Py_INCREF(Py_None); resultobj = Py_None;
5660 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5661 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5662 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5663 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5664 return resultobj;
5665 fail:
5666 return NULL;
5667 }
5668
5669
5670 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5671 PyObject *resultobj;
5672 wxSize result;
5673 char *kwnames[] = {
5674 NULL
5675 };
5676
5677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5678 {
5679 if (!wxPyCheckForApp()) SWIG_fail;
5680 PyThreadState* __tstate = wxPyBeginAllowThreads();
5681 result = wxGetDisplaySize();
5682
5683 wxPyEndAllowThreads(__tstate);
5684 if (PyErr_Occurred()) SWIG_fail;
5685 }
5686 {
5687 wxSize * resultptr;
5688 resultptr = new wxSize((wxSize &)(result));
5689 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5690 }
5691 return resultobj;
5692 fail:
5693 return NULL;
5694 }
5695
5696
5697 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5698 PyObject *resultobj;
5699 int *arg1 = (int *) 0 ;
5700 int *arg2 = (int *) 0 ;
5701 int temp1 ;
5702 int res1 = 0 ;
5703 int temp2 ;
5704 int res2 = 0 ;
5705 char *kwnames[] = {
5706 NULL
5707 };
5708
5709 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5710 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5712 {
5713 if (!wxPyCheckForApp()) SWIG_fail;
5714 PyThreadState* __tstate = wxPyBeginAllowThreads();
5715 wxDisplaySizeMM(arg1,arg2);
5716
5717 wxPyEndAllowThreads(__tstate);
5718 if (PyErr_Occurred()) SWIG_fail;
5719 }
5720 Py_INCREF(Py_None); resultobj = Py_None;
5721 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5722 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5723 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5724 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5725 return resultobj;
5726 fail:
5727 return NULL;
5728 }
5729
5730
5731 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5732 PyObject *resultobj;
5733 wxSize result;
5734 char *kwnames[] = {
5735 NULL
5736 };
5737
5738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5739 {
5740 if (!wxPyCheckForApp()) SWIG_fail;
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 result = wxGetDisplaySizeMM();
5743
5744 wxPyEndAllowThreads(__tstate);
5745 if (PyErr_Occurred()) SWIG_fail;
5746 }
5747 {
5748 wxSize * resultptr;
5749 resultptr = new wxSize((wxSize &)(result));
5750 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5751 }
5752 return resultobj;
5753 fail:
5754 return NULL;
5755 }
5756
5757
5758 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5759 PyObject *resultobj;
5760 int *arg1 = (int *) 0 ;
5761 int *arg2 = (int *) 0 ;
5762 int *arg3 = (int *) 0 ;
5763 int *arg4 = (int *) 0 ;
5764 int temp1 ;
5765 int res1 = 0 ;
5766 int temp2 ;
5767 int res2 = 0 ;
5768 int temp3 ;
5769 int res3 = 0 ;
5770 int temp4 ;
5771 int res4 = 0 ;
5772 char *kwnames[] = {
5773 NULL
5774 };
5775
5776 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5777 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5778 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5779 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5781 {
5782 if (!wxPyCheckForApp()) SWIG_fail;
5783 PyThreadState* __tstate = wxPyBeginAllowThreads();
5784 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5785
5786 wxPyEndAllowThreads(__tstate);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 Py_INCREF(Py_None); resultobj = Py_None;
5790 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5791 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5792 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5793 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5794 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5795 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5796 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5797 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5798 return resultobj;
5799 fail:
5800 return NULL;
5801 }
5802
5803
5804 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5805 PyObject *resultobj;
5806 wxRect result;
5807 char *kwnames[] = {
5808 NULL
5809 };
5810
5811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5812 {
5813 if (!wxPyCheckForApp()) SWIG_fail;
5814 PyThreadState* __tstate = wxPyBeginAllowThreads();
5815 result = wxGetClientDisplayRect();
5816
5817 wxPyEndAllowThreads(__tstate);
5818 if (PyErr_Occurred()) SWIG_fail;
5819 }
5820 {
5821 wxRect * resultptr;
5822 resultptr = new wxRect((wxRect &)(result));
5823 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5824 }
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj;
5833 wxCursor *arg1 = 0 ;
5834 PyObject * obj0 = 0 ;
5835 char *kwnames[] = {
5836 (char *) "cursor", NULL
5837 };
5838
5839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5840 {
5841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5842 if (SWIG_arg_fail(1)) SWIG_fail;
5843 if (arg1 == NULL) {
5844 SWIG_null_ref("wxCursor");
5845 }
5846 if (SWIG_arg_fail(1)) SWIG_fail;
5847 }
5848 {
5849 if (!wxPyCheckForApp()) SWIG_fail;
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 wxSetCursor(*arg1);
5852
5853 wxPyEndAllowThreads(__tstate);
5854 if (PyErr_Occurred()) SWIG_fail;
5855 }
5856 Py_INCREF(Py_None); resultobj = Py_None;
5857 return resultobj;
5858 fail:
5859 return NULL;
5860 }
5861
5862
5863 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5864 PyObject *resultobj;
5865 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5866 PyObject * obj0 = 0 ;
5867 char *kwnames[] = {
5868 (char *) "cursor", NULL
5869 };
5870
5871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5872 if (obj0) {
5873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5874 if (SWIG_arg_fail(1)) SWIG_fail;
5875 }
5876 {
5877 if (!wxPyCheckForApp()) SWIG_fail;
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 wxBeginBusyCursor(arg1);
5880
5881 wxPyEndAllowThreads(__tstate);
5882 if (PyErr_Occurred()) SWIG_fail;
5883 }
5884 Py_INCREF(Py_None); resultobj = Py_None;
5885 return resultobj;
5886 fail:
5887 return NULL;
5888 }
5889
5890
5891 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5892 PyObject *resultobj;
5893 wxWindow *result;
5894 char *kwnames[] = {
5895 NULL
5896 };
5897
5898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5899 {
5900 if (!wxPyCheckForApp()) SWIG_fail;
5901 PyThreadState* __tstate = wxPyBeginAllowThreads();
5902 result = (wxWindow *)wxGetActiveWindow();
5903
5904 wxPyEndAllowThreads(__tstate);
5905 if (PyErr_Occurred()) SWIG_fail;
5906 }
5907 {
5908 resultobj = wxPyMake_wxObject(result, 0);
5909 }
5910 return resultobj;
5911 fail:
5912 return NULL;
5913 }
5914
5915
5916 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5917 PyObject *resultobj;
5918 wxPoint *arg1 = 0 ;
5919 wxWindow *result;
5920 wxPoint temp1 ;
5921 PyObject * obj0 = 0 ;
5922 char *kwnames[] = {
5923 (char *) "pt", NULL
5924 };
5925
5926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5927 {
5928 arg1 = &temp1;
5929 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5930 }
5931 {
5932 if (!wxPyCheckForApp()) SWIG_fail;
5933 PyThreadState* __tstate = wxPyBeginAllowThreads();
5934 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5935
5936 wxPyEndAllowThreads(__tstate);
5937 if (PyErr_Occurred()) SWIG_fail;
5938 }
5939 {
5940 resultobj = wxPyMake_wxObject(result, 0);
5941 }
5942 return resultobj;
5943 fail:
5944 return NULL;
5945 }
5946
5947
5948 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5949 PyObject *resultobj;
5950 wxPoint *arg1 = 0 ;
5951 wxWindow *result;
5952 wxPoint temp1 ;
5953 PyObject * obj0 = 0 ;
5954 char *kwnames[] = {
5955 (char *) "pt", NULL
5956 };
5957
5958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5959 {
5960 arg1 = &temp1;
5961 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5962 }
5963 {
5964 if (!wxPyCheckForApp()) SWIG_fail;
5965 PyThreadState* __tstate = wxPyBeginAllowThreads();
5966 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5967
5968 wxPyEndAllowThreads(__tstate);
5969 if (PyErr_Occurred()) SWIG_fail;
5970 }
5971 {
5972 resultobj = wxPyMake_wxObject(result, 0);
5973 }
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5981 PyObject *resultobj;
5982 wxWindow *arg1 = (wxWindow *) 0 ;
5983 wxWindow *result;
5984 PyObject * obj0 = 0 ;
5985 char *kwnames[] = {
5986 (char *) "win", NULL
5987 };
5988
5989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5991 if (SWIG_arg_fail(1)) SWIG_fail;
5992 {
5993 if (!wxPyCheckForApp()) SWIG_fail;
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 result = (wxWindow *)wxGetTopLevelParent(arg1);
5996
5997 wxPyEndAllowThreads(__tstate);
5998 if (PyErr_Occurred()) SWIG_fail;
5999 }
6000 {
6001 resultobj = wxPyMake_wxObject(result, 0);
6002 }
6003 return resultobj;
6004 fail:
6005 return NULL;
6006 }
6007
6008
6009 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj;
6011 wxKeyCode arg1 ;
6012 bool result;
6013 PyObject * obj0 = 0 ;
6014 char *kwnames[] = {
6015 (char *) "key", NULL
6016 };
6017
6018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6019 {
6020 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6021 if (SWIG_arg_fail(1)) SWIG_fail;
6022 }
6023 {
6024 if (!wxPyCheckForApp()) SWIG_fail;
6025 PyThreadState* __tstate = wxPyBeginAllowThreads();
6026 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6027
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 {
6032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6033 }
6034 return resultobj;
6035 fail:
6036 return NULL;
6037 }
6038
6039
6040 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6041 PyObject *resultobj;
6042 char *kwnames[] = {
6043 NULL
6044 };
6045
6046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6047 {
6048 if (!wxPyCheckForApp()) SWIG_fail;
6049 PyThreadState* __tstate = wxPyBeginAllowThreads();
6050 wxWakeUpMainThread();
6051
6052 wxPyEndAllowThreads(__tstate);
6053 if (PyErr_Occurred()) SWIG_fail;
6054 }
6055 Py_INCREF(Py_None); resultobj = Py_None;
6056 return resultobj;
6057 fail:
6058 return NULL;
6059 }
6060
6061
6062 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6063 PyObject *resultobj;
6064 char *kwnames[] = {
6065 NULL
6066 };
6067
6068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6069 {
6070 if (!wxPyCheckForApp()) SWIG_fail;
6071 PyThreadState* __tstate = wxPyBeginAllowThreads();
6072 wxMutexGuiEnter();
6073
6074 wxPyEndAllowThreads(__tstate);
6075 if (PyErr_Occurred()) SWIG_fail;
6076 }
6077 Py_INCREF(Py_None); resultobj = Py_None;
6078 return resultobj;
6079 fail:
6080 return NULL;
6081 }
6082
6083
6084 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj;
6086 char *kwnames[] = {
6087 NULL
6088 };
6089
6090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6091 {
6092 if (!wxPyCheckForApp()) SWIG_fail;
6093 PyThreadState* __tstate = wxPyBeginAllowThreads();
6094 wxMutexGuiLeave();
6095
6096 wxPyEndAllowThreads(__tstate);
6097 if (PyErr_Occurred()) SWIG_fail;
6098 }
6099 Py_INCREF(Py_None); resultobj = Py_None;
6100 return resultobj;
6101 fail:
6102 return NULL;
6103 }
6104
6105
6106 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6107 PyObject *resultobj;
6108 wxMutexGuiLocker *result;
6109 char *kwnames[] = {
6110 NULL
6111 };
6112
6113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6114 {
6115 if (!wxPyCheckForApp()) SWIG_fail;
6116 PyThreadState* __tstate = wxPyBeginAllowThreads();
6117 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6118
6119 wxPyEndAllowThreads(__tstate);
6120 if (PyErr_Occurred()) SWIG_fail;
6121 }
6122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6123 return resultobj;
6124 fail:
6125 return NULL;
6126 }
6127
6128
6129 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6130 PyObject *resultobj;
6131 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6132 PyObject * obj0 = 0 ;
6133 char *kwnames[] = {
6134 (char *) "self", NULL
6135 };
6136
6137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6139 if (SWIG_arg_fail(1)) SWIG_fail;
6140 {
6141 PyThreadState* __tstate = wxPyBeginAllowThreads();
6142 delete arg1;
6143
6144 wxPyEndAllowThreads(__tstate);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 Py_INCREF(Py_None); resultobj = Py_None;
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6155 PyObject *obj;
6156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6157 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6158 Py_INCREF(obj);
6159 return Py_BuildValue((char *)"");
6160 }
6161 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6162 PyObject *resultobj;
6163 bool result;
6164 char *kwnames[] = {
6165 NULL
6166 };
6167
6168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6169 {
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 result = (bool)wxThread_IsMain();
6172
6173 wxPyEndAllowThreads(__tstate);
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 {
6177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6178 }
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj;
6187 wxString *arg1 = 0 ;
6188 wxToolTip *result;
6189 bool temp1 = false ;
6190 PyObject * obj0 = 0 ;
6191 char *kwnames[] = {
6192 (char *) "tip", NULL
6193 };
6194
6195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6196 {
6197 arg1 = wxString_in_helper(obj0);
6198 if (arg1 == NULL) SWIG_fail;
6199 temp1 = true;
6200 }
6201 {
6202 if (!wxPyCheckForApp()) SWIG_fail;
6203 PyThreadState* __tstate = wxPyBeginAllowThreads();
6204 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6205
6206 wxPyEndAllowThreads(__tstate);
6207 if (PyErr_Occurred()) SWIG_fail;
6208 }
6209 {
6210 resultobj = wxPyMake_wxObject(result, 1);
6211 }
6212 {
6213 if (temp1)
6214 delete arg1;
6215 }
6216 return resultobj;
6217 fail:
6218 {
6219 if (temp1)
6220 delete arg1;
6221 }
6222 return NULL;
6223 }
6224
6225
6226 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6227 PyObject *resultobj;
6228 wxToolTip *arg1 = (wxToolTip *) 0 ;
6229 wxString *arg2 = 0 ;
6230 bool temp2 = false ;
6231 PyObject * obj0 = 0 ;
6232 PyObject * obj1 = 0 ;
6233 char *kwnames[] = {
6234 (char *) "self",(char *) "tip", NULL
6235 };
6236
6237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6239 if (SWIG_arg_fail(1)) SWIG_fail;
6240 {
6241 arg2 = wxString_in_helper(obj1);
6242 if (arg2 == NULL) SWIG_fail;
6243 temp2 = true;
6244 }
6245 {
6246 PyThreadState* __tstate = wxPyBeginAllowThreads();
6247 (arg1)->SetTip((wxString const &)*arg2);
6248
6249 wxPyEndAllowThreads(__tstate);
6250 if (PyErr_Occurred()) SWIG_fail;
6251 }
6252 Py_INCREF(Py_None); resultobj = Py_None;
6253 {
6254 if (temp2)
6255 delete arg2;
6256 }
6257 return resultobj;
6258 fail:
6259 {
6260 if (temp2)
6261 delete arg2;
6262 }
6263 return NULL;
6264 }
6265
6266
6267 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj;
6269 wxToolTip *arg1 = (wxToolTip *) 0 ;
6270 wxString result;
6271 PyObject * obj0 = 0 ;
6272 char *kwnames[] = {
6273 (char *) "self", NULL
6274 };
6275
6276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6278 if (SWIG_arg_fail(1)) SWIG_fail;
6279 {
6280 PyThreadState* __tstate = wxPyBeginAllowThreads();
6281 result = (arg1)->GetTip();
6282
6283 wxPyEndAllowThreads(__tstate);
6284 if (PyErr_Occurred()) SWIG_fail;
6285 }
6286 {
6287 #if wxUSE_UNICODE
6288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6289 #else
6290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6291 #endif
6292 }
6293 return resultobj;
6294 fail:
6295 return NULL;
6296 }
6297
6298
6299 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6300 PyObject *resultobj;
6301 wxToolTip *arg1 = (wxToolTip *) 0 ;
6302 wxWindow *result;
6303 PyObject * obj0 = 0 ;
6304 char *kwnames[] = {
6305 (char *) "self", NULL
6306 };
6307
6308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6310 if (SWIG_arg_fail(1)) SWIG_fail;
6311 {
6312 PyThreadState* __tstate = wxPyBeginAllowThreads();
6313 result = (wxWindow *)(arg1)->GetWindow();
6314
6315 wxPyEndAllowThreads(__tstate);
6316 if (PyErr_Occurred()) SWIG_fail;
6317 }
6318 {
6319 resultobj = wxPyMake_wxObject(result, 0);
6320 }
6321 return resultobj;
6322 fail:
6323 return NULL;
6324 }
6325
6326
6327 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6328 PyObject *resultobj;
6329 bool arg1 ;
6330 PyObject * obj0 = 0 ;
6331 char *kwnames[] = {
6332 (char *) "flag", NULL
6333 };
6334
6335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6336 {
6337 arg1 = (bool)(SWIG_As_bool(obj0));
6338 if (SWIG_arg_fail(1)) SWIG_fail;
6339 }
6340 {
6341 PyThreadState* __tstate = wxPyBeginAllowThreads();
6342 wxToolTip::Enable(arg1);
6343
6344 wxPyEndAllowThreads(__tstate);
6345 if (PyErr_Occurred()) SWIG_fail;
6346 }
6347 Py_INCREF(Py_None); resultobj = Py_None;
6348 return resultobj;
6349 fail:
6350 return NULL;
6351 }
6352
6353
6354 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6355 PyObject *resultobj;
6356 long arg1 ;
6357 PyObject * obj0 = 0 ;
6358 char *kwnames[] = {
6359 (char *) "milliseconds", NULL
6360 };
6361
6362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6363 {
6364 arg1 = (long)(SWIG_As_long(obj0));
6365 if (SWIG_arg_fail(1)) SWIG_fail;
6366 }
6367 {
6368 PyThreadState* __tstate = wxPyBeginAllowThreads();
6369 wxToolTip::SetDelay(arg1);
6370
6371 wxPyEndAllowThreads(__tstate);
6372 if (PyErr_Occurred()) SWIG_fail;
6373 }
6374 Py_INCREF(Py_None); resultobj = Py_None;
6375 return resultobj;
6376 fail:
6377 return NULL;
6378 }
6379
6380
6381 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6382 PyObject *obj;
6383 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6384 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6385 Py_INCREF(obj);
6386 return Py_BuildValue((char *)"");
6387 }
6388 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6389 PyObject *resultobj;
6390 wxWindow *arg1 = (wxWindow *) 0 ;
6391 wxSize *arg2 = 0 ;
6392 wxCaret *result;
6393 wxSize temp2 ;
6394 PyObject * obj0 = 0 ;
6395 PyObject * obj1 = 0 ;
6396 char *kwnames[] = {
6397 (char *) "window",(char *) "size", NULL
6398 };
6399
6400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6402 if (SWIG_arg_fail(1)) SWIG_fail;
6403 {
6404 arg2 = &temp2;
6405 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6406 }
6407 {
6408 if (!wxPyCheckForApp()) SWIG_fail;
6409 PyThreadState* __tstate = wxPyBeginAllowThreads();
6410 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6411
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj;
6424 wxCaret *arg1 = (wxCaret *) 0 ;
6425 PyObject * obj0 = 0 ;
6426 char *kwnames[] = {
6427 (char *) "self", NULL
6428 };
6429
6430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6432 if (SWIG_arg_fail(1)) SWIG_fail;
6433 {
6434 PyThreadState* __tstate = wxPyBeginAllowThreads();
6435 wxCaret_Destroy(arg1);
6436
6437 wxPyEndAllowThreads(__tstate);
6438 if (PyErr_Occurred()) SWIG_fail;
6439 }
6440 Py_INCREF(Py_None); resultobj = Py_None;
6441 return resultobj;
6442 fail:
6443 return NULL;
6444 }
6445
6446
6447 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6448 PyObject *resultobj;
6449 wxCaret *arg1 = (wxCaret *) 0 ;
6450 bool result;
6451 PyObject * obj0 = 0 ;
6452 char *kwnames[] = {
6453 (char *) "self", NULL
6454 };
6455
6456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6458 if (SWIG_arg_fail(1)) SWIG_fail;
6459 {
6460 PyThreadState* __tstate = wxPyBeginAllowThreads();
6461 result = (bool)(arg1)->IsOk();
6462
6463 wxPyEndAllowThreads(__tstate);
6464 if (PyErr_Occurred()) SWIG_fail;
6465 }
6466 {
6467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6468 }
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6476 PyObject *resultobj;
6477 wxCaret *arg1 = (wxCaret *) 0 ;
6478 bool result;
6479 PyObject * obj0 = 0 ;
6480 char *kwnames[] = {
6481 (char *) "self", NULL
6482 };
6483
6484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6486 if (SWIG_arg_fail(1)) SWIG_fail;
6487 {
6488 PyThreadState* __tstate = wxPyBeginAllowThreads();
6489 result = (bool)(arg1)->IsVisible();
6490
6491 wxPyEndAllowThreads(__tstate);
6492 if (PyErr_Occurred()) SWIG_fail;
6493 }
6494 {
6495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6496 }
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj;
6505 wxCaret *arg1 = (wxCaret *) 0 ;
6506 wxPoint result;
6507 PyObject * obj0 = 0 ;
6508 char *kwnames[] = {
6509 (char *) "self", NULL
6510 };
6511
6512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6514 if (SWIG_arg_fail(1)) SWIG_fail;
6515 {
6516 PyThreadState* __tstate = wxPyBeginAllowThreads();
6517 result = (arg1)->GetPosition();
6518
6519 wxPyEndAllowThreads(__tstate);
6520 if (PyErr_Occurred()) SWIG_fail;
6521 }
6522 {
6523 wxPoint * resultptr;
6524 resultptr = new wxPoint((wxPoint &)(result));
6525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6526 }
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj;
6535 wxCaret *arg1 = (wxCaret *) 0 ;
6536 int *arg2 = (int *) 0 ;
6537 int *arg3 = (int *) 0 ;
6538 int temp2 ;
6539 int res2 = 0 ;
6540 int temp3 ;
6541 int res3 = 0 ;
6542 PyObject * obj0 = 0 ;
6543 char *kwnames[] = {
6544 (char *) "self", NULL
6545 };
6546
6547 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6548 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6551 if (SWIG_arg_fail(1)) SWIG_fail;
6552 {
6553 PyThreadState* __tstate = wxPyBeginAllowThreads();
6554 (arg1)->GetPosition(arg2,arg3);
6555
6556 wxPyEndAllowThreads(__tstate);
6557 if (PyErr_Occurred()) SWIG_fail;
6558 }
6559 Py_INCREF(Py_None); resultobj = Py_None;
6560 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6561 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6562 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6563 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj;
6572 wxCaret *arg1 = (wxCaret *) 0 ;
6573 wxSize result;
6574 PyObject * obj0 = 0 ;
6575 char *kwnames[] = {
6576 (char *) "self", NULL
6577 };
6578
6579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6581 if (SWIG_arg_fail(1)) SWIG_fail;
6582 {
6583 PyThreadState* __tstate = wxPyBeginAllowThreads();
6584 result = (arg1)->GetSize();
6585
6586 wxPyEndAllowThreads(__tstate);
6587 if (PyErr_Occurred()) SWIG_fail;
6588 }
6589 {
6590 wxSize * resultptr;
6591 resultptr = new wxSize((wxSize &)(result));
6592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6593 }
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj;
6602 wxCaret *arg1 = (wxCaret *) 0 ;
6603 int *arg2 = (int *) 0 ;
6604 int *arg3 = (int *) 0 ;
6605 int temp2 ;
6606 int res2 = 0 ;
6607 int temp3 ;
6608 int res3 = 0 ;
6609 PyObject * obj0 = 0 ;
6610 char *kwnames[] = {
6611 (char *) "self", NULL
6612 };
6613
6614 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6615 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6618 if (SWIG_arg_fail(1)) SWIG_fail;
6619 {
6620 PyThreadState* __tstate = wxPyBeginAllowThreads();
6621 (arg1)->GetSize(arg2,arg3);
6622
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 Py_INCREF(Py_None); resultobj = Py_None;
6627 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6628 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6629 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6630 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6631 return resultobj;
6632 fail:
6633 return NULL;
6634 }
6635
6636
6637 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6638 PyObject *resultobj;
6639 wxCaret *arg1 = (wxCaret *) 0 ;
6640 wxWindow *result;
6641 PyObject * obj0 = 0 ;
6642 char *kwnames[] = {
6643 (char *) "self", NULL
6644 };
6645
6646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(1)) SWIG_fail;
6649 {
6650 PyThreadState* __tstate = wxPyBeginAllowThreads();
6651 result = (wxWindow *)(arg1)->GetWindow();
6652
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 {
6657 resultobj = wxPyMake_wxObject(result, 0);
6658 }
6659 return resultobj;
6660 fail:
6661 return NULL;
6662 }
6663
6664
6665 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6666 PyObject *resultobj;
6667 wxCaret *arg1 = (wxCaret *) 0 ;
6668 int arg2 ;
6669 int arg3 ;
6670 PyObject * obj0 = 0 ;
6671 PyObject * obj1 = 0 ;
6672 PyObject * obj2 = 0 ;
6673 char *kwnames[] = {
6674 (char *) "self",(char *) "x",(char *) "y", NULL
6675 };
6676
6677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6679 if (SWIG_arg_fail(1)) SWIG_fail;
6680 {
6681 arg2 = (int)(SWIG_As_int(obj1));
6682 if (SWIG_arg_fail(2)) SWIG_fail;
6683 }
6684 {
6685 arg3 = (int)(SWIG_As_int(obj2));
6686 if (SWIG_arg_fail(3)) SWIG_fail;
6687 }
6688 {
6689 PyThreadState* __tstate = wxPyBeginAllowThreads();
6690 (arg1)->Move(arg2,arg3);
6691
6692 wxPyEndAllowThreads(__tstate);
6693 if (PyErr_Occurred()) SWIG_fail;
6694 }
6695 Py_INCREF(Py_None); resultobj = Py_None;
6696 return resultobj;
6697 fail:
6698 return NULL;
6699 }
6700
6701
6702 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6703 PyObject *resultobj;
6704 wxCaret *arg1 = (wxCaret *) 0 ;
6705 wxPoint *arg2 = 0 ;
6706 wxPoint temp2 ;
6707 PyObject * obj0 = 0 ;
6708 PyObject * obj1 = 0 ;
6709 char *kwnames[] = {
6710 (char *) "self",(char *) "pt", NULL
6711 };
6712
6713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6715 if (SWIG_arg_fail(1)) SWIG_fail;
6716 {
6717 arg2 = &temp2;
6718 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6719 }
6720 {
6721 PyThreadState* __tstate = wxPyBeginAllowThreads();
6722 (arg1)->Move((wxPoint const &)*arg2);
6723
6724 wxPyEndAllowThreads(__tstate);
6725 if (PyErr_Occurred()) SWIG_fail;
6726 }
6727 Py_INCREF(Py_None); resultobj = Py_None;
6728 return resultobj;
6729 fail:
6730 return NULL;
6731 }
6732
6733
6734 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6735 PyObject *resultobj;
6736 wxCaret *arg1 = (wxCaret *) 0 ;
6737 int arg2 ;
6738 int arg3 ;
6739 PyObject * obj0 = 0 ;
6740 PyObject * obj1 = 0 ;
6741 PyObject * obj2 = 0 ;
6742 char *kwnames[] = {
6743 (char *) "self",(char *) "width",(char *) "height", NULL
6744 };
6745
6746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6748 if (SWIG_arg_fail(1)) SWIG_fail;
6749 {
6750 arg2 = (int)(SWIG_As_int(obj1));
6751 if (SWIG_arg_fail(2)) SWIG_fail;
6752 }
6753 {
6754 arg3 = (int)(SWIG_As_int(obj2));
6755 if (SWIG_arg_fail(3)) SWIG_fail;
6756 }
6757 {
6758 PyThreadState* __tstate = wxPyBeginAllowThreads();
6759 (arg1)->SetSize(arg2,arg3);
6760
6761 wxPyEndAllowThreads(__tstate);
6762 if (PyErr_Occurred()) SWIG_fail;
6763 }
6764 Py_INCREF(Py_None); resultobj = Py_None;
6765 return resultobj;
6766 fail:
6767 return NULL;
6768 }
6769
6770
6771 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6772 PyObject *resultobj;
6773 wxCaret *arg1 = (wxCaret *) 0 ;
6774 wxSize *arg2 = 0 ;
6775 wxSize temp2 ;
6776 PyObject * obj0 = 0 ;
6777 PyObject * obj1 = 0 ;
6778 char *kwnames[] = {
6779 (char *) "self",(char *) "size", NULL
6780 };
6781
6782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6784 if (SWIG_arg_fail(1)) SWIG_fail;
6785 {
6786 arg2 = &temp2;
6787 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6788 }
6789 {
6790 PyThreadState* __tstate = wxPyBeginAllowThreads();
6791 (arg1)->SetSize((wxSize const &)*arg2);
6792
6793 wxPyEndAllowThreads(__tstate);
6794 if (PyErr_Occurred()) SWIG_fail;
6795 }
6796 Py_INCREF(Py_None); resultobj = Py_None;
6797 return resultobj;
6798 fail:
6799 return NULL;
6800 }
6801
6802
6803 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6804 PyObject *resultobj;
6805 wxCaret *arg1 = (wxCaret *) 0 ;
6806 int arg2 = (int) true ;
6807 PyObject * obj0 = 0 ;
6808 PyObject * obj1 = 0 ;
6809 char *kwnames[] = {
6810 (char *) "self",(char *) "show", NULL
6811 };
6812
6813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6815 if (SWIG_arg_fail(1)) SWIG_fail;
6816 if (obj1) {
6817 {
6818 arg2 = (int)(SWIG_As_int(obj1));
6819 if (SWIG_arg_fail(2)) SWIG_fail;
6820 }
6821 }
6822 {
6823 PyThreadState* __tstate = wxPyBeginAllowThreads();
6824 (arg1)->Show(arg2);
6825
6826 wxPyEndAllowThreads(__tstate);
6827 if (PyErr_Occurred()) SWIG_fail;
6828 }
6829 Py_INCREF(Py_None); resultobj = Py_None;
6830 return resultobj;
6831 fail:
6832 return NULL;
6833 }
6834
6835
6836 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6837 PyObject *resultobj;
6838 wxCaret *arg1 = (wxCaret *) 0 ;
6839 PyObject * obj0 = 0 ;
6840 char *kwnames[] = {
6841 (char *) "self", NULL
6842 };
6843
6844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6846 if (SWIG_arg_fail(1)) SWIG_fail;
6847 {
6848 PyThreadState* __tstate = wxPyBeginAllowThreads();
6849 (arg1)->Hide();
6850
6851 wxPyEndAllowThreads(__tstate);
6852 if (PyErr_Occurred()) SWIG_fail;
6853 }
6854 Py_INCREF(Py_None); resultobj = Py_None;
6855 return resultobj;
6856 fail:
6857 return NULL;
6858 }
6859
6860
6861 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6862 PyObject *resultobj;
6863 int result;
6864 char *kwnames[] = {
6865 NULL
6866 };
6867
6868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6869 {
6870 PyThreadState* __tstate = wxPyBeginAllowThreads();
6871 result = (int)wxCaret::GetBlinkTime();
6872
6873 wxPyEndAllowThreads(__tstate);
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 {
6877 resultobj = SWIG_From_int((int)(result));
6878 }
6879 return resultobj;
6880 fail:
6881 return NULL;
6882 }
6883
6884
6885 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6886 PyObject *resultobj;
6887 int arg1 ;
6888 PyObject * obj0 = 0 ;
6889 char *kwnames[] = {
6890 (char *) "milliseconds", NULL
6891 };
6892
6893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6894 {
6895 arg1 = (int)(SWIG_As_int(obj0));
6896 if (SWIG_arg_fail(1)) SWIG_fail;
6897 }
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 wxCaret::SetBlinkTime(arg1);
6901
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 Py_INCREF(Py_None); resultobj = Py_None;
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6913 PyObject *obj;
6914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6915 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6916 Py_INCREF(obj);
6917 return Py_BuildValue((char *)"");
6918 }
6919 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6920 PyObject *resultobj;
6921 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6922 wxBusyCursor *result;
6923 PyObject * obj0 = 0 ;
6924 char *kwnames[] = {
6925 (char *) "cursor", NULL
6926 };
6927
6928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6929 if (obj0) {
6930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6931 if (SWIG_arg_fail(1)) SWIG_fail;
6932 }
6933 {
6934 if (!wxPyCheckForApp()) SWIG_fail;
6935 PyThreadState* __tstate = wxPyBeginAllowThreads();
6936 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6937
6938 wxPyEndAllowThreads(__tstate);
6939 if (PyErr_Occurred()) SWIG_fail;
6940 }
6941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj;
6950 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6951 PyObject * obj0 = 0 ;
6952 char *kwnames[] = {
6953 (char *) "self", NULL
6954 };
6955
6956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6958 if (SWIG_arg_fail(1)) SWIG_fail;
6959 {
6960 PyThreadState* __tstate = wxPyBeginAllowThreads();
6961 delete arg1;
6962
6963 wxPyEndAllowThreads(__tstate);
6964 if (PyErr_Occurred()) SWIG_fail;
6965 }
6966 Py_INCREF(Py_None); resultobj = Py_None;
6967 return resultobj;
6968 fail:
6969 return NULL;
6970 }
6971
6972
6973 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6974 PyObject *obj;
6975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6976 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6977 Py_INCREF(obj);
6978 return Py_BuildValue((char *)"");
6979 }
6980 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6981 PyObject *resultobj;
6982 wxWindow *arg1 = (wxWindow *) NULL ;
6983 wxWindowDisabler *result;
6984 PyObject * obj0 = 0 ;
6985 char *kwnames[] = {
6986 (char *) "winToSkip", NULL
6987 };
6988
6989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6990 if (obj0) {
6991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6992 if (SWIG_arg_fail(1)) SWIG_fail;
6993 }
6994 {
6995 if (!wxPyCheckForApp()) SWIG_fail;
6996 PyThreadState* __tstate = wxPyBeginAllowThreads();
6997 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6998
6999 wxPyEndAllowThreads(__tstate);
7000 if (PyErr_Occurred()) SWIG_fail;
7001 }
7002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7010 PyObject *resultobj;
7011 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7012 PyObject * obj0 = 0 ;
7013 char *kwnames[] = {
7014 (char *) "self", NULL
7015 };
7016
7017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7019 if (SWIG_arg_fail(1)) SWIG_fail;
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 delete arg1;
7023
7024 wxPyEndAllowThreads(__tstate);
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 Py_INCREF(Py_None); resultobj = Py_None;
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7035 PyObject *obj;
7036 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7037 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7038 Py_INCREF(obj);
7039 return Py_BuildValue((char *)"");
7040 }
7041 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7042 PyObject *resultobj;
7043 wxString *arg1 = 0 ;
7044 wxBusyInfo *result;
7045 bool temp1 = false ;
7046 PyObject * obj0 = 0 ;
7047 char *kwnames[] = {
7048 (char *) "message", NULL
7049 };
7050
7051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7052 {
7053 arg1 = wxString_in_helper(obj0);
7054 if (arg1 == NULL) SWIG_fail;
7055 temp1 = true;
7056 }
7057 {
7058 if (!wxPyCheckForApp()) SWIG_fail;
7059 PyThreadState* __tstate = wxPyBeginAllowThreads();
7060 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7061
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7066 {
7067 if (temp1)
7068 delete arg1;
7069 }
7070 return resultobj;
7071 fail:
7072 {
7073 if (temp1)
7074 delete arg1;
7075 }
7076 return NULL;
7077 }
7078
7079
7080 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7081 PyObject *resultobj;
7082 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7083 PyObject * obj0 = 0 ;
7084 char *kwnames[] = {
7085 (char *) "self", NULL
7086 };
7087
7088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7090 if (SWIG_arg_fail(1)) SWIG_fail;
7091 {
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 delete arg1;
7094
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 Py_INCREF(Py_None); resultobj = Py_None;
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7106 PyObject *obj;
7107 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7108 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7109 Py_INCREF(obj);
7110 return Py_BuildValue((char *)"");
7111 }
7112 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7113 PyObject *resultobj;
7114 wxStopWatch *result;
7115 char *kwnames[] = {
7116 NULL
7117 };
7118
7119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7120 {
7121 PyThreadState* __tstate = wxPyBeginAllowThreads();
7122 result = (wxStopWatch *)new wxStopWatch();
7123
7124 wxPyEndAllowThreads(__tstate);
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7135 PyObject *resultobj;
7136 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7137 long arg2 = (long) 0 ;
7138 PyObject * obj0 = 0 ;
7139 PyObject * obj1 = 0 ;
7140 char *kwnames[] = {
7141 (char *) "self",(char *) "t0", NULL
7142 };
7143
7144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7146 if (SWIG_arg_fail(1)) SWIG_fail;
7147 if (obj1) {
7148 {
7149 arg2 = (long)(SWIG_As_long(obj1));
7150 if (SWIG_arg_fail(2)) SWIG_fail;
7151 }
7152 }
7153 {
7154 PyThreadState* __tstate = wxPyBeginAllowThreads();
7155 (arg1)->Start(arg2);
7156
7157 wxPyEndAllowThreads(__tstate);
7158 if (PyErr_Occurred()) SWIG_fail;
7159 }
7160 Py_INCREF(Py_None); resultobj = Py_None;
7161 return resultobj;
7162 fail:
7163 return NULL;
7164 }
7165
7166
7167 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7168 PyObject *resultobj;
7169 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7170 PyObject * obj0 = 0 ;
7171 char *kwnames[] = {
7172 (char *) "self", NULL
7173 };
7174
7175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7177 if (SWIG_arg_fail(1)) SWIG_fail;
7178 {
7179 PyThreadState* __tstate = wxPyBeginAllowThreads();
7180 (arg1)->Pause();
7181
7182 wxPyEndAllowThreads(__tstate);
7183 if (PyErr_Occurred()) SWIG_fail;
7184 }
7185 Py_INCREF(Py_None); resultobj = Py_None;
7186 return resultobj;
7187 fail:
7188 return NULL;
7189 }
7190
7191
7192 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7193 PyObject *resultobj;
7194 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7195 PyObject * obj0 = 0 ;
7196 char *kwnames[] = {
7197 (char *) "self", NULL
7198 };
7199
7200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7202 if (SWIG_arg_fail(1)) SWIG_fail;
7203 {
7204 PyThreadState* __tstate = wxPyBeginAllowThreads();
7205 (arg1)->Resume();
7206
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 Py_INCREF(Py_None); resultobj = Py_None;
7211 return resultobj;
7212 fail:
7213 return NULL;
7214 }
7215
7216
7217 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7218 PyObject *resultobj;
7219 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7220 long result;
7221 PyObject * obj0 = 0 ;
7222 char *kwnames[] = {
7223 (char *) "self", NULL
7224 };
7225
7226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7228 if (SWIG_arg_fail(1)) SWIG_fail;
7229 {
7230 PyThreadState* __tstate = wxPyBeginAllowThreads();
7231 result = (long)((wxStopWatch const *)arg1)->Time();
7232
7233 wxPyEndAllowThreads(__tstate);
7234 if (PyErr_Occurred()) SWIG_fail;
7235 }
7236 {
7237 resultobj = SWIG_From_long((long)(result));
7238 }
7239 return resultobj;
7240 fail:
7241 return NULL;
7242 }
7243
7244
7245 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7246 PyObject *obj;
7247 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7248 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7249 Py_INCREF(obj);
7250 return Py_BuildValue((char *)"");
7251 }
7252 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7253 PyObject *resultobj;
7254 int arg1 = (int) 9 ;
7255 int arg2 = (int) wxID_FILE1 ;
7256 wxFileHistory *result;
7257 PyObject * obj0 = 0 ;
7258 PyObject * obj1 = 0 ;
7259 char *kwnames[] = {
7260 (char *) "maxFiles",(char *) "idBase", NULL
7261 };
7262
7263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7264 if (obj0) {
7265 {
7266 arg1 = (int)(SWIG_As_int(obj0));
7267 if (SWIG_arg_fail(1)) SWIG_fail;
7268 }
7269 }
7270 if (obj1) {
7271 {
7272 arg2 = (int)(SWIG_As_int(obj1));
7273 if (SWIG_arg_fail(2)) SWIG_fail;
7274 }
7275 }
7276 {
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7279
7280 wxPyEndAllowThreads(__tstate);
7281 if (PyErr_Occurred()) SWIG_fail;
7282 }
7283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7284 return resultobj;
7285 fail:
7286 return NULL;
7287 }
7288
7289
7290 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7291 PyObject *resultobj;
7292 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7293 PyObject * obj0 = 0 ;
7294 char *kwnames[] = {
7295 (char *) "self", NULL
7296 };
7297
7298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7300 if (SWIG_arg_fail(1)) SWIG_fail;
7301 {
7302 PyThreadState* __tstate = wxPyBeginAllowThreads();
7303 delete arg1;
7304
7305 wxPyEndAllowThreads(__tstate);
7306 if (PyErr_Occurred()) SWIG_fail;
7307 }
7308 Py_INCREF(Py_None); resultobj = Py_None;
7309 return resultobj;
7310 fail:
7311 return NULL;
7312 }
7313
7314
7315 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7316 PyObject *resultobj;
7317 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7318 wxString *arg2 = 0 ;
7319 bool temp2 = false ;
7320 PyObject * obj0 = 0 ;
7321 PyObject * obj1 = 0 ;
7322 char *kwnames[] = {
7323 (char *) "self",(char *) "file", NULL
7324 };
7325
7326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7328 if (SWIG_arg_fail(1)) SWIG_fail;
7329 {
7330 arg2 = wxString_in_helper(obj1);
7331 if (arg2 == NULL) SWIG_fail;
7332 temp2 = true;
7333 }
7334 {
7335 PyThreadState* __tstate = wxPyBeginAllowThreads();
7336 (arg1)->AddFileToHistory((wxString const &)*arg2);
7337
7338 wxPyEndAllowThreads(__tstate);
7339 if (PyErr_Occurred()) SWIG_fail;
7340 }
7341 Py_INCREF(Py_None); resultobj = Py_None;
7342 {
7343 if (temp2)
7344 delete arg2;
7345 }
7346 return resultobj;
7347 fail:
7348 {
7349 if (temp2)
7350 delete arg2;
7351 }
7352 return NULL;
7353 }
7354
7355
7356 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7357 PyObject *resultobj;
7358 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7359 int arg2 ;
7360 PyObject * obj0 = 0 ;
7361 PyObject * obj1 = 0 ;
7362 char *kwnames[] = {
7363 (char *) "self",(char *) "i", NULL
7364 };
7365
7366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7368 if (SWIG_arg_fail(1)) SWIG_fail;
7369 {
7370 arg2 = (int)(SWIG_As_int(obj1));
7371 if (SWIG_arg_fail(2)) SWIG_fail;
7372 }
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 (arg1)->RemoveFileFromHistory(arg2);
7376
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 Py_INCREF(Py_None); resultobj = Py_None;
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj;
7389 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7390 int result;
7391 PyObject * obj0 = 0 ;
7392 char *kwnames[] = {
7393 (char *) "self", NULL
7394 };
7395
7396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7398 if (SWIG_arg_fail(1)) SWIG_fail;
7399 {
7400 PyThreadState* __tstate = wxPyBeginAllowThreads();
7401 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7402
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 {
7407 resultobj = SWIG_From_int((int)(result));
7408 }
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj;
7417 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7418 wxMenu *arg2 = (wxMenu *) 0 ;
7419 PyObject * obj0 = 0 ;
7420 PyObject * obj1 = 0 ;
7421 char *kwnames[] = {
7422 (char *) "self",(char *) "menu", NULL
7423 };
7424
7425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7427 if (SWIG_arg_fail(1)) SWIG_fail;
7428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7429 if (SWIG_arg_fail(2)) SWIG_fail;
7430 {
7431 PyThreadState* __tstate = wxPyBeginAllowThreads();
7432 (arg1)->UseMenu(arg2);
7433
7434 wxPyEndAllowThreads(__tstate);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 Py_INCREF(Py_None); resultobj = Py_None;
7438 return resultobj;
7439 fail:
7440 return NULL;
7441 }
7442
7443
7444 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7445 PyObject *resultobj;
7446 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7447 wxMenu *arg2 = (wxMenu *) 0 ;
7448 PyObject * obj0 = 0 ;
7449 PyObject * obj1 = 0 ;
7450 char *kwnames[] = {
7451 (char *) "self",(char *) "menu", NULL
7452 };
7453
7454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7456 if (SWIG_arg_fail(1)) SWIG_fail;
7457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7458 if (SWIG_arg_fail(2)) SWIG_fail;
7459 {
7460 PyThreadState* __tstate = wxPyBeginAllowThreads();
7461 (arg1)->RemoveMenu(arg2);
7462
7463 wxPyEndAllowThreads(__tstate);
7464 if (PyErr_Occurred()) SWIG_fail;
7465 }
7466 Py_INCREF(Py_None); resultobj = Py_None;
7467 return resultobj;
7468 fail:
7469 return NULL;
7470 }
7471
7472
7473 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7474 PyObject *resultobj;
7475 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7476 wxConfigBase *arg2 = 0 ;
7477 PyObject * obj0 = 0 ;
7478 PyObject * obj1 = 0 ;
7479 char *kwnames[] = {
7480 (char *) "self",(char *) "config", NULL
7481 };
7482
7483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7485 if (SWIG_arg_fail(1)) SWIG_fail;
7486 {
7487 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7488 if (SWIG_arg_fail(2)) SWIG_fail;
7489 if (arg2 == NULL) {
7490 SWIG_null_ref("wxConfigBase");
7491 }
7492 if (SWIG_arg_fail(2)) SWIG_fail;
7493 }
7494 {
7495 PyThreadState* __tstate = wxPyBeginAllowThreads();
7496 (arg1)->Load(*arg2);
7497
7498 wxPyEndAllowThreads(__tstate);
7499 if (PyErr_Occurred()) SWIG_fail;
7500 }
7501 Py_INCREF(Py_None); resultobj = Py_None;
7502 return resultobj;
7503 fail:
7504 return NULL;
7505 }
7506
7507
7508 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7509 PyObject *resultobj;
7510 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7511 wxConfigBase *arg2 = 0 ;
7512 PyObject * obj0 = 0 ;
7513 PyObject * obj1 = 0 ;
7514 char *kwnames[] = {
7515 (char *) "self",(char *) "config", NULL
7516 };
7517
7518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7520 if (SWIG_arg_fail(1)) SWIG_fail;
7521 {
7522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7523 if (SWIG_arg_fail(2)) SWIG_fail;
7524 if (arg2 == NULL) {
7525 SWIG_null_ref("wxConfigBase");
7526 }
7527 if (SWIG_arg_fail(2)) SWIG_fail;
7528 }
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 (arg1)->Save(*arg2);
7532
7533 wxPyEndAllowThreads(__tstate);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 Py_INCREF(Py_None); resultobj = Py_None;
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj;
7545 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7546 PyObject * obj0 = 0 ;
7547 char *kwnames[] = {
7548 (char *) "self", NULL
7549 };
7550
7551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7553 if (SWIG_arg_fail(1)) SWIG_fail;
7554 {
7555 PyThreadState* __tstate = wxPyBeginAllowThreads();
7556 (arg1)->AddFilesToMenu();
7557
7558 wxPyEndAllowThreads(__tstate);
7559 if (PyErr_Occurred()) SWIG_fail;
7560 }
7561 Py_INCREF(Py_None); resultobj = Py_None;
7562 return resultobj;
7563 fail:
7564 return NULL;
7565 }
7566
7567
7568 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7569 PyObject *resultobj;
7570 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7571 wxMenu *arg2 = (wxMenu *) 0 ;
7572 PyObject * obj0 = 0 ;
7573 PyObject * obj1 = 0 ;
7574 char *kwnames[] = {
7575 (char *) "self",(char *) "menu", NULL
7576 };
7577
7578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7580 if (SWIG_arg_fail(1)) SWIG_fail;
7581 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7582 if (SWIG_arg_fail(2)) SWIG_fail;
7583 {
7584 PyThreadState* __tstate = wxPyBeginAllowThreads();
7585 (arg1)->AddFilesToMenu(arg2);
7586
7587 wxPyEndAllowThreads(__tstate);
7588 if (PyErr_Occurred()) SWIG_fail;
7589 }
7590 Py_INCREF(Py_None); resultobj = Py_None;
7591 return resultobj;
7592 fail:
7593 return NULL;
7594 }
7595
7596
7597 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7598 PyObject *resultobj;
7599 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7600 int arg2 ;
7601 wxString result;
7602 PyObject * obj0 = 0 ;
7603 PyObject * obj1 = 0 ;
7604 char *kwnames[] = {
7605 (char *) "self",(char *) "i", NULL
7606 };
7607
7608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7610 if (SWIG_arg_fail(1)) SWIG_fail;
7611 {
7612 arg2 = (int)(SWIG_As_int(obj1));
7613 if (SWIG_arg_fail(2)) SWIG_fail;
7614 }
7615 {
7616 PyThreadState* __tstate = wxPyBeginAllowThreads();
7617 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7618
7619 wxPyEndAllowThreads(__tstate);
7620 if (PyErr_Occurred()) SWIG_fail;
7621 }
7622 {
7623 #if wxUSE_UNICODE
7624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7625 #else
7626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7627 #endif
7628 }
7629 return resultobj;
7630 fail:
7631 return NULL;
7632 }
7633
7634
7635 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7636 PyObject *resultobj;
7637 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7638 int result;
7639 PyObject * obj0 = 0 ;
7640 char *kwnames[] = {
7641 (char *) "self", NULL
7642 };
7643
7644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7646 if (SWIG_arg_fail(1)) SWIG_fail;
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 result = (int)((wxFileHistory const *)arg1)->GetCount();
7650
7651 wxPyEndAllowThreads(__tstate);
7652 if (PyErr_Occurred()) SWIG_fail;
7653 }
7654 {
7655 resultobj = SWIG_From_int((int)(result));
7656 }
7657 return resultobj;
7658 fail:
7659 return NULL;
7660 }
7661
7662
7663 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7664 PyObject *obj;
7665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7666 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7667 Py_INCREF(obj);
7668 return Py_BuildValue((char *)"");
7669 }
7670 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj;
7672 wxString *arg1 = 0 ;
7673 wxString const &arg2_defvalue = wxPyEmptyString ;
7674 wxString *arg2 = (wxString *) &arg2_defvalue ;
7675 wxSingleInstanceChecker *result;
7676 bool temp1 = false ;
7677 bool temp2 = false ;
7678 PyObject * obj0 = 0 ;
7679 PyObject * obj1 = 0 ;
7680 char *kwnames[] = {
7681 (char *) "name",(char *) "path", NULL
7682 };
7683
7684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7685 {
7686 arg1 = wxString_in_helper(obj0);
7687 if (arg1 == NULL) SWIG_fail;
7688 temp1 = true;
7689 }
7690 if (obj1) {
7691 {
7692 arg2 = wxString_in_helper(obj1);
7693 if (arg2 == NULL) SWIG_fail;
7694 temp2 = true;
7695 }
7696 }
7697 {
7698 PyThreadState* __tstate = wxPyBeginAllowThreads();
7699 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7700
7701 wxPyEndAllowThreads(__tstate);
7702 if (PyErr_Occurred()) SWIG_fail;
7703 }
7704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7705 {
7706 if (temp1)
7707 delete arg1;
7708 }
7709 {
7710 if (temp2)
7711 delete arg2;
7712 }
7713 return resultobj;
7714 fail:
7715 {
7716 if (temp1)
7717 delete arg1;
7718 }
7719 {
7720 if (temp2)
7721 delete arg2;
7722 }
7723 return NULL;
7724 }
7725
7726
7727 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7728 PyObject *resultobj;
7729 wxSingleInstanceChecker *result;
7730 char *kwnames[] = {
7731 NULL
7732 };
7733
7734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7735 {
7736 PyThreadState* __tstate = wxPyBeginAllowThreads();
7737 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7738
7739 wxPyEndAllowThreads(__tstate);
7740 if (PyErr_Occurred()) SWIG_fail;
7741 }
7742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7743 return resultobj;
7744 fail:
7745 return NULL;
7746 }
7747
7748
7749 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7750 PyObject *resultobj;
7751 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7752 PyObject * obj0 = 0 ;
7753 char *kwnames[] = {
7754 (char *) "self", NULL
7755 };
7756
7757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7759 if (SWIG_arg_fail(1)) SWIG_fail;
7760 {
7761 PyThreadState* __tstate = wxPyBeginAllowThreads();
7762 delete arg1;
7763
7764 wxPyEndAllowThreads(__tstate);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 Py_INCREF(Py_None); resultobj = Py_None;
7768 return resultobj;
7769 fail:
7770 return NULL;
7771 }
7772
7773
7774 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7775 PyObject *resultobj;
7776 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7777 wxString *arg2 = 0 ;
7778 wxString const &arg3_defvalue = wxPyEmptyString ;
7779 wxString *arg3 = (wxString *) &arg3_defvalue ;
7780 bool result;
7781 bool temp2 = false ;
7782 bool temp3 = false ;
7783 PyObject * obj0 = 0 ;
7784 PyObject * obj1 = 0 ;
7785 PyObject * obj2 = 0 ;
7786 char *kwnames[] = {
7787 (char *) "self",(char *) "name",(char *) "path", NULL
7788 };
7789
7790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7792 if (SWIG_arg_fail(1)) SWIG_fail;
7793 {
7794 arg2 = wxString_in_helper(obj1);
7795 if (arg2 == NULL) SWIG_fail;
7796 temp2 = true;
7797 }
7798 if (obj2) {
7799 {
7800 arg3 = wxString_in_helper(obj2);
7801 if (arg3 == NULL) SWIG_fail;
7802 temp3 = true;
7803 }
7804 }
7805 {
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7808
7809 wxPyEndAllowThreads(__tstate);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 {
7813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7814 }
7815 {
7816 if (temp2)
7817 delete arg2;
7818 }
7819 {
7820 if (temp3)
7821 delete arg3;
7822 }
7823 return resultobj;
7824 fail:
7825 {
7826 if (temp2)
7827 delete arg2;
7828 }
7829 {
7830 if (temp3)
7831 delete arg3;
7832 }
7833 return NULL;
7834 }
7835
7836
7837 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7838 PyObject *resultobj;
7839 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7840 bool result;
7841 PyObject * obj0 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "self", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 PyThreadState* __tstate = wxPyBeginAllowThreads();
7851 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7852
7853 wxPyEndAllowThreads(__tstate);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 {
7857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7858 }
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7866 PyObject *obj;
7867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7868 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7869 Py_INCREF(obj);
7870 return Py_BuildValue((char *)"");
7871 }
7872 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj;
7874 wxWindow *arg1 = (wxWindow *) 0 ;
7875 wxDC *arg2 = 0 ;
7876 bool result;
7877 PyObject * obj0 = 0 ;
7878 PyObject * obj1 = 0 ;
7879 char *kwnames[] = {
7880 (char *) "window",(char *) "dc", NULL
7881 };
7882
7883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7885 if (SWIG_arg_fail(1)) SWIG_fail;
7886 {
7887 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7888 if (SWIG_arg_fail(2)) SWIG_fail;
7889 if (arg2 == NULL) {
7890 SWIG_null_ref("wxDC");
7891 }
7892 if (SWIG_arg_fail(2)) SWIG_fail;
7893 }
7894 {
7895 PyThreadState* __tstate = wxPyBeginAllowThreads();
7896 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7897
7898 wxPyEndAllowThreads(__tstate);
7899 if (PyErr_Occurred()) SWIG_fail;
7900 }
7901 {
7902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7903 }
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7911 PyObject *resultobj;
7912 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7913 PyObject * obj0 = 0 ;
7914 char *kwnames[] = {
7915 (char *) "self", NULL
7916 };
7917
7918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7920 if (SWIG_arg_fail(1)) SWIG_fail;
7921 {
7922 PyThreadState* __tstate = wxPyBeginAllowThreads();
7923 delete arg1;
7924
7925 wxPyEndAllowThreads(__tstate);
7926 if (PyErr_Occurred()) SWIG_fail;
7927 }
7928 Py_INCREF(Py_None); resultobj = Py_None;
7929 return resultobj;
7930 fail:
7931 return NULL;
7932 }
7933
7934
7935 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7936 PyObject *resultobj;
7937 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7938 wxString result;
7939 PyObject * obj0 = 0 ;
7940 char *kwnames[] = {
7941 (char *) "self", NULL
7942 };
7943
7944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7946 if (SWIG_arg_fail(1)) SWIG_fail;
7947 {
7948 PyThreadState* __tstate = wxPyBeginAllowThreads();
7949 result = (arg1)->GetTip();
7950
7951 wxPyEndAllowThreads(__tstate);
7952 if (PyErr_Occurred()) SWIG_fail;
7953 }
7954 {
7955 #if wxUSE_UNICODE
7956 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7957 #else
7958 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7959 #endif
7960 }
7961 return resultobj;
7962 fail:
7963 return NULL;
7964 }
7965
7966
7967 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7968 PyObject *resultobj;
7969 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7970 size_t result;
7971 PyObject * obj0 = 0 ;
7972 char *kwnames[] = {
7973 (char *) "self", NULL
7974 };
7975
7976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7978 if (SWIG_arg_fail(1)) SWIG_fail;
7979 {
7980 PyThreadState* __tstate = wxPyBeginAllowThreads();
7981 result = (size_t)(arg1)->GetCurrentTip();
7982
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 {
7987 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7988 }
7989 return resultobj;
7990 fail:
7991 return NULL;
7992 }
7993
7994
7995 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7996 PyObject *resultobj;
7997 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7998 wxString *arg2 = 0 ;
7999 wxString result;
8000 bool temp2 = false ;
8001 PyObject * obj0 = 0 ;
8002 PyObject * obj1 = 0 ;
8003 char *kwnames[] = {
8004 (char *) "self",(char *) "tip", NULL
8005 };
8006
8007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8009 if (SWIG_arg_fail(1)) SWIG_fail;
8010 {
8011 arg2 = wxString_in_helper(obj1);
8012 if (arg2 == NULL) SWIG_fail;
8013 temp2 = true;
8014 }
8015 {
8016 PyThreadState* __tstate = wxPyBeginAllowThreads();
8017 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8018
8019 wxPyEndAllowThreads(__tstate);
8020 if (PyErr_Occurred()) SWIG_fail;
8021 }
8022 {
8023 #if wxUSE_UNICODE
8024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8025 #else
8026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8027 #endif
8028 }
8029 {
8030 if (temp2)
8031 delete arg2;
8032 }
8033 return resultobj;
8034 fail:
8035 {
8036 if (temp2)
8037 delete arg2;
8038 }
8039 return NULL;
8040 }
8041
8042
8043 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8044 PyObject *obj;
8045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8046 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8047 Py_INCREF(obj);
8048 return Py_BuildValue((char *)"");
8049 }
8050 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8051 PyObject *resultobj;
8052 size_t arg1 ;
8053 wxPyTipProvider *result;
8054 PyObject * obj0 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "currentTip", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8060 {
8061 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8062 if (SWIG_arg_fail(1)) SWIG_fail;
8063 }
8064 {
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8067
8068 wxPyEndAllowThreads(__tstate);
8069 if (PyErr_Occurred()) SWIG_fail;
8070 }
8071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8072 return resultobj;
8073 fail:
8074 return NULL;
8075 }
8076
8077
8078 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8079 PyObject *resultobj;
8080 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8081 PyObject *arg2 = (PyObject *) 0 ;
8082 PyObject *arg3 = (PyObject *) 0 ;
8083 PyObject * obj0 = 0 ;
8084 PyObject * obj1 = 0 ;
8085 PyObject * obj2 = 0 ;
8086 char *kwnames[] = {
8087 (char *) "self",(char *) "self",(char *) "_class", NULL
8088 };
8089
8090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8092 if (SWIG_arg_fail(1)) SWIG_fail;
8093 arg2 = obj1;
8094 arg3 = obj2;
8095 {
8096 PyThreadState* __tstate = wxPyBeginAllowThreads();
8097 (arg1)->_setCallbackInfo(arg2,arg3);
8098
8099 wxPyEndAllowThreads(__tstate);
8100 if (PyErr_Occurred()) SWIG_fail;
8101 }
8102 Py_INCREF(Py_None); resultobj = Py_None;
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8110 PyObject *obj;
8111 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8112 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8113 Py_INCREF(obj);
8114 return Py_BuildValue((char *)"");
8115 }
8116 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj;
8118 wxWindow *arg1 = (wxWindow *) 0 ;
8119 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8120 bool arg3 = (bool) true ;
8121 bool result;
8122 PyObject * obj0 = 0 ;
8123 PyObject * obj1 = 0 ;
8124 PyObject * obj2 = 0 ;
8125 char *kwnames[] = {
8126 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8127 };
8128
8129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8131 if (SWIG_arg_fail(1)) SWIG_fail;
8132 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8133 if (SWIG_arg_fail(2)) SWIG_fail;
8134 if (obj2) {
8135 {
8136 arg3 = (bool)(SWIG_As_bool(obj2));
8137 if (SWIG_arg_fail(3)) SWIG_fail;
8138 }
8139 }
8140 {
8141 if (!wxPyCheckForApp()) SWIG_fail;
8142 PyThreadState* __tstate = wxPyBeginAllowThreads();
8143 result = (bool)wxShowTip(arg1,arg2,arg3);
8144
8145 wxPyEndAllowThreads(__tstate);
8146 if (PyErr_Occurred()) SWIG_fail;
8147 }
8148 {
8149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8150 }
8151 return resultobj;
8152 fail:
8153 return NULL;
8154 }
8155
8156
8157 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8158 PyObject *resultobj;
8159 wxString *arg1 = 0 ;
8160 size_t arg2 ;
8161 wxTipProvider *result;
8162 bool temp1 = false ;
8163 PyObject * obj0 = 0 ;
8164 PyObject * obj1 = 0 ;
8165 char *kwnames[] = {
8166 (char *) "filename",(char *) "currentTip", NULL
8167 };
8168
8169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8170 {
8171 arg1 = wxString_in_helper(obj0);
8172 if (arg1 == NULL) SWIG_fail;
8173 temp1 = true;
8174 }
8175 {
8176 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8177 if (SWIG_arg_fail(2)) SWIG_fail;
8178 }
8179 {
8180 if (!wxPyCheckForApp()) SWIG_fail;
8181 PyThreadState* __tstate = wxPyBeginAllowThreads();
8182 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8183
8184 wxPyEndAllowThreads(__tstate);
8185 if (PyErr_Occurred()) SWIG_fail;
8186 }
8187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8188 {
8189 if (temp1)
8190 delete arg1;
8191 }
8192 return resultobj;
8193 fail:
8194 {
8195 if (temp1)
8196 delete arg1;
8197 }
8198 return NULL;
8199 }
8200
8201
8202 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj;
8204 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8205 int arg2 = (int) -1 ;
8206 wxPyTimer *result;
8207 PyObject * obj0 = 0 ;
8208 PyObject * obj1 = 0 ;
8209 char *kwnames[] = {
8210 (char *) "owner",(char *) "id", NULL
8211 };
8212
8213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8214 if (obj0) {
8215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8216 if (SWIG_arg_fail(1)) SWIG_fail;
8217 }
8218 if (obj1) {
8219 {
8220 arg2 = (int)(SWIG_As_int(obj1));
8221 if (SWIG_arg_fail(2)) SWIG_fail;
8222 }
8223 }
8224 {
8225 if (!wxPyCheckForApp()) SWIG_fail;
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8228
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj;
8241 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8242 PyObject * obj0 = 0 ;
8243 char *kwnames[] = {
8244 (char *) "self", NULL
8245 };
8246
8247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8249 if (SWIG_arg_fail(1)) SWIG_fail;
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 delete arg1;
8253
8254 wxPyEndAllowThreads(__tstate);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 Py_INCREF(Py_None); resultobj = Py_None;
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj;
8266 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8267 PyObject *arg2 = (PyObject *) 0 ;
8268 PyObject *arg3 = (PyObject *) 0 ;
8269 int arg4 = (int) 1 ;
8270 PyObject * obj0 = 0 ;
8271 PyObject * obj1 = 0 ;
8272 PyObject * obj2 = 0 ;
8273 PyObject * obj3 = 0 ;
8274 char *kwnames[] = {
8275 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8276 };
8277
8278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8280 if (SWIG_arg_fail(1)) SWIG_fail;
8281 arg2 = obj1;
8282 arg3 = obj2;
8283 if (obj3) {
8284 {
8285 arg4 = (int)(SWIG_As_int(obj3));
8286 if (SWIG_arg_fail(4)) SWIG_fail;
8287 }
8288 }
8289 {
8290 PyThreadState* __tstate = wxPyBeginAllowThreads();
8291 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8292
8293 wxPyEndAllowThreads(__tstate);
8294 if (PyErr_Occurred()) SWIG_fail;
8295 }
8296 Py_INCREF(Py_None); resultobj = Py_None;
8297 return resultobj;
8298 fail:
8299 return NULL;
8300 }
8301
8302
8303 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8304 PyObject *resultobj;
8305 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8306 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8307 int arg3 = (int) -1 ;
8308 PyObject * obj0 = 0 ;
8309 PyObject * obj1 = 0 ;
8310 PyObject * obj2 = 0 ;
8311 char *kwnames[] = {
8312 (char *) "self",(char *) "owner",(char *) "id", NULL
8313 };
8314
8315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8317 if (SWIG_arg_fail(1)) SWIG_fail;
8318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8319 if (SWIG_arg_fail(2)) SWIG_fail;
8320 if (obj2) {
8321 {
8322 arg3 = (int)(SWIG_As_int(obj2));
8323 if (SWIG_arg_fail(3)) SWIG_fail;
8324 }
8325 }
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 (arg1)->SetOwner(arg2,arg3);
8329
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 Py_INCREF(Py_None); resultobj = Py_None;
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj;
8342 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8343 wxEvtHandler *result;
8344 PyObject * obj0 = 0 ;
8345 char *kwnames[] = {
8346 (char *) "self", NULL
8347 };
8348
8349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8351 if (SWIG_arg_fail(1)) SWIG_fail;
8352 {
8353 PyThreadState* __tstate = wxPyBeginAllowThreads();
8354 result = (wxEvtHandler *)(arg1)->GetOwner();
8355
8356 wxPyEndAllowThreads(__tstate);
8357 if (PyErr_Occurred()) SWIG_fail;
8358 }
8359 {
8360 resultobj = wxPyMake_wxObject(result, 0);
8361 }
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8369 PyObject *resultobj;
8370 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8371 int arg2 = (int) -1 ;
8372 bool arg3 = (bool) false ;
8373 bool result;
8374 PyObject * obj0 = 0 ;
8375 PyObject * obj1 = 0 ;
8376 PyObject * obj2 = 0 ;
8377 char *kwnames[] = {
8378 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8379 };
8380
8381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8383 if (SWIG_arg_fail(1)) SWIG_fail;
8384 if (obj1) {
8385 {
8386 arg2 = (int)(SWIG_As_int(obj1));
8387 if (SWIG_arg_fail(2)) SWIG_fail;
8388 }
8389 }
8390 if (obj2) {
8391 {
8392 arg3 = (bool)(SWIG_As_bool(obj2));
8393 if (SWIG_arg_fail(3)) SWIG_fail;
8394 }
8395 }
8396 {
8397 PyThreadState* __tstate = wxPyBeginAllowThreads();
8398 result = (bool)(arg1)->Start(arg2,arg3);
8399
8400 wxPyEndAllowThreads(__tstate);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 {
8404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8405 }
8406 return resultobj;
8407 fail:
8408 return NULL;
8409 }
8410
8411
8412 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8413 PyObject *resultobj;
8414 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8415 PyObject * obj0 = 0 ;
8416 char *kwnames[] = {
8417 (char *) "self", NULL
8418 };
8419
8420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8422 if (SWIG_arg_fail(1)) SWIG_fail;
8423 {
8424 PyThreadState* __tstate = wxPyBeginAllowThreads();
8425 (arg1)->Stop();
8426
8427 wxPyEndAllowThreads(__tstate);
8428 if (PyErr_Occurred()) SWIG_fail;
8429 }
8430 Py_INCREF(Py_None); resultobj = Py_None;
8431 return resultobj;
8432 fail:
8433 return NULL;
8434 }
8435
8436
8437 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8438 PyObject *resultobj;
8439 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8440 bool result;
8441 PyObject * obj0 = 0 ;
8442 char *kwnames[] = {
8443 (char *) "self", NULL
8444 };
8445
8446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8448 if (SWIG_arg_fail(1)) SWIG_fail;
8449 {
8450 PyThreadState* __tstate = wxPyBeginAllowThreads();
8451 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8452
8453 wxPyEndAllowThreads(__tstate);
8454 if (PyErr_Occurred()) SWIG_fail;
8455 }
8456 {
8457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8458 }
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj;
8467 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8468 int result;
8469 PyObject * obj0 = 0 ;
8470 char *kwnames[] = {
8471 (char *) "self", NULL
8472 };
8473
8474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8476 if (SWIG_arg_fail(1)) SWIG_fail;
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8480
8481 wxPyEndAllowThreads(__tstate);
8482 if (PyErr_Occurred()) SWIG_fail;
8483 }
8484 {
8485 resultobj = SWIG_From_int((int)(result));
8486 }
8487 return resultobj;
8488 fail:
8489 return NULL;
8490 }
8491
8492
8493 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8494 PyObject *resultobj;
8495 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8496 bool result;
8497 PyObject * obj0 = 0 ;
8498 char *kwnames[] = {
8499 (char *) "self", NULL
8500 };
8501
8502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8504 if (SWIG_arg_fail(1)) SWIG_fail;
8505 {
8506 PyThreadState* __tstate = wxPyBeginAllowThreads();
8507 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8508
8509 wxPyEndAllowThreads(__tstate);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 {
8513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8514 }
8515 return resultobj;
8516 fail:
8517 return NULL;
8518 }
8519
8520
8521 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8522 PyObject *resultobj;
8523 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8524 int result;
8525 PyObject * obj0 = 0 ;
8526 char *kwnames[] = {
8527 (char *) "self", NULL
8528 };
8529
8530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8532 if (SWIG_arg_fail(1)) SWIG_fail;
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (int)((wxPyTimer const *)arg1)->GetId();
8536
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 {
8541 resultobj = SWIG_From_int((int)(result));
8542 }
8543 return resultobj;
8544 fail:
8545 return NULL;
8546 }
8547
8548
8549 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8550 PyObject *obj;
8551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8552 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8553 Py_INCREF(obj);
8554 return Py_BuildValue((char *)"");
8555 }
8556 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8557 PyObject *resultobj;
8558 int arg1 = (int) 0 ;
8559 int arg2 = (int) 0 ;
8560 wxTimerEvent *result;
8561 PyObject * obj0 = 0 ;
8562 PyObject * obj1 = 0 ;
8563 char *kwnames[] = {
8564 (char *) "timerid",(char *) "interval", NULL
8565 };
8566
8567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8568 if (obj0) {
8569 {
8570 arg1 = (int)(SWIG_As_int(obj0));
8571 if (SWIG_arg_fail(1)) SWIG_fail;
8572 }
8573 }
8574 if (obj1) {
8575 {
8576 arg2 = (int)(SWIG_As_int(obj1));
8577 if (SWIG_arg_fail(2)) SWIG_fail;
8578 }
8579 }
8580 {
8581 PyThreadState* __tstate = wxPyBeginAllowThreads();
8582 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8583
8584 wxPyEndAllowThreads(__tstate);
8585 if (PyErr_Occurred()) SWIG_fail;
8586 }
8587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8588 return resultobj;
8589 fail:
8590 return NULL;
8591 }
8592
8593
8594 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8595 PyObject *resultobj;
8596 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8597 int result;
8598 PyObject * obj0 = 0 ;
8599 char *kwnames[] = {
8600 (char *) "self", NULL
8601 };
8602
8603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8605 if (SWIG_arg_fail(1)) SWIG_fail;
8606 {
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8609
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 {
8614 resultobj = SWIG_From_int((int)(result));
8615 }
8616 return resultobj;
8617 fail:
8618 return NULL;
8619 }
8620
8621
8622 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8623 PyObject *obj;
8624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8625 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8626 Py_INCREF(obj);
8627 return Py_BuildValue((char *)"");
8628 }
8629 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8630 PyObject *resultobj;
8631 wxTimer *arg1 = 0 ;
8632 wxTimerRunner *result;
8633 PyObject * obj0 = 0 ;
8634
8635 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8636 {
8637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8638 if (SWIG_arg_fail(1)) SWIG_fail;
8639 if (arg1 == NULL) {
8640 SWIG_null_ref("wxTimer");
8641 }
8642 if (SWIG_arg_fail(1)) SWIG_fail;
8643 }
8644 {
8645 if (!wxPyCheckForApp()) SWIG_fail;
8646 PyThreadState* __tstate = wxPyBeginAllowThreads();
8647 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8648
8649 wxPyEndAllowThreads(__tstate);
8650 if (PyErr_Occurred()) SWIG_fail;
8651 }
8652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8653 return resultobj;
8654 fail:
8655 return NULL;
8656 }
8657
8658
8659 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8660 PyObject *resultobj;
8661 wxTimer *arg1 = 0 ;
8662 int arg2 ;
8663 bool arg3 = (bool) false ;
8664 wxTimerRunner *result;
8665 PyObject * obj0 = 0 ;
8666 PyObject * obj1 = 0 ;
8667 PyObject * obj2 = 0 ;
8668
8669 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8670 {
8671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8672 if (SWIG_arg_fail(1)) SWIG_fail;
8673 if (arg1 == NULL) {
8674 SWIG_null_ref("wxTimer");
8675 }
8676 if (SWIG_arg_fail(1)) SWIG_fail;
8677 }
8678 {
8679 arg2 = (int)(SWIG_As_int(obj1));
8680 if (SWIG_arg_fail(2)) SWIG_fail;
8681 }
8682 if (obj2) {
8683 {
8684 arg3 = (bool)(SWIG_As_bool(obj2));
8685 if (SWIG_arg_fail(3)) SWIG_fail;
8686 }
8687 }
8688 {
8689 if (!wxPyCheckForApp()) SWIG_fail;
8690 PyThreadState* __tstate = wxPyBeginAllowThreads();
8691 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8692
8693 wxPyEndAllowThreads(__tstate);
8694 if (PyErr_Occurred()) SWIG_fail;
8695 }
8696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8697 return resultobj;
8698 fail:
8699 return NULL;
8700 }
8701
8702
8703 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8704 int argc;
8705 PyObject *argv[4];
8706 int ii;
8707
8708 argc = PyObject_Length(args);
8709 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8710 argv[ii] = PyTuple_GetItem(args,ii);
8711 }
8712 if (argc == 1) {
8713 int _v;
8714 {
8715 void *ptr = 0;
8716 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8717 _v = 0;
8718 PyErr_Clear();
8719 } else {
8720 _v = (ptr != 0);
8721 }
8722 }
8723 if (_v) {
8724 return _wrap_new_TimerRunner__SWIG_0(self,args);
8725 }
8726 }
8727 if ((argc >= 2) && (argc <= 3)) {
8728 int _v;
8729 {
8730 void *ptr = 0;
8731 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8732 _v = 0;
8733 PyErr_Clear();
8734 } else {
8735 _v = (ptr != 0);
8736 }
8737 }
8738 if (_v) {
8739 _v = SWIG_Check_int(argv[1]);
8740 if (_v) {
8741 if (argc <= 2) {
8742 return _wrap_new_TimerRunner__SWIG_1(self,args);
8743 }
8744 _v = SWIG_Check_bool(argv[2]);
8745 if (_v) {
8746 return _wrap_new_TimerRunner__SWIG_1(self,args);
8747 }
8748 }
8749 }
8750 }
8751
8752 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8753 return NULL;
8754 }
8755
8756
8757 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8758 PyObject *resultobj;
8759 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8760 PyObject * obj0 = 0 ;
8761 char *kwnames[] = {
8762 (char *) "self", NULL
8763 };
8764
8765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8767 if (SWIG_arg_fail(1)) SWIG_fail;
8768 {
8769 PyThreadState* __tstate = wxPyBeginAllowThreads();
8770 delete arg1;
8771
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 Py_INCREF(Py_None); resultobj = Py_None;
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj;
8784 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8785 int arg2 ;
8786 bool arg3 = (bool) false ;
8787 PyObject * obj0 = 0 ;
8788 PyObject * obj1 = 0 ;
8789 PyObject * obj2 = 0 ;
8790 char *kwnames[] = {
8791 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8792 };
8793
8794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8796 if (SWIG_arg_fail(1)) SWIG_fail;
8797 {
8798 arg2 = (int)(SWIG_As_int(obj1));
8799 if (SWIG_arg_fail(2)) SWIG_fail;
8800 }
8801 if (obj2) {
8802 {
8803 arg3 = (bool)(SWIG_As_bool(obj2));
8804 if (SWIG_arg_fail(3)) SWIG_fail;
8805 }
8806 }
8807 {
8808 PyThreadState* __tstate = wxPyBeginAllowThreads();
8809 (arg1)->Start(arg2,arg3);
8810
8811 wxPyEndAllowThreads(__tstate);
8812 if (PyErr_Occurred()) SWIG_fail;
8813 }
8814 Py_INCREF(Py_None); resultobj = Py_None;
8815 return resultobj;
8816 fail:
8817 return NULL;
8818 }
8819
8820
8821 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8822 PyObject *obj;
8823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8824 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8825 Py_INCREF(obj);
8826 return Py_BuildValue((char *)"");
8827 }
8828 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8829 PyObject *resultobj;
8830 wxLog *result;
8831 char *kwnames[] = {
8832 NULL
8833 };
8834
8835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8836 {
8837 PyThreadState* __tstate = wxPyBeginAllowThreads();
8838 result = (wxLog *)new wxLog();
8839
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8844 return resultobj;
8845 fail:
8846 return NULL;
8847 }
8848
8849
8850 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8851 PyObject *resultobj;
8852 bool result;
8853 char *kwnames[] = {
8854 NULL
8855 };
8856
8857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8858 {
8859 PyThreadState* __tstate = wxPyBeginAllowThreads();
8860 result = (bool)wxLog::IsEnabled();
8861
8862 wxPyEndAllowThreads(__tstate);
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 {
8866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8867 }
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj;
8876 bool arg1 = (bool) true ;
8877 bool result;
8878 PyObject * obj0 = 0 ;
8879 char *kwnames[] = {
8880 (char *) "doIt", NULL
8881 };
8882
8883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8884 if (obj0) {
8885 {
8886 arg1 = (bool)(SWIG_As_bool(obj0));
8887 if (SWIG_arg_fail(1)) SWIG_fail;
8888 }
8889 }
8890 {
8891 PyThreadState* __tstate = wxPyBeginAllowThreads();
8892 result = (bool)wxLog::EnableLogging(arg1);
8893
8894 wxPyEndAllowThreads(__tstate);
8895 if (PyErr_Occurred()) SWIG_fail;
8896 }
8897 {
8898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8899 }
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj;
8908 wxLogLevel arg1 ;
8909 wxChar *arg2 = (wxChar *) 0 ;
8910 time_t arg3 ;
8911 PyObject * obj0 = 0 ;
8912 PyObject * obj1 = 0 ;
8913 PyObject * obj2 = 0 ;
8914 char *kwnames[] = {
8915 (char *) "level",(char *) "szString",(char *) "t", NULL
8916 };
8917
8918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8919 {
8920 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8921 if (SWIG_arg_fail(1)) SWIG_fail;
8922 }
8923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8924 if (SWIG_arg_fail(2)) SWIG_fail;
8925 {
8926 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8927 if (SWIG_arg_fail(3)) SWIG_fail;
8928 }
8929 {
8930 PyThreadState* __tstate = wxPyBeginAllowThreads();
8931 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8932
8933 wxPyEndAllowThreads(__tstate);
8934 if (PyErr_Occurred()) SWIG_fail;
8935 }
8936 Py_INCREF(Py_None); resultobj = Py_None;
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8944 PyObject *resultobj;
8945 wxLog *arg1 = (wxLog *) 0 ;
8946 PyObject * obj0 = 0 ;
8947 char *kwnames[] = {
8948 (char *) "self", NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8953 if (SWIG_arg_fail(1)) SWIG_fail;
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 (arg1)->Flush();
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 Py_INCREF(Py_None); resultobj = Py_None;
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj;
8970 char *kwnames[] = {
8971 NULL
8972 };
8973
8974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 wxLog::FlushActive();
8978
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 Py_INCREF(Py_None); resultobj = Py_None;
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8990 PyObject *resultobj;
8991 wxLog *result;
8992 char *kwnames[] = {
8993 NULL
8994 };
8995
8996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8997 {
8998 PyThreadState* __tstate = wxPyBeginAllowThreads();
8999 result = (wxLog *)wxLog::GetActiveTarget();
9000
9001 wxPyEndAllowThreads(__tstate);
9002 if (PyErr_Occurred()) SWIG_fail;
9003 }
9004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
9011 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9012 PyObject *resultobj;
9013 wxLog *arg1 = (wxLog *) 0 ;
9014 wxLog *result;
9015 PyObject * obj0 = 0 ;
9016 char *kwnames[] = {
9017 (char *) "pLogger", NULL
9018 };
9019
9020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9022 if (SWIG_arg_fail(1)) SWIG_fail;
9023 {
9024 PyThreadState* __tstate = wxPyBeginAllowThreads();
9025 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9026
9027 wxPyEndAllowThreads(__tstate);
9028 if (PyErr_Occurred()) SWIG_fail;
9029 }
9030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9031 return resultobj;
9032 fail:
9033 return NULL;
9034 }
9035
9036
9037 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9038 PyObject *resultobj;
9039 char *kwnames[] = {
9040 NULL
9041 };
9042
9043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9044 {
9045 PyThreadState* __tstate = wxPyBeginAllowThreads();
9046 wxLog::Suspend();
9047
9048 wxPyEndAllowThreads(__tstate);
9049 if (PyErr_Occurred()) SWIG_fail;
9050 }
9051 Py_INCREF(Py_None); resultobj = Py_None;
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9059 PyObject *resultobj;
9060 char *kwnames[] = {
9061 NULL
9062 };
9063
9064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9065 {
9066 PyThreadState* __tstate = wxPyBeginAllowThreads();
9067 wxLog::Resume();
9068
9069 wxPyEndAllowThreads(__tstate);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 Py_INCREF(Py_None); resultobj = Py_None;
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9080 PyObject *resultobj;
9081 bool arg1 = (bool) true ;
9082 PyObject * obj0 = 0 ;
9083 char *kwnames[] = {
9084 (char *) "bVerbose", NULL
9085 };
9086
9087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9088 if (obj0) {
9089 {
9090 arg1 = (bool)(SWIG_As_bool(obj0));
9091 if (SWIG_arg_fail(1)) SWIG_fail;
9092 }
9093 }
9094 {
9095 PyThreadState* __tstate = wxPyBeginAllowThreads();
9096 wxLog::SetVerbose(arg1);
9097
9098 wxPyEndAllowThreads(__tstate);
9099 if (PyErr_Occurred()) SWIG_fail;
9100 }
9101 Py_INCREF(Py_None); resultobj = Py_None;
9102 return resultobj;
9103 fail:
9104 return NULL;
9105 }
9106
9107
9108 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9109 PyObject *resultobj;
9110 wxLogLevel arg1 ;
9111 PyObject * obj0 = 0 ;
9112 char *kwnames[] = {
9113 (char *) "logLevel", NULL
9114 };
9115
9116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9117 {
9118 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9119 if (SWIG_arg_fail(1)) SWIG_fail;
9120 }
9121 {
9122 PyThreadState* __tstate = wxPyBeginAllowThreads();
9123 wxLog::SetLogLevel(arg1);
9124
9125 wxPyEndAllowThreads(__tstate);
9126 if (PyErr_Occurred()) SWIG_fail;
9127 }
9128 Py_INCREF(Py_None); resultobj = Py_None;
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj;
9137 char *kwnames[] = {
9138 NULL
9139 };
9140
9141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9142 {
9143 PyThreadState* __tstate = wxPyBeginAllowThreads();
9144 wxLog::DontCreateOnDemand();
9145
9146 wxPyEndAllowThreads(__tstate);
9147 if (PyErr_Occurred()) SWIG_fail;
9148 }
9149 Py_INCREF(Py_None); resultobj = Py_None;
9150 return resultobj;
9151 fail:
9152 return NULL;
9153 }
9154
9155
9156 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9157 PyObject *resultobj;
9158 wxTraceMask arg1 ;
9159 PyObject * obj0 = 0 ;
9160 char *kwnames[] = {
9161 (char *) "ulMask", NULL
9162 };
9163
9164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9165 {
9166 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9167 if (SWIG_arg_fail(1)) SWIG_fail;
9168 }
9169 {
9170 PyThreadState* __tstate = wxPyBeginAllowThreads();
9171 wxLog::SetTraceMask(arg1);
9172
9173 wxPyEndAllowThreads(__tstate);
9174 if (PyErr_Occurred()) SWIG_fail;
9175 }
9176 Py_INCREF(Py_None); resultobj = Py_None;
9177 return resultobj;
9178 fail:
9179 return NULL;
9180 }
9181
9182
9183 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9184 PyObject *resultobj;
9185 wxString *arg1 = 0 ;
9186 bool temp1 = false ;
9187 PyObject * obj0 = 0 ;
9188 char *kwnames[] = {
9189 (char *) "str", NULL
9190 };
9191
9192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9193 {
9194 arg1 = wxString_in_helper(obj0);
9195 if (arg1 == NULL) SWIG_fail;
9196 temp1 = true;
9197 }
9198 {
9199 PyThreadState* __tstate = wxPyBeginAllowThreads();
9200 wxLog::AddTraceMask((wxString const &)*arg1);
9201
9202 wxPyEndAllowThreads(__tstate);
9203 if (PyErr_Occurred()) SWIG_fail;
9204 }
9205 Py_INCREF(Py_None); resultobj = Py_None;
9206 {
9207 if (temp1)
9208 delete arg1;
9209 }
9210 return resultobj;
9211 fail:
9212 {
9213 if (temp1)
9214 delete arg1;
9215 }
9216 return NULL;
9217 }
9218
9219
9220 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9221 PyObject *resultobj;
9222 wxString *arg1 = 0 ;
9223 bool temp1 = false ;
9224 PyObject * obj0 = 0 ;
9225 char *kwnames[] = {
9226 (char *) "str", NULL
9227 };
9228
9229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9230 {
9231 arg1 = wxString_in_helper(obj0);
9232 if (arg1 == NULL) SWIG_fail;
9233 temp1 = true;
9234 }
9235 {
9236 PyThreadState* __tstate = wxPyBeginAllowThreads();
9237 wxLog::RemoveTraceMask((wxString const &)*arg1);
9238
9239 wxPyEndAllowThreads(__tstate);
9240 if (PyErr_Occurred()) SWIG_fail;
9241 }
9242 Py_INCREF(Py_None); resultobj = Py_None;
9243 {
9244 if (temp1)
9245 delete arg1;
9246 }
9247 return resultobj;
9248 fail:
9249 {
9250 if (temp1)
9251 delete arg1;
9252 }
9253 return NULL;
9254 }
9255
9256
9257 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9258 PyObject *resultobj;
9259 char *kwnames[] = {
9260 NULL
9261 };
9262
9263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9264 {
9265 PyThreadState* __tstate = wxPyBeginAllowThreads();
9266 wxLog::ClearTraceMasks();
9267
9268 wxPyEndAllowThreads(__tstate);
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 Py_INCREF(Py_None); resultobj = Py_None;
9272 return resultobj;
9273 fail:
9274 return NULL;
9275 }
9276
9277
9278 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9279 PyObject *resultobj;
9280 wxArrayString *result;
9281 char *kwnames[] = {
9282 NULL
9283 };
9284
9285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9286 {
9287 PyThreadState* __tstate = wxPyBeginAllowThreads();
9288 {
9289 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9290 result = (wxArrayString *) &_result_ref;
9291 }
9292
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 {
9297 resultobj = wxArrayString2PyList_helper(*result);
9298 }
9299 return resultobj;
9300 fail:
9301 return NULL;
9302 }
9303
9304
9305 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9306 PyObject *resultobj;
9307 wxChar *arg1 = (wxChar *) 0 ;
9308 PyObject * obj0 = 0 ;
9309 char *kwnames[] = {
9310 (char *) "ts", NULL
9311 };
9312
9313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9315 if (SWIG_arg_fail(1)) SWIG_fail;
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 wxLog::SetTimestamp((wxChar const *)arg1);
9319
9320 wxPyEndAllowThreads(__tstate);
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 Py_INCREF(Py_None); resultobj = Py_None;
9324 return resultobj;
9325 fail:
9326 return NULL;
9327 }
9328
9329
9330 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9331 PyObject *resultobj;
9332 bool result;
9333 char *kwnames[] = {
9334 NULL
9335 };
9336
9337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9338 {
9339 PyThreadState* __tstate = wxPyBeginAllowThreads();
9340 result = (bool)wxLog::GetVerbose();
9341
9342 wxPyEndAllowThreads(__tstate);
9343 if (PyErr_Occurred()) SWIG_fail;
9344 }
9345 {
9346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9347 }
9348 return resultobj;
9349 fail:
9350 return NULL;
9351 }
9352
9353
9354 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9355 PyObject *resultobj;
9356 wxTraceMask result;
9357 char *kwnames[] = {
9358 NULL
9359 };
9360
9361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9362 {
9363 PyThreadState* __tstate = wxPyBeginAllowThreads();
9364 result = (wxTraceMask)wxLog::GetTraceMask();
9365
9366 wxPyEndAllowThreads(__tstate);
9367 if (PyErr_Occurred()) SWIG_fail;
9368 }
9369 {
9370 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9371 }
9372 return resultobj;
9373 fail:
9374 return NULL;
9375 }
9376
9377
9378 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9379 PyObject *resultobj;
9380 wxChar *arg1 = (wxChar *) 0 ;
9381 bool result;
9382 PyObject * obj0 = 0 ;
9383 char *kwnames[] = {
9384 (char *) "mask", NULL
9385 };
9386
9387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9389 if (SWIG_arg_fail(1)) SWIG_fail;
9390 {
9391 PyThreadState* __tstate = wxPyBeginAllowThreads();
9392 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9393
9394 wxPyEndAllowThreads(__tstate);
9395 if (PyErr_Occurred()) SWIG_fail;
9396 }
9397 {
9398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9399 }
9400 return resultobj;
9401 fail:
9402 return NULL;
9403 }
9404
9405
9406 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9407 PyObject *resultobj;
9408 wxLogLevel result;
9409 char *kwnames[] = {
9410 NULL
9411 };
9412
9413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 result = (wxLogLevel)wxLog::GetLogLevel();
9417
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 {
9422 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9423 }
9424 return resultobj;
9425 fail:
9426 return NULL;
9427 }
9428
9429
9430 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj;
9432 wxChar *result;
9433 char *kwnames[] = {
9434 NULL
9435 };
9436
9437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9438 {
9439 PyThreadState* __tstate = wxPyBeginAllowThreads();
9440 result = (wxChar *)wxLog::GetTimestamp();
9441
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9446 return resultobj;
9447 fail:
9448 return NULL;
9449 }
9450
9451
9452 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9453 PyObject *resultobj;
9454 wxString result;
9455 char *kwnames[] = {
9456 NULL
9457 };
9458
9459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 result = Log_TimeStamp();
9463
9464 wxPyEndAllowThreads(__tstate);
9465 if (PyErr_Occurred()) SWIG_fail;
9466 }
9467 {
9468 #if wxUSE_UNICODE
9469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9470 #else
9471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9472 #endif
9473 }
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9481 PyObject *resultobj;
9482 wxLog *arg1 = (wxLog *) 0 ;
9483 PyObject * obj0 = 0 ;
9484 char *kwnames[] = {
9485 (char *) "self", NULL
9486 };
9487
9488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9490 if (SWIG_arg_fail(1)) SWIG_fail;
9491 {
9492 PyThreadState* __tstate = wxPyBeginAllowThreads();
9493 wxLog_Destroy(arg1);
9494
9495 wxPyEndAllowThreads(__tstate);
9496 if (PyErr_Occurred()) SWIG_fail;
9497 }
9498 Py_INCREF(Py_None); resultobj = Py_None;
9499 return resultobj;
9500 fail:
9501 return NULL;
9502 }
9503
9504
9505 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9506 PyObject *obj;
9507 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9508 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9509 Py_INCREF(obj);
9510 return Py_BuildValue((char *)"");
9511 }
9512 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9513 PyObject *resultobj;
9514 wxLogStderr *result;
9515 char *kwnames[] = {
9516 NULL
9517 };
9518
9519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9520 {
9521 PyThreadState* __tstate = wxPyBeginAllowThreads();
9522 result = (wxLogStderr *)new wxLogStderr();
9523
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9528 return resultobj;
9529 fail:
9530 return NULL;
9531 }
9532
9533
9534 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9535 PyObject *obj;
9536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9537 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9538 Py_INCREF(obj);
9539 return Py_BuildValue((char *)"");
9540 }
9541 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9542 PyObject *resultobj;
9543 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9544 wxLogTextCtrl *result;
9545 PyObject * obj0 = 0 ;
9546 char *kwnames[] = {
9547 (char *) "pTextCtrl", NULL
9548 };
9549
9550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9552 if (SWIG_arg_fail(1)) SWIG_fail;
9553 {
9554 PyThreadState* __tstate = wxPyBeginAllowThreads();
9555 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9556
9557 wxPyEndAllowThreads(__tstate);
9558 if (PyErr_Occurred()) SWIG_fail;
9559 }
9560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9561 return resultobj;
9562 fail:
9563 return NULL;
9564 }
9565
9566
9567 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9568 PyObject *obj;
9569 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9570 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9571 Py_INCREF(obj);
9572 return Py_BuildValue((char *)"");
9573 }
9574 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9575 PyObject *resultobj;
9576 wxLogGui *result;
9577 char *kwnames[] = {
9578 NULL
9579 };
9580
9581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (wxLogGui *)new wxLogGui();
9585
9586 wxPyEndAllowThreads(__tstate);
9587 if (PyErr_Occurred()) SWIG_fail;
9588 }
9589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9590 return resultobj;
9591 fail:
9592 return NULL;
9593 }
9594
9595
9596 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9597 PyObject *obj;
9598 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9599 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9600 Py_INCREF(obj);
9601 return Py_BuildValue((char *)"");
9602 }
9603 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9604 PyObject *resultobj;
9605 wxFrame *arg1 = (wxFrame *) 0 ;
9606 wxString *arg2 = 0 ;
9607 bool arg3 = (bool) true ;
9608 bool arg4 = (bool) true ;
9609 wxLogWindow *result;
9610 bool temp2 = false ;
9611 PyObject * obj0 = 0 ;
9612 PyObject * obj1 = 0 ;
9613 PyObject * obj2 = 0 ;
9614 PyObject * obj3 = 0 ;
9615 char *kwnames[] = {
9616 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9617 };
9618
9619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9621 if (SWIG_arg_fail(1)) SWIG_fail;
9622 {
9623 arg2 = wxString_in_helper(obj1);
9624 if (arg2 == NULL) SWIG_fail;
9625 temp2 = true;
9626 }
9627 if (obj2) {
9628 {
9629 arg3 = (bool)(SWIG_As_bool(obj2));
9630 if (SWIG_arg_fail(3)) SWIG_fail;
9631 }
9632 }
9633 if (obj3) {
9634 {
9635 arg4 = (bool)(SWIG_As_bool(obj3));
9636 if (SWIG_arg_fail(4)) SWIG_fail;
9637 }
9638 }
9639 {
9640 PyThreadState* __tstate = wxPyBeginAllowThreads();
9641 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9642
9643 wxPyEndAllowThreads(__tstate);
9644 if (PyErr_Occurred()) SWIG_fail;
9645 }
9646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9647 {
9648 if (temp2)
9649 delete arg2;
9650 }
9651 return resultobj;
9652 fail:
9653 {
9654 if (temp2)
9655 delete arg2;
9656 }
9657 return NULL;
9658 }
9659
9660
9661 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9662 PyObject *resultobj;
9663 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9664 bool arg2 = (bool) true ;
9665 PyObject * obj0 = 0 ;
9666 PyObject * obj1 = 0 ;
9667 char *kwnames[] = {
9668 (char *) "self",(char *) "bShow", NULL
9669 };
9670
9671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9673 if (SWIG_arg_fail(1)) SWIG_fail;
9674 if (obj1) {
9675 {
9676 arg2 = (bool)(SWIG_As_bool(obj1));
9677 if (SWIG_arg_fail(2)) SWIG_fail;
9678 }
9679 }
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 (arg1)->Show(arg2);
9683
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 Py_INCREF(Py_None); resultobj = Py_None;
9688 return resultobj;
9689 fail:
9690 return NULL;
9691 }
9692
9693
9694 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9695 PyObject *resultobj;
9696 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9697 wxFrame *result;
9698 PyObject * obj0 = 0 ;
9699 char *kwnames[] = {
9700 (char *) "self", NULL
9701 };
9702
9703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9705 if (SWIG_arg_fail(1)) SWIG_fail;
9706 {
9707 PyThreadState* __tstate = wxPyBeginAllowThreads();
9708 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9709
9710 wxPyEndAllowThreads(__tstate);
9711 if (PyErr_Occurred()) SWIG_fail;
9712 }
9713 {
9714 resultobj = wxPyMake_wxObject(result, 0);
9715 }
9716 return resultobj;
9717 fail:
9718 return NULL;
9719 }
9720
9721
9722 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9723 PyObject *resultobj;
9724 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9725 wxLog *result;
9726 PyObject * obj0 = 0 ;
9727 char *kwnames[] = {
9728 (char *) "self", NULL
9729 };
9730
9731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9733 if (SWIG_arg_fail(1)) SWIG_fail;
9734 {
9735 PyThreadState* __tstate = wxPyBeginAllowThreads();
9736 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9737
9738 wxPyEndAllowThreads(__tstate);
9739 if (PyErr_Occurred()) SWIG_fail;
9740 }
9741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9742 return resultobj;
9743 fail:
9744 return NULL;
9745 }
9746
9747
9748 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9749 PyObject *resultobj;
9750 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9751 bool result;
9752 PyObject * obj0 = 0 ;
9753 char *kwnames[] = {
9754 (char *) "self", NULL
9755 };
9756
9757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9759 if (SWIG_arg_fail(1)) SWIG_fail;
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9763
9764 wxPyEndAllowThreads(__tstate);
9765 if (PyErr_Occurred()) SWIG_fail;
9766 }
9767 {
9768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9769 }
9770 return resultobj;
9771 fail:
9772 return NULL;
9773 }
9774
9775
9776 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9777 PyObject *resultobj;
9778 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9779 bool arg2 ;
9780 PyObject * obj0 = 0 ;
9781 PyObject * obj1 = 0 ;
9782 char *kwnames[] = {
9783 (char *) "self",(char *) "bDoPass", NULL
9784 };
9785
9786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9788 if (SWIG_arg_fail(1)) SWIG_fail;
9789 {
9790 arg2 = (bool)(SWIG_As_bool(obj1));
9791 if (SWIG_arg_fail(2)) SWIG_fail;
9792 }
9793 {
9794 PyThreadState* __tstate = wxPyBeginAllowThreads();
9795 (arg1)->PassMessages(arg2);
9796
9797 wxPyEndAllowThreads(__tstate);
9798 if (PyErr_Occurred()) SWIG_fail;
9799 }
9800 Py_INCREF(Py_None); resultobj = Py_None;
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9808 PyObject *obj;
9809 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9810 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9811 Py_INCREF(obj);
9812 return Py_BuildValue((char *)"");
9813 }
9814 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9815 PyObject *resultobj;
9816 wxLog *arg1 = (wxLog *) 0 ;
9817 wxLogChain *result;
9818 PyObject * obj0 = 0 ;
9819 char *kwnames[] = {
9820 (char *) "logger", NULL
9821 };
9822
9823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9825 if (SWIG_arg_fail(1)) SWIG_fail;
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 result = (wxLogChain *)new wxLogChain(arg1);
9829
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9834 return resultobj;
9835 fail:
9836 return NULL;
9837 }
9838
9839
9840 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9841 PyObject *resultobj;
9842 wxLogChain *arg1 = (wxLogChain *) 0 ;
9843 wxLog *arg2 = (wxLog *) 0 ;
9844 PyObject * obj0 = 0 ;
9845 PyObject * obj1 = 0 ;
9846 char *kwnames[] = {
9847 (char *) "self",(char *) "logger", NULL
9848 };
9849
9850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9852 if (SWIG_arg_fail(1)) SWIG_fail;
9853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9854 if (SWIG_arg_fail(2)) SWIG_fail;
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 (arg1)->SetLog(arg2);
9858
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 Py_INCREF(Py_None); resultobj = Py_None;
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj;
9871 wxLogChain *arg1 = (wxLogChain *) 0 ;
9872 bool arg2 ;
9873 PyObject * obj0 = 0 ;
9874 PyObject * obj1 = 0 ;
9875 char *kwnames[] = {
9876 (char *) "self",(char *) "bDoPass", NULL
9877 };
9878
9879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9881 if (SWIG_arg_fail(1)) SWIG_fail;
9882 {
9883 arg2 = (bool)(SWIG_As_bool(obj1));
9884 if (SWIG_arg_fail(2)) SWIG_fail;
9885 }
9886 {
9887 PyThreadState* __tstate = wxPyBeginAllowThreads();
9888 (arg1)->PassMessages(arg2);
9889
9890 wxPyEndAllowThreads(__tstate);
9891 if (PyErr_Occurred()) SWIG_fail;
9892 }
9893 Py_INCREF(Py_None); resultobj = Py_None;
9894 return resultobj;
9895 fail:
9896 return NULL;
9897 }
9898
9899
9900 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9901 PyObject *resultobj;
9902 wxLogChain *arg1 = (wxLogChain *) 0 ;
9903 bool result;
9904 PyObject * obj0 = 0 ;
9905 char *kwnames[] = {
9906 (char *) "self", NULL
9907 };
9908
9909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9911 if (SWIG_arg_fail(1)) SWIG_fail;
9912 {
9913 PyThreadState* __tstate = wxPyBeginAllowThreads();
9914 result = (bool)(arg1)->IsPassingMessages();
9915
9916 wxPyEndAllowThreads(__tstate);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 {
9920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9921 }
9922 return resultobj;
9923 fail:
9924 return NULL;
9925 }
9926
9927
9928 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9929 PyObject *resultobj;
9930 wxLogChain *arg1 = (wxLogChain *) 0 ;
9931 wxLog *result;
9932 PyObject * obj0 = 0 ;
9933 char *kwnames[] = {
9934 (char *) "self", NULL
9935 };
9936
9937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9939 if (SWIG_arg_fail(1)) SWIG_fail;
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 result = (wxLog *)(arg1)->GetOldLog();
9943
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9948 return resultobj;
9949 fail:
9950 return NULL;
9951 }
9952
9953
9954 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9955 PyObject *obj;
9956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9957 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9958 Py_INCREF(obj);
9959 return Py_BuildValue((char *)"");
9960 }
9961 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj;
9963 unsigned long result;
9964 char *kwnames[] = {
9965 NULL
9966 };
9967
9968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9969 {
9970 PyThreadState* __tstate = wxPyBeginAllowThreads();
9971 result = (unsigned long)wxSysErrorCode();
9972
9973 wxPyEndAllowThreads(__tstate);
9974 if (PyErr_Occurred()) SWIG_fail;
9975 }
9976 {
9977 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9978 }
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9986 PyObject *resultobj;
9987 unsigned long arg1 = (unsigned long) 0 ;
9988 wxString result;
9989 PyObject * obj0 = 0 ;
9990 char *kwnames[] = {
9991 (char *) "nErrCode", NULL
9992 };
9993
9994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9995 if (obj0) {
9996 {
9997 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9998 if (SWIG_arg_fail(1)) SWIG_fail;
9999 }
10000 }
10001 {
10002 PyThreadState* __tstate = wxPyBeginAllowThreads();
10003 result = wxSysErrorMsg(arg1);
10004
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 {
10009 #if wxUSE_UNICODE
10010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10011 #else
10012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10013 #endif
10014 }
10015 return resultobj;
10016 fail:
10017 return NULL;
10018 }
10019
10020
10021 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj;
10023 wxString *arg1 = 0 ;
10024 bool temp1 = false ;
10025 PyObject * obj0 = 0 ;
10026 char *kwnames[] = {
10027 (char *) "msg", NULL
10028 };
10029
10030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10031 {
10032 arg1 = wxString_in_helper(obj0);
10033 if (arg1 == NULL) SWIG_fail;
10034 temp1 = true;
10035 }
10036 {
10037 PyThreadState* __tstate = wxPyBeginAllowThreads();
10038 wxPyLogFatalError((wxString const &)*arg1);
10039
10040 wxPyEndAllowThreads(__tstate);
10041 if (PyErr_Occurred()) SWIG_fail;
10042 }
10043 Py_INCREF(Py_None); resultobj = Py_None;
10044 {
10045 if (temp1)
10046 delete arg1;
10047 }
10048 return resultobj;
10049 fail:
10050 {
10051 if (temp1)
10052 delete arg1;
10053 }
10054 return NULL;
10055 }
10056
10057
10058 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10059 PyObject *resultobj;
10060 wxString *arg1 = 0 ;
10061 bool temp1 = false ;
10062 PyObject * obj0 = 0 ;
10063 char *kwnames[] = {
10064 (char *) "msg", NULL
10065 };
10066
10067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10068 {
10069 arg1 = wxString_in_helper(obj0);
10070 if (arg1 == NULL) SWIG_fail;
10071 temp1 = true;
10072 }
10073 {
10074 PyThreadState* __tstate = wxPyBeginAllowThreads();
10075 wxPyLogError((wxString const &)*arg1);
10076
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 Py_INCREF(Py_None); resultobj = Py_None;
10081 {
10082 if (temp1)
10083 delete arg1;
10084 }
10085 return resultobj;
10086 fail:
10087 {
10088 if (temp1)
10089 delete arg1;
10090 }
10091 return NULL;
10092 }
10093
10094
10095 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj;
10097 wxString *arg1 = 0 ;
10098 bool temp1 = false ;
10099 PyObject * obj0 = 0 ;
10100 char *kwnames[] = {
10101 (char *) "msg", NULL
10102 };
10103
10104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10105 {
10106 arg1 = wxString_in_helper(obj0);
10107 if (arg1 == NULL) SWIG_fail;
10108 temp1 = true;
10109 }
10110 {
10111 PyThreadState* __tstate = wxPyBeginAllowThreads();
10112 wxPyLogWarning((wxString const &)*arg1);
10113
10114 wxPyEndAllowThreads(__tstate);
10115 if (PyErr_Occurred()) SWIG_fail;
10116 }
10117 Py_INCREF(Py_None); resultobj = Py_None;
10118 {
10119 if (temp1)
10120 delete arg1;
10121 }
10122 return resultobj;
10123 fail:
10124 {
10125 if (temp1)
10126 delete arg1;
10127 }
10128 return NULL;
10129 }
10130
10131
10132 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10133 PyObject *resultobj;
10134 wxString *arg1 = 0 ;
10135 bool temp1 = false ;
10136 PyObject * obj0 = 0 ;
10137 char *kwnames[] = {
10138 (char *) "msg", NULL
10139 };
10140
10141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10142 {
10143 arg1 = wxString_in_helper(obj0);
10144 if (arg1 == NULL) SWIG_fail;
10145 temp1 = true;
10146 }
10147 {
10148 PyThreadState* __tstate = wxPyBeginAllowThreads();
10149 wxPyLogMessage((wxString const &)*arg1);
10150
10151 wxPyEndAllowThreads(__tstate);
10152 if (PyErr_Occurred()) SWIG_fail;
10153 }
10154 Py_INCREF(Py_None); resultobj = Py_None;
10155 {
10156 if (temp1)
10157 delete arg1;
10158 }
10159 return resultobj;
10160 fail:
10161 {
10162 if (temp1)
10163 delete arg1;
10164 }
10165 return NULL;
10166 }
10167
10168
10169 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10170 PyObject *resultobj;
10171 wxString *arg1 = 0 ;
10172 bool temp1 = false ;
10173 PyObject * obj0 = 0 ;
10174 char *kwnames[] = {
10175 (char *) "msg", NULL
10176 };
10177
10178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10179 {
10180 arg1 = wxString_in_helper(obj0);
10181 if (arg1 == NULL) SWIG_fail;
10182 temp1 = true;
10183 }
10184 {
10185 PyThreadState* __tstate = wxPyBeginAllowThreads();
10186 wxPyLogInfo((wxString const &)*arg1);
10187
10188 wxPyEndAllowThreads(__tstate);
10189 if (PyErr_Occurred()) SWIG_fail;
10190 }
10191 Py_INCREF(Py_None); resultobj = Py_None;
10192 {
10193 if (temp1)
10194 delete arg1;
10195 }
10196 return resultobj;
10197 fail:
10198 {
10199 if (temp1)
10200 delete arg1;
10201 }
10202 return NULL;
10203 }
10204
10205
10206 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj;
10208 wxString *arg1 = 0 ;
10209 bool temp1 = false ;
10210 PyObject * obj0 = 0 ;
10211 char *kwnames[] = {
10212 (char *) "msg", NULL
10213 };
10214
10215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10216 {
10217 arg1 = wxString_in_helper(obj0);
10218 if (arg1 == NULL) SWIG_fail;
10219 temp1 = true;
10220 }
10221 {
10222 PyThreadState* __tstate = wxPyBeginAllowThreads();
10223 wxPyLogDebug((wxString const &)*arg1);
10224
10225 wxPyEndAllowThreads(__tstate);
10226 if (PyErr_Occurred()) SWIG_fail;
10227 }
10228 Py_INCREF(Py_None); resultobj = Py_None;
10229 {
10230 if (temp1)
10231 delete arg1;
10232 }
10233 return resultobj;
10234 fail:
10235 {
10236 if (temp1)
10237 delete arg1;
10238 }
10239 return NULL;
10240 }
10241
10242
10243 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10244 PyObject *resultobj;
10245 wxString *arg1 = 0 ;
10246 bool temp1 = false ;
10247 PyObject * obj0 = 0 ;
10248 char *kwnames[] = {
10249 (char *) "msg", NULL
10250 };
10251
10252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10253 {
10254 arg1 = wxString_in_helper(obj0);
10255 if (arg1 == NULL) SWIG_fail;
10256 temp1 = true;
10257 }
10258 {
10259 PyThreadState* __tstate = wxPyBeginAllowThreads();
10260 wxPyLogVerbose((wxString const &)*arg1);
10261
10262 wxPyEndAllowThreads(__tstate);
10263 if (PyErr_Occurred()) SWIG_fail;
10264 }
10265 Py_INCREF(Py_None); resultobj = Py_None;
10266 {
10267 if (temp1)
10268 delete arg1;
10269 }
10270 return resultobj;
10271 fail:
10272 {
10273 if (temp1)
10274 delete arg1;
10275 }
10276 return NULL;
10277 }
10278
10279
10280 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10281 PyObject *resultobj;
10282 wxString *arg1 = 0 ;
10283 bool temp1 = false ;
10284 PyObject * obj0 = 0 ;
10285 char *kwnames[] = {
10286 (char *) "msg", NULL
10287 };
10288
10289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10290 {
10291 arg1 = wxString_in_helper(obj0);
10292 if (arg1 == NULL) SWIG_fail;
10293 temp1 = true;
10294 }
10295 {
10296 PyThreadState* __tstate = wxPyBeginAllowThreads();
10297 wxPyLogStatus((wxString const &)*arg1);
10298
10299 wxPyEndAllowThreads(__tstate);
10300 if (PyErr_Occurred()) SWIG_fail;
10301 }
10302 Py_INCREF(Py_None); resultobj = Py_None;
10303 {
10304 if (temp1)
10305 delete arg1;
10306 }
10307 return resultobj;
10308 fail:
10309 {
10310 if (temp1)
10311 delete arg1;
10312 }
10313 return NULL;
10314 }
10315
10316
10317 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10318 PyObject *resultobj;
10319 wxFrame *arg1 = (wxFrame *) 0 ;
10320 wxString *arg2 = 0 ;
10321 bool temp2 = false ;
10322 PyObject * obj0 = 0 ;
10323 PyObject * obj1 = 0 ;
10324 char *kwnames[] = {
10325 (char *) "pFrame",(char *) "msg", NULL
10326 };
10327
10328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10330 if (SWIG_arg_fail(1)) SWIG_fail;
10331 {
10332 arg2 = wxString_in_helper(obj1);
10333 if (arg2 == NULL) SWIG_fail;
10334 temp2 = true;
10335 }
10336 {
10337 PyThreadState* __tstate = wxPyBeginAllowThreads();
10338 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10339
10340 wxPyEndAllowThreads(__tstate);
10341 if (PyErr_Occurred()) SWIG_fail;
10342 }
10343 Py_INCREF(Py_None); resultobj = Py_None;
10344 {
10345 if (temp2)
10346 delete arg2;
10347 }
10348 return resultobj;
10349 fail:
10350 {
10351 if (temp2)
10352 delete arg2;
10353 }
10354 return NULL;
10355 }
10356
10357
10358 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10359 PyObject *resultobj;
10360 wxString *arg1 = 0 ;
10361 bool temp1 = false ;
10362 PyObject * obj0 = 0 ;
10363 char *kwnames[] = {
10364 (char *) "msg", NULL
10365 };
10366
10367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10368 {
10369 arg1 = wxString_in_helper(obj0);
10370 if (arg1 == NULL) SWIG_fail;
10371 temp1 = true;
10372 }
10373 {
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 wxPyLogSysError((wxString const &)*arg1);
10376
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 Py_INCREF(Py_None); resultobj = Py_None;
10381 {
10382 if (temp1)
10383 delete arg1;
10384 }
10385 return resultobj;
10386 fail:
10387 {
10388 if (temp1)
10389 delete arg1;
10390 }
10391 return NULL;
10392 }
10393
10394
10395 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10396 PyObject *resultobj;
10397 unsigned long arg1 ;
10398 wxString *arg2 = 0 ;
10399 bool temp2 = false ;
10400 PyObject * obj0 = 0 ;
10401 PyObject * obj1 = 0 ;
10402 char *kwnames[] = {
10403 (char *) "level",(char *) "msg", NULL
10404 };
10405
10406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10407 {
10408 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10409 if (SWIG_arg_fail(1)) SWIG_fail;
10410 }
10411 {
10412 arg2 = wxString_in_helper(obj1);
10413 if (arg2 == NULL) SWIG_fail;
10414 temp2 = true;
10415 }
10416 {
10417 PyThreadState* __tstate = wxPyBeginAllowThreads();
10418 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10419
10420 wxPyEndAllowThreads(__tstate);
10421 if (PyErr_Occurred()) SWIG_fail;
10422 }
10423 Py_INCREF(Py_None); resultobj = Py_None;
10424 {
10425 if (temp2)
10426 delete arg2;
10427 }
10428 return resultobj;
10429 fail:
10430 {
10431 if (temp2)
10432 delete arg2;
10433 }
10434 return NULL;
10435 }
10436
10437
10438 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10439 PyObject *resultobj;
10440 unsigned long arg1 ;
10441 wxString *arg2 = 0 ;
10442 bool temp2 = false ;
10443 PyObject * obj0 = 0 ;
10444 PyObject * obj1 = 0 ;
10445
10446 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10447 {
10448 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10449 if (SWIG_arg_fail(1)) SWIG_fail;
10450 }
10451 {
10452 arg2 = wxString_in_helper(obj1);
10453 if (arg2 == NULL) SWIG_fail;
10454 temp2 = true;
10455 }
10456 {
10457 PyThreadState* __tstate = wxPyBeginAllowThreads();
10458 wxPyLogTrace(arg1,(wxString const &)*arg2);
10459
10460 wxPyEndAllowThreads(__tstate);
10461 if (PyErr_Occurred()) SWIG_fail;
10462 }
10463 Py_INCREF(Py_None); resultobj = Py_None;
10464 {
10465 if (temp2)
10466 delete arg2;
10467 }
10468 return resultobj;
10469 fail:
10470 {
10471 if (temp2)
10472 delete arg2;
10473 }
10474 return NULL;
10475 }
10476
10477
10478 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10479 PyObject *resultobj;
10480 wxString *arg1 = 0 ;
10481 wxString *arg2 = 0 ;
10482 bool temp1 = false ;
10483 bool temp2 = false ;
10484 PyObject * obj0 = 0 ;
10485 PyObject * obj1 = 0 ;
10486
10487 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10488 {
10489 arg1 = wxString_in_helper(obj0);
10490 if (arg1 == NULL) SWIG_fail;
10491 temp1 = true;
10492 }
10493 {
10494 arg2 = wxString_in_helper(obj1);
10495 if (arg2 == NULL) SWIG_fail;
10496 temp2 = true;
10497 }
10498 {
10499 PyThreadState* __tstate = wxPyBeginAllowThreads();
10500 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10501
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 Py_INCREF(Py_None); resultobj = Py_None;
10506 {
10507 if (temp1)
10508 delete arg1;
10509 }
10510 {
10511 if (temp2)
10512 delete arg2;
10513 }
10514 return resultobj;
10515 fail:
10516 {
10517 if (temp1)
10518 delete arg1;
10519 }
10520 {
10521 if (temp2)
10522 delete arg2;
10523 }
10524 return NULL;
10525 }
10526
10527
10528 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10529 int argc;
10530 PyObject *argv[3];
10531 int ii;
10532
10533 argc = PyObject_Length(args);
10534 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10535 argv[ii] = PyTuple_GetItem(args,ii);
10536 }
10537 if (argc == 2) {
10538 int _v;
10539 {
10540 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10541 }
10542 if (_v) {
10543 {
10544 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10545 }
10546 if (_v) {
10547 return _wrap_LogTrace__SWIG_1(self,args);
10548 }
10549 }
10550 }
10551 if (argc == 2) {
10552 int _v;
10553 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10554 if (_v) {
10555 {
10556 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10557 }
10558 if (_v) {
10559 return _wrap_LogTrace__SWIG_0(self,args);
10560 }
10561 }
10562 }
10563
10564 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10565 return NULL;
10566 }
10567
10568
10569 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10570 PyObject *resultobj;
10571 wxString *arg1 = 0 ;
10572 wxString *arg2 = 0 ;
10573 bool temp1 = false ;
10574 bool temp2 = false ;
10575 PyObject * obj0 = 0 ;
10576 PyObject * obj1 = 0 ;
10577 char *kwnames[] = {
10578 (char *) "title",(char *) "text", NULL
10579 };
10580
10581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10582 {
10583 arg1 = wxString_in_helper(obj0);
10584 if (arg1 == NULL) SWIG_fail;
10585 temp1 = true;
10586 }
10587 {
10588 arg2 = wxString_in_helper(obj1);
10589 if (arg2 == NULL) SWIG_fail;
10590 temp2 = true;
10591 }
10592 {
10593 PyThreadState* __tstate = wxPyBeginAllowThreads();
10594 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10595
10596 wxPyEndAllowThreads(__tstate);
10597 if (PyErr_Occurred()) SWIG_fail;
10598 }
10599 Py_INCREF(Py_None); resultobj = Py_None;
10600 {
10601 if (temp1)
10602 delete arg1;
10603 }
10604 {
10605 if (temp2)
10606 delete arg2;
10607 }
10608 return resultobj;
10609 fail:
10610 {
10611 if (temp1)
10612 delete arg1;
10613 }
10614 {
10615 if (temp2)
10616 delete arg2;
10617 }
10618 return NULL;
10619 }
10620
10621
10622 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10623 PyObject *resultobj;
10624 wxLogNull *result;
10625 char *kwnames[] = {
10626 NULL
10627 };
10628
10629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = (wxLogNull *)new wxLogNull();
10633
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10638 return resultobj;
10639 fail:
10640 return NULL;
10641 }
10642
10643
10644 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10645 PyObject *resultobj;
10646 wxLogNull *arg1 = (wxLogNull *) 0 ;
10647 PyObject * obj0 = 0 ;
10648 char *kwnames[] = {
10649 (char *) "self", NULL
10650 };
10651
10652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10654 if (SWIG_arg_fail(1)) SWIG_fail;
10655 {
10656 PyThreadState* __tstate = wxPyBeginAllowThreads();
10657 delete arg1;
10658
10659 wxPyEndAllowThreads(__tstate);
10660 if (PyErr_Occurred()) SWIG_fail;
10661 }
10662 Py_INCREF(Py_None); resultobj = Py_None;
10663 return resultobj;
10664 fail:
10665 return NULL;
10666 }
10667
10668
10669 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10670 PyObject *obj;
10671 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10672 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10673 Py_INCREF(obj);
10674 return Py_BuildValue((char *)"");
10675 }
10676 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10677 PyObject *resultobj;
10678 wxPyLog *result;
10679 char *kwnames[] = {
10680 NULL
10681 };
10682
10683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10684 {
10685 PyThreadState* __tstate = wxPyBeginAllowThreads();
10686 result = (wxPyLog *)new wxPyLog();
10687
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10699 PyObject *resultobj;
10700 wxPyLog *arg1 = (wxPyLog *) 0 ;
10701 PyObject *arg2 = (PyObject *) 0 ;
10702 PyObject *arg3 = (PyObject *) 0 ;
10703 PyObject * obj0 = 0 ;
10704 PyObject * obj1 = 0 ;
10705 PyObject * obj2 = 0 ;
10706 char *kwnames[] = {
10707 (char *) "self",(char *) "self",(char *) "_class", NULL
10708 };
10709
10710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10712 if (SWIG_arg_fail(1)) SWIG_fail;
10713 arg2 = obj1;
10714 arg3 = obj2;
10715 {
10716 PyThreadState* __tstate = wxPyBeginAllowThreads();
10717 (arg1)->_setCallbackInfo(arg2,arg3);
10718
10719 wxPyEndAllowThreads(__tstate);
10720 if (PyErr_Occurred()) SWIG_fail;
10721 }
10722 Py_INCREF(Py_None); resultobj = Py_None;
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10730 PyObject *obj;
10731 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10732 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10733 Py_INCREF(obj);
10734 return Py_BuildValue((char *)"");
10735 }
10736 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10737 PyObject *resultobj;
10738 int arg1 ;
10739 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10740 int arg3 = (int) wxKILL_NOCHILDREN ;
10741 wxKillError result;
10742 PyObject * obj0 = 0 ;
10743 PyObject * obj1 = 0 ;
10744 PyObject * obj2 = 0 ;
10745 char *kwnames[] = {
10746 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10747 };
10748
10749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10750 {
10751 arg1 = (int)(SWIG_As_int(obj0));
10752 if (SWIG_arg_fail(1)) SWIG_fail;
10753 }
10754 if (obj1) {
10755 {
10756 arg2 = (wxSignal)(SWIG_As_int(obj1));
10757 if (SWIG_arg_fail(2)) SWIG_fail;
10758 }
10759 }
10760 if (obj2) {
10761 {
10762 arg3 = (int)(SWIG_As_int(obj2));
10763 if (SWIG_arg_fail(3)) SWIG_fail;
10764 }
10765 }
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10769
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 resultobj = SWIG_From_int((result));
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10781 PyObject *resultobj;
10782 int arg1 ;
10783 bool result;
10784 PyObject * obj0 = 0 ;
10785 char *kwnames[] = {
10786 (char *) "pid", NULL
10787 };
10788
10789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10790 {
10791 arg1 = (int)(SWIG_As_int(obj0));
10792 if (SWIG_arg_fail(1)) SWIG_fail;
10793 }
10794 {
10795 PyThreadState* __tstate = wxPyBeginAllowThreads();
10796 result = (bool)wxPyProcess::Exists(arg1);
10797
10798 wxPyEndAllowThreads(__tstate);
10799 if (PyErr_Occurred()) SWIG_fail;
10800 }
10801 {
10802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10803 }
10804 return resultobj;
10805 fail:
10806 return NULL;
10807 }
10808
10809
10810 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10811 PyObject *resultobj;
10812 wxString *arg1 = 0 ;
10813 int arg2 = (int) wxEXEC_ASYNC ;
10814 wxPyProcess *result;
10815 bool temp1 = false ;
10816 PyObject * obj0 = 0 ;
10817 PyObject * obj1 = 0 ;
10818 char *kwnames[] = {
10819 (char *) "cmd",(char *) "flags", NULL
10820 };
10821
10822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10823 {
10824 arg1 = wxString_in_helper(obj0);
10825 if (arg1 == NULL) SWIG_fail;
10826 temp1 = true;
10827 }
10828 if (obj1) {
10829 {
10830 arg2 = (int)(SWIG_As_int(obj1));
10831 if (SWIG_arg_fail(2)) SWIG_fail;
10832 }
10833 }
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10837
10838 wxPyEndAllowThreads(__tstate);
10839 if (PyErr_Occurred()) SWIG_fail;
10840 }
10841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10842 {
10843 if (temp1)
10844 delete arg1;
10845 }
10846 return resultobj;
10847 fail:
10848 {
10849 if (temp1)
10850 delete arg1;
10851 }
10852 return NULL;
10853 }
10854
10855
10856 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10857 PyObject *resultobj;
10858 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10859 int arg2 = (int) -1 ;
10860 wxPyProcess *result;
10861 PyObject * obj0 = 0 ;
10862 PyObject * obj1 = 0 ;
10863 char *kwnames[] = {
10864 (char *) "parent",(char *) "id", NULL
10865 };
10866
10867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10868 if (obj0) {
10869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10870 if (SWIG_arg_fail(1)) SWIG_fail;
10871 }
10872 if (obj1) {
10873 {
10874 arg2 = (int)(SWIG_As_int(obj1));
10875 if (SWIG_arg_fail(2)) SWIG_fail;
10876 }
10877 }
10878 {
10879 PyThreadState* __tstate = wxPyBeginAllowThreads();
10880 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10881
10882 wxPyEndAllowThreads(__tstate);
10883 if (PyErr_Occurred()) SWIG_fail;
10884 }
10885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10886 return resultobj;
10887 fail:
10888 return NULL;
10889 }
10890
10891
10892 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10893 PyObject *resultobj;
10894 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10895 PyObject *arg2 = (PyObject *) 0 ;
10896 PyObject *arg3 = (PyObject *) 0 ;
10897 PyObject * obj0 = 0 ;
10898 PyObject * obj1 = 0 ;
10899 PyObject * obj2 = 0 ;
10900 char *kwnames[] = {
10901 (char *) "self",(char *) "self",(char *) "_class", NULL
10902 };
10903
10904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10906 if (SWIG_arg_fail(1)) SWIG_fail;
10907 arg2 = obj1;
10908 arg3 = obj2;
10909 {
10910 PyThreadState* __tstate = wxPyBeginAllowThreads();
10911 (arg1)->_setCallbackInfo(arg2,arg3);
10912
10913 wxPyEndAllowThreads(__tstate);
10914 if (PyErr_Occurred()) SWIG_fail;
10915 }
10916 Py_INCREF(Py_None); resultobj = Py_None;
10917 return resultobj;
10918 fail:
10919 return NULL;
10920 }
10921
10922
10923 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10924 PyObject *resultobj;
10925 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10926 int arg2 ;
10927 int arg3 ;
10928 PyObject * obj0 = 0 ;
10929 PyObject * obj1 = 0 ;
10930 PyObject * obj2 = 0 ;
10931 char *kwnames[] = {
10932 (char *) "self",(char *) "pid",(char *) "status", NULL
10933 };
10934
10935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10937 if (SWIG_arg_fail(1)) SWIG_fail;
10938 {
10939 arg2 = (int)(SWIG_As_int(obj1));
10940 if (SWIG_arg_fail(2)) SWIG_fail;
10941 }
10942 {
10943 arg3 = (int)(SWIG_As_int(obj2));
10944 if (SWIG_arg_fail(3)) SWIG_fail;
10945 }
10946 {
10947 PyThreadState* __tstate = wxPyBeginAllowThreads();
10948 (arg1)->base_OnTerminate(arg2,arg3);
10949
10950 wxPyEndAllowThreads(__tstate);
10951 if (PyErr_Occurred()) SWIG_fail;
10952 }
10953 Py_INCREF(Py_None); resultobj = Py_None;
10954 return resultobj;
10955 fail:
10956 return NULL;
10957 }
10958
10959
10960 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10961 PyObject *resultobj;
10962 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10963 PyObject * obj0 = 0 ;
10964 char *kwnames[] = {
10965 (char *) "self", NULL
10966 };
10967
10968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10970 if (SWIG_arg_fail(1)) SWIG_fail;
10971 {
10972 PyThreadState* __tstate = wxPyBeginAllowThreads();
10973 (arg1)->Redirect();
10974
10975 wxPyEndAllowThreads(__tstate);
10976 if (PyErr_Occurred()) SWIG_fail;
10977 }
10978 Py_INCREF(Py_None); resultobj = Py_None;
10979 return resultobj;
10980 fail:
10981 return NULL;
10982 }
10983
10984
10985 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10986 PyObject *resultobj;
10987 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10988 bool result;
10989 PyObject * obj0 = 0 ;
10990 char *kwnames[] = {
10991 (char *) "self", NULL
10992 };
10993
10994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10996 if (SWIG_arg_fail(1)) SWIG_fail;
10997 {
10998 PyThreadState* __tstate = wxPyBeginAllowThreads();
10999 result = (bool)(arg1)->IsRedirected();
11000
11001 wxPyEndAllowThreads(__tstate);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 {
11005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11006 }
11007 return resultobj;
11008 fail:
11009 return NULL;
11010 }
11011
11012
11013 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11014 PyObject *resultobj;
11015 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11016 PyObject * obj0 = 0 ;
11017 char *kwnames[] = {
11018 (char *) "self", NULL
11019 };
11020
11021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11023 if (SWIG_arg_fail(1)) SWIG_fail;
11024 {
11025 PyThreadState* __tstate = wxPyBeginAllowThreads();
11026 (arg1)->Detach();
11027
11028 wxPyEndAllowThreads(__tstate);
11029 if (PyErr_Occurred()) SWIG_fail;
11030 }
11031 Py_INCREF(Py_None); resultobj = Py_None;
11032 return resultobj;
11033 fail:
11034 return NULL;
11035 }
11036
11037
11038 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11039 PyObject *resultobj;
11040 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11041 wxInputStream *result;
11042 PyObject * obj0 = 0 ;
11043 char *kwnames[] = {
11044 (char *) "self", NULL
11045 };
11046
11047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11049 if (SWIG_arg_fail(1)) SWIG_fail;
11050 {
11051 PyThreadState* __tstate = wxPyBeginAllowThreads();
11052 result = (wxInputStream *)(arg1)->GetInputStream();
11053
11054 wxPyEndAllowThreads(__tstate);
11055 if (PyErr_Occurred()) SWIG_fail;
11056 }
11057 {
11058 wxPyInputStream * _ptr = NULL;
11059
11060 if (result) {
11061 _ptr = new wxPyInputStream(result);
11062 }
11063 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11064 }
11065 return resultobj;
11066 fail:
11067 return NULL;
11068 }
11069
11070
11071 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11072 PyObject *resultobj;
11073 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11074 wxInputStream *result;
11075 PyObject * obj0 = 0 ;
11076 char *kwnames[] = {
11077 (char *) "self", NULL
11078 };
11079
11080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11082 if (SWIG_arg_fail(1)) SWIG_fail;
11083 {
11084 PyThreadState* __tstate = wxPyBeginAllowThreads();
11085 result = (wxInputStream *)(arg1)->GetErrorStream();
11086
11087 wxPyEndAllowThreads(__tstate);
11088 if (PyErr_Occurred()) SWIG_fail;
11089 }
11090 {
11091 wxPyInputStream * _ptr = NULL;
11092
11093 if (result) {
11094 _ptr = new wxPyInputStream(result);
11095 }
11096 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11097 }
11098 return resultobj;
11099 fail:
11100 return NULL;
11101 }
11102
11103
11104 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11105 PyObject *resultobj;
11106 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11107 wxOutputStream *result;
11108 PyObject * obj0 = 0 ;
11109 char *kwnames[] = {
11110 (char *) "self", NULL
11111 };
11112
11113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11115 if (SWIG_arg_fail(1)) SWIG_fail;
11116 {
11117 PyThreadState* __tstate = wxPyBeginAllowThreads();
11118 result = (wxOutputStream *)(arg1)->GetOutputStream();
11119
11120 wxPyEndAllowThreads(__tstate);
11121 if (PyErr_Occurred()) SWIG_fail;
11122 }
11123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11124 return resultobj;
11125 fail:
11126 return NULL;
11127 }
11128
11129
11130 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11131 PyObject *resultobj;
11132 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11133 PyObject * obj0 = 0 ;
11134 char *kwnames[] = {
11135 (char *) "self", NULL
11136 };
11137
11138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11140 if (SWIG_arg_fail(1)) SWIG_fail;
11141 {
11142 PyThreadState* __tstate = wxPyBeginAllowThreads();
11143 (arg1)->CloseOutput();
11144
11145 wxPyEndAllowThreads(__tstate);
11146 if (PyErr_Occurred()) SWIG_fail;
11147 }
11148 Py_INCREF(Py_None); resultobj = Py_None;
11149 return resultobj;
11150 fail:
11151 return NULL;
11152 }
11153
11154
11155 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj;
11157 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11158 bool result;
11159 PyObject * obj0 = 0 ;
11160 char *kwnames[] = {
11161 (char *) "self", NULL
11162 };
11163
11164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11166 if (SWIG_arg_fail(1)) SWIG_fail;
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11170
11171 wxPyEndAllowThreads(__tstate);
11172 if (PyErr_Occurred()) SWIG_fail;
11173 }
11174 {
11175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11176 }
11177 return resultobj;
11178 fail:
11179 return NULL;
11180 }
11181
11182
11183 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11184 PyObject *resultobj;
11185 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11186 bool result;
11187 PyObject * obj0 = 0 ;
11188 char *kwnames[] = {
11189 (char *) "self", NULL
11190 };
11191
11192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11194 if (SWIG_arg_fail(1)) SWIG_fail;
11195 {
11196 PyThreadState* __tstate = wxPyBeginAllowThreads();
11197 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11198
11199 wxPyEndAllowThreads(__tstate);
11200 if (PyErr_Occurred()) SWIG_fail;
11201 }
11202 {
11203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11204 }
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11212 PyObject *resultobj;
11213 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11214 bool result;
11215 PyObject * obj0 = 0 ;
11216 char *kwnames[] = {
11217 (char *) "self", NULL
11218 };
11219
11220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11222 if (SWIG_arg_fail(1)) SWIG_fail;
11223 {
11224 PyThreadState* __tstate = wxPyBeginAllowThreads();
11225 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11226
11227 wxPyEndAllowThreads(__tstate);
11228 if (PyErr_Occurred()) SWIG_fail;
11229 }
11230 {
11231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11232 }
11233 return resultobj;
11234 fail:
11235 return NULL;
11236 }
11237
11238
11239 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11240 PyObject *obj;
11241 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11242 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11243 Py_INCREF(obj);
11244 return Py_BuildValue((char *)"");
11245 }
11246 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11247 PyObject *resultobj;
11248 int arg1 = (int) 0 ;
11249 int arg2 = (int) 0 ;
11250 int arg3 = (int) 0 ;
11251 wxProcessEvent *result;
11252 PyObject * obj0 = 0 ;
11253 PyObject * obj1 = 0 ;
11254 PyObject * obj2 = 0 ;
11255 char *kwnames[] = {
11256 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11257 };
11258
11259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11260 if (obj0) {
11261 {
11262 arg1 = (int)(SWIG_As_int(obj0));
11263 if (SWIG_arg_fail(1)) SWIG_fail;
11264 }
11265 }
11266 if (obj1) {
11267 {
11268 arg2 = (int)(SWIG_As_int(obj1));
11269 if (SWIG_arg_fail(2)) SWIG_fail;
11270 }
11271 }
11272 if (obj2) {
11273 {
11274 arg3 = (int)(SWIG_As_int(obj2));
11275 if (SWIG_arg_fail(3)) SWIG_fail;
11276 }
11277 }
11278 {
11279 PyThreadState* __tstate = wxPyBeginAllowThreads();
11280 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11281
11282 wxPyEndAllowThreads(__tstate);
11283 if (PyErr_Occurred()) SWIG_fail;
11284 }
11285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11286 return resultobj;
11287 fail:
11288 return NULL;
11289 }
11290
11291
11292 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11293 PyObject *resultobj;
11294 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11295 int result;
11296 PyObject * obj0 = 0 ;
11297 char *kwnames[] = {
11298 (char *) "self", NULL
11299 };
11300
11301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11303 if (SWIG_arg_fail(1)) SWIG_fail;
11304 {
11305 PyThreadState* __tstate = wxPyBeginAllowThreads();
11306 result = (int)(arg1)->GetPid();
11307
11308 wxPyEndAllowThreads(__tstate);
11309 if (PyErr_Occurred()) SWIG_fail;
11310 }
11311 {
11312 resultobj = SWIG_From_int((int)(result));
11313 }
11314 return resultobj;
11315 fail:
11316 return NULL;
11317 }
11318
11319
11320 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11321 PyObject *resultobj;
11322 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11323 int result;
11324 PyObject * obj0 = 0 ;
11325 char *kwnames[] = {
11326 (char *) "self", NULL
11327 };
11328
11329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11331 if (SWIG_arg_fail(1)) SWIG_fail;
11332 {
11333 PyThreadState* __tstate = wxPyBeginAllowThreads();
11334 result = (int)(arg1)->GetExitCode();
11335
11336 wxPyEndAllowThreads(__tstate);
11337 if (PyErr_Occurred()) SWIG_fail;
11338 }
11339 {
11340 resultobj = SWIG_From_int((int)(result));
11341 }
11342 return resultobj;
11343 fail:
11344 return NULL;
11345 }
11346
11347
11348 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11349 PyObject *resultobj;
11350 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11351 int arg2 ;
11352 PyObject * obj0 = 0 ;
11353 PyObject * obj1 = 0 ;
11354 char *kwnames[] = {
11355 (char *) "self",(char *) "m_pid", NULL
11356 };
11357
11358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11360 if (SWIG_arg_fail(1)) SWIG_fail;
11361 {
11362 arg2 = (int)(SWIG_As_int(obj1));
11363 if (SWIG_arg_fail(2)) SWIG_fail;
11364 }
11365 if (arg1) (arg1)->m_pid = arg2;
11366
11367 Py_INCREF(Py_None); resultobj = Py_None;
11368 return resultobj;
11369 fail:
11370 return NULL;
11371 }
11372
11373
11374 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11375 PyObject *resultobj;
11376 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11377 int result;
11378 PyObject * obj0 = 0 ;
11379 char *kwnames[] = {
11380 (char *) "self", NULL
11381 };
11382
11383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11385 if (SWIG_arg_fail(1)) SWIG_fail;
11386 result = (int) ((arg1)->m_pid);
11387
11388 {
11389 resultobj = SWIG_From_int((int)(result));
11390 }
11391 return resultobj;
11392 fail:
11393 return NULL;
11394 }
11395
11396
11397 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11398 PyObject *resultobj;
11399 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11400 int arg2 ;
11401 PyObject * obj0 = 0 ;
11402 PyObject * obj1 = 0 ;
11403 char *kwnames[] = {
11404 (char *) "self",(char *) "m_exitcode", NULL
11405 };
11406
11407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11409 if (SWIG_arg_fail(1)) SWIG_fail;
11410 {
11411 arg2 = (int)(SWIG_As_int(obj1));
11412 if (SWIG_arg_fail(2)) SWIG_fail;
11413 }
11414 if (arg1) (arg1)->m_exitcode = arg2;
11415
11416 Py_INCREF(Py_None); resultobj = Py_None;
11417 return resultobj;
11418 fail:
11419 return NULL;
11420 }
11421
11422
11423 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11424 PyObject *resultobj;
11425 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11426 int result;
11427 PyObject * obj0 = 0 ;
11428 char *kwnames[] = {
11429 (char *) "self", NULL
11430 };
11431
11432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11434 if (SWIG_arg_fail(1)) SWIG_fail;
11435 result = (int) ((arg1)->m_exitcode);
11436
11437 {
11438 resultobj = SWIG_From_int((int)(result));
11439 }
11440 return resultobj;
11441 fail:
11442 return NULL;
11443 }
11444
11445
11446 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11447 PyObject *obj;
11448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11449 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11450 Py_INCREF(obj);
11451 return Py_BuildValue((char *)"");
11452 }
11453 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11454 PyObject *resultobj;
11455 wxString *arg1 = 0 ;
11456 int arg2 = (int) wxEXEC_ASYNC ;
11457 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11458 long result;
11459 bool temp1 = false ;
11460 PyObject * obj0 = 0 ;
11461 PyObject * obj1 = 0 ;
11462 PyObject * obj2 = 0 ;
11463 char *kwnames[] = {
11464 (char *) "command",(char *) "flags",(char *) "process", NULL
11465 };
11466
11467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11468 {
11469 arg1 = wxString_in_helper(obj0);
11470 if (arg1 == NULL) SWIG_fail;
11471 temp1 = true;
11472 }
11473 if (obj1) {
11474 {
11475 arg2 = (int)(SWIG_As_int(obj1));
11476 if (SWIG_arg_fail(2)) SWIG_fail;
11477 }
11478 }
11479 if (obj2) {
11480 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11481 if (SWIG_arg_fail(3)) SWIG_fail;
11482 }
11483 {
11484 if (!wxPyCheckForApp()) SWIG_fail;
11485 PyThreadState* __tstate = wxPyBeginAllowThreads();
11486 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11487
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 {
11492 resultobj = SWIG_From_long((long)(result));
11493 }
11494 {
11495 if (temp1)
11496 delete arg1;
11497 }
11498 return resultobj;
11499 fail:
11500 {
11501 if (temp1)
11502 delete arg1;
11503 }
11504 return NULL;
11505 }
11506
11507
11508 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11509 PyObject *resultobj;
11510 long arg1 ;
11511 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11512 wxKillError *arg3 = (wxKillError *) 0 ;
11513 int arg4 = (int) wxKILL_NOCHILDREN ;
11514 int result;
11515 wxKillError temp3 ;
11516 PyObject * obj0 = 0 ;
11517 PyObject * obj1 = 0 ;
11518 PyObject * obj2 = 0 ;
11519 char *kwnames[] = {
11520 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11521 };
11522
11523 {
11524 arg3 = &temp3;
11525 }
11526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11527 {
11528 arg1 = (long)(SWIG_As_long(obj0));
11529 if (SWIG_arg_fail(1)) SWIG_fail;
11530 }
11531 if (obj1) {
11532 {
11533 arg2 = (wxSignal)(SWIG_As_int(obj1));
11534 if (SWIG_arg_fail(2)) SWIG_fail;
11535 }
11536 }
11537 if (obj2) {
11538 {
11539 arg4 = (int)(SWIG_As_int(obj2));
11540 if (SWIG_arg_fail(4)) SWIG_fail;
11541 }
11542 }
11543 {
11544 PyThreadState* __tstate = wxPyBeginAllowThreads();
11545 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11546
11547 wxPyEndAllowThreads(__tstate);
11548 if (PyErr_Occurred()) SWIG_fail;
11549 }
11550 {
11551 resultobj = SWIG_From_int((int)(result));
11552 }
11553 {
11554 PyObject* o;
11555 o = PyInt_FromLong((long) (*arg3));
11556 resultobj = t_output_helper(resultobj, o);
11557 }
11558 return resultobj;
11559 fail:
11560 return NULL;
11561 }
11562
11563
11564 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11565 PyObject *resultobj;
11566 int arg1 = (int) wxJOYSTICK1 ;
11567 wxJoystick *result;
11568 PyObject * obj0 = 0 ;
11569 char *kwnames[] = {
11570 (char *) "joystick", NULL
11571 };
11572
11573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11574 if (obj0) {
11575 {
11576 arg1 = (int)(SWIG_As_int(obj0));
11577 if (SWIG_arg_fail(1)) SWIG_fail;
11578 }
11579 }
11580 {
11581 if (!wxPyCheckForApp()) SWIG_fail;
11582 PyThreadState* __tstate = wxPyBeginAllowThreads();
11583 result = (wxJoystick *)new wxJoystick(arg1);
11584
11585 wxPyEndAllowThreads(__tstate);
11586 if (PyErr_Occurred()) SWIG_fail;
11587 }
11588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11589 return resultobj;
11590 fail:
11591 return NULL;
11592 }
11593
11594
11595 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11596 PyObject *resultobj;
11597 wxJoystick *arg1 = (wxJoystick *) 0 ;
11598 PyObject * obj0 = 0 ;
11599 char *kwnames[] = {
11600 (char *) "self", NULL
11601 };
11602
11603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11605 if (SWIG_arg_fail(1)) SWIG_fail;
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 delete arg1;
11609
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 Py_INCREF(Py_None); resultobj = Py_None;
11614 return resultobj;
11615 fail:
11616 return NULL;
11617 }
11618
11619
11620 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11621 PyObject *resultobj;
11622 wxJoystick *arg1 = (wxJoystick *) 0 ;
11623 wxPoint result;
11624 PyObject * obj0 = 0 ;
11625 char *kwnames[] = {
11626 (char *) "self", NULL
11627 };
11628
11629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11631 if (SWIG_arg_fail(1)) SWIG_fail;
11632 {
11633 PyThreadState* __tstate = wxPyBeginAllowThreads();
11634 result = (arg1)->GetPosition();
11635
11636 wxPyEndAllowThreads(__tstate);
11637 if (PyErr_Occurred()) SWIG_fail;
11638 }
11639 {
11640 wxPoint * resultptr;
11641 resultptr = new wxPoint((wxPoint &)(result));
11642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11643 }
11644 return resultobj;
11645 fail:
11646 return NULL;
11647 }
11648
11649
11650 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11651 PyObject *resultobj;
11652 wxJoystick *arg1 = (wxJoystick *) 0 ;
11653 int result;
11654 PyObject * obj0 = 0 ;
11655 char *kwnames[] = {
11656 (char *) "self", NULL
11657 };
11658
11659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11661 if (SWIG_arg_fail(1)) SWIG_fail;
11662 {
11663 PyThreadState* __tstate = wxPyBeginAllowThreads();
11664 result = (int)(arg1)->GetZPosition();
11665
11666 wxPyEndAllowThreads(__tstate);
11667 if (PyErr_Occurred()) SWIG_fail;
11668 }
11669 {
11670 resultobj = SWIG_From_int((int)(result));
11671 }
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11679 PyObject *resultobj;
11680 wxJoystick *arg1 = (wxJoystick *) 0 ;
11681 int result;
11682 PyObject * obj0 = 0 ;
11683 char *kwnames[] = {
11684 (char *) "self", NULL
11685 };
11686
11687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11689 if (SWIG_arg_fail(1)) SWIG_fail;
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 result = (int)(arg1)->GetButtonState();
11693
11694 wxPyEndAllowThreads(__tstate);
11695 if (PyErr_Occurred()) SWIG_fail;
11696 }
11697 {
11698 resultobj = SWIG_From_int((int)(result));
11699 }
11700 return resultobj;
11701 fail:
11702 return NULL;
11703 }
11704
11705
11706 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11707 PyObject *resultobj;
11708 wxJoystick *arg1 = (wxJoystick *) 0 ;
11709 int result;
11710 PyObject * obj0 = 0 ;
11711 char *kwnames[] = {
11712 (char *) "self", NULL
11713 };
11714
11715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11717 if (SWIG_arg_fail(1)) SWIG_fail;
11718 {
11719 PyThreadState* __tstate = wxPyBeginAllowThreads();
11720 result = (int)(arg1)->GetPOVPosition();
11721
11722 wxPyEndAllowThreads(__tstate);
11723 if (PyErr_Occurred()) SWIG_fail;
11724 }
11725 {
11726 resultobj = SWIG_From_int((int)(result));
11727 }
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11735 PyObject *resultobj;
11736 wxJoystick *arg1 = (wxJoystick *) 0 ;
11737 int result;
11738 PyObject * obj0 = 0 ;
11739 char *kwnames[] = {
11740 (char *) "self", NULL
11741 };
11742
11743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11745 if (SWIG_arg_fail(1)) SWIG_fail;
11746 {
11747 PyThreadState* __tstate = wxPyBeginAllowThreads();
11748 result = (int)(arg1)->GetPOVCTSPosition();
11749
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 {
11754 resultobj = SWIG_From_int((int)(result));
11755 }
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11763 PyObject *resultobj;
11764 wxJoystick *arg1 = (wxJoystick *) 0 ;
11765 int result;
11766 PyObject * obj0 = 0 ;
11767 char *kwnames[] = {
11768 (char *) "self", NULL
11769 };
11770
11771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11773 if (SWIG_arg_fail(1)) SWIG_fail;
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 result = (int)(arg1)->GetRudderPosition();
11777
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 {
11782 resultobj = SWIG_From_int((int)(result));
11783 }
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11791 PyObject *resultobj;
11792 wxJoystick *arg1 = (wxJoystick *) 0 ;
11793 int result;
11794 PyObject * obj0 = 0 ;
11795 char *kwnames[] = {
11796 (char *) "self", NULL
11797 };
11798
11799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11801 if (SWIG_arg_fail(1)) SWIG_fail;
11802 {
11803 PyThreadState* __tstate = wxPyBeginAllowThreads();
11804 result = (int)(arg1)->GetUPosition();
11805
11806 wxPyEndAllowThreads(__tstate);
11807 if (PyErr_Occurred()) SWIG_fail;
11808 }
11809 {
11810 resultobj = SWIG_From_int((int)(result));
11811 }
11812 return resultobj;
11813 fail:
11814 return NULL;
11815 }
11816
11817
11818 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11819 PyObject *resultobj;
11820 wxJoystick *arg1 = (wxJoystick *) 0 ;
11821 int result;
11822 PyObject * obj0 = 0 ;
11823 char *kwnames[] = {
11824 (char *) "self", NULL
11825 };
11826
11827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11829 if (SWIG_arg_fail(1)) SWIG_fail;
11830 {
11831 PyThreadState* __tstate = wxPyBeginAllowThreads();
11832 result = (int)(arg1)->GetVPosition();
11833
11834 wxPyEndAllowThreads(__tstate);
11835 if (PyErr_Occurred()) SWIG_fail;
11836 }
11837 {
11838 resultobj = SWIG_From_int((int)(result));
11839 }
11840 return resultobj;
11841 fail:
11842 return NULL;
11843 }
11844
11845
11846 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11847 PyObject *resultobj;
11848 wxJoystick *arg1 = (wxJoystick *) 0 ;
11849 int result;
11850 PyObject * obj0 = 0 ;
11851 char *kwnames[] = {
11852 (char *) "self", NULL
11853 };
11854
11855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11857 if (SWIG_arg_fail(1)) SWIG_fail;
11858 {
11859 PyThreadState* __tstate = wxPyBeginAllowThreads();
11860 result = (int)(arg1)->GetMovementThreshold();
11861
11862 wxPyEndAllowThreads(__tstate);
11863 if (PyErr_Occurred()) SWIG_fail;
11864 }
11865 {
11866 resultobj = SWIG_From_int((int)(result));
11867 }
11868 return resultobj;
11869 fail:
11870 return NULL;
11871 }
11872
11873
11874 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11875 PyObject *resultobj;
11876 wxJoystick *arg1 = (wxJoystick *) 0 ;
11877 int arg2 ;
11878 PyObject * obj0 = 0 ;
11879 PyObject * obj1 = 0 ;
11880 char *kwnames[] = {
11881 (char *) "self",(char *) "threshold", NULL
11882 };
11883
11884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11886 if (SWIG_arg_fail(1)) SWIG_fail;
11887 {
11888 arg2 = (int)(SWIG_As_int(obj1));
11889 if (SWIG_arg_fail(2)) SWIG_fail;
11890 }
11891 {
11892 PyThreadState* __tstate = wxPyBeginAllowThreads();
11893 (arg1)->SetMovementThreshold(arg2);
11894
11895 wxPyEndAllowThreads(__tstate);
11896 if (PyErr_Occurred()) SWIG_fail;
11897 }
11898 Py_INCREF(Py_None); resultobj = Py_None;
11899 return resultobj;
11900 fail:
11901 return NULL;
11902 }
11903
11904
11905 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11906 PyObject *resultobj;
11907 wxJoystick *arg1 = (wxJoystick *) 0 ;
11908 bool result;
11909 PyObject * obj0 = 0 ;
11910 char *kwnames[] = {
11911 (char *) "self", NULL
11912 };
11913
11914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11916 if (SWIG_arg_fail(1)) SWIG_fail;
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 result = (bool)(arg1)->IsOk();
11920
11921 wxPyEndAllowThreads(__tstate);
11922 if (PyErr_Occurred()) SWIG_fail;
11923 }
11924 {
11925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11926 }
11927 return resultobj;
11928 fail:
11929 return NULL;
11930 }
11931
11932
11933 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11934 PyObject *resultobj;
11935 wxJoystick *arg1 = (wxJoystick *) 0 ;
11936 int result;
11937 PyObject * obj0 = 0 ;
11938 char *kwnames[] = {
11939 (char *) "self", NULL
11940 };
11941
11942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11944 if (SWIG_arg_fail(1)) SWIG_fail;
11945 {
11946 PyThreadState* __tstate = wxPyBeginAllowThreads();
11947 result = (int)(arg1)->GetNumberJoysticks();
11948
11949 wxPyEndAllowThreads(__tstate);
11950 if (PyErr_Occurred()) SWIG_fail;
11951 }
11952 {
11953 resultobj = SWIG_From_int((int)(result));
11954 }
11955 return resultobj;
11956 fail:
11957 return NULL;
11958 }
11959
11960
11961 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11962 PyObject *resultobj;
11963 wxJoystick *arg1 = (wxJoystick *) 0 ;
11964 int result;
11965 PyObject * obj0 = 0 ;
11966 char *kwnames[] = {
11967 (char *) "self", NULL
11968 };
11969
11970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11972 if (SWIG_arg_fail(1)) SWIG_fail;
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 result = (int)(arg1)->GetManufacturerId();
11976
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 {
11981 resultobj = SWIG_From_int((int)(result));
11982 }
11983 return resultobj;
11984 fail:
11985 return NULL;
11986 }
11987
11988
11989 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11990 PyObject *resultobj;
11991 wxJoystick *arg1 = (wxJoystick *) 0 ;
11992 int result;
11993 PyObject * obj0 = 0 ;
11994 char *kwnames[] = {
11995 (char *) "self", NULL
11996 };
11997
11998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12000 if (SWIG_arg_fail(1)) SWIG_fail;
12001 {
12002 PyThreadState* __tstate = wxPyBeginAllowThreads();
12003 result = (int)(arg1)->GetProductId();
12004
12005 wxPyEndAllowThreads(__tstate);
12006 if (PyErr_Occurred()) SWIG_fail;
12007 }
12008 {
12009 resultobj = SWIG_From_int((int)(result));
12010 }
12011 return resultobj;
12012 fail:
12013 return NULL;
12014 }
12015
12016
12017 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj;
12019 wxJoystick *arg1 = (wxJoystick *) 0 ;
12020 wxString result;
12021 PyObject * obj0 = 0 ;
12022 char *kwnames[] = {
12023 (char *) "self", NULL
12024 };
12025
12026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12028 if (SWIG_arg_fail(1)) SWIG_fail;
12029 {
12030 PyThreadState* __tstate = wxPyBeginAllowThreads();
12031 result = (arg1)->GetProductName();
12032
12033 wxPyEndAllowThreads(__tstate);
12034 if (PyErr_Occurred()) SWIG_fail;
12035 }
12036 {
12037 #if wxUSE_UNICODE
12038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12039 #else
12040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12041 #endif
12042 }
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj;
12051 wxJoystick *arg1 = (wxJoystick *) 0 ;
12052 int result;
12053 PyObject * obj0 = 0 ;
12054 char *kwnames[] = {
12055 (char *) "self", NULL
12056 };
12057
12058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12060 if (SWIG_arg_fail(1)) SWIG_fail;
12061 {
12062 PyThreadState* __tstate = wxPyBeginAllowThreads();
12063 result = (int)(arg1)->GetXMin();
12064
12065 wxPyEndAllowThreads(__tstate);
12066 if (PyErr_Occurred()) SWIG_fail;
12067 }
12068 {
12069 resultobj = SWIG_From_int((int)(result));
12070 }
12071 return resultobj;
12072 fail:
12073 return NULL;
12074 }
12075
12076
12077 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12078 PyObject *resultobj;
12079 wxJoystick *arg1 = (wxJoystick *) 0 ;
12080 int result;
12081 PyObject * obj0 = 0 ;
12082 char *kwnames[] = {
12083 (char *) "self", NULL
12084 };
12085
12086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12088 if (SWIG_arg_fail(1)) SWIG_fail;
12089 {
12090 PyThreadState* __tstate = wxPyBeginAllowThreads();
12091 result = (int)(arg1)->GetYMin();
12092
12093 wxPyEndAllowThreads(__tstate);
12094 if (PyErr_Occurred()) SWIG_fail;
12095 }
12096 {
12097 resultobj = SWIG_From_int((int)(result));
12098 }
12099 return resultobj;
12100 fail:
12101 return NULL;
12102 }
12103
12104
12105 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12106 PyObject *resultobj;
12107 wxJoystick *arg1 = (wxJoystick *) 0 ;
12108 int result;
12109 PyObject * obj0 = 0 ;
12110 char *kwnames[] = {
12111 (char *) "self", NULL
12112 };
12113
12114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12116 if (SWIG_arg_fail(1)) SWIG_fail;
12117 {
12118 PyThreadState* __tstate = wxPyBeginAllowThreads();
12119 result = (int)(arg1)->GetZMin();
12120
12121 wxPyEndAllowThreads(__tstate);
12122 if (PyErr_Occurred()) SWIG_fail;
12123 }
12124 {
12125 resultobj = SWIG_From_int((int)(result));
12126 }
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj;
12135 wxJoystick *arg1 = (wxJoystick *) 0 ;
12136 int result;
12137 PyObject * obj0 = 0 ;
12138 char *kwnames[] = {
12139 (char *) "self", NULL
12140 };
12141
12142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12144 if (SWIG_arg_fail(1)) SWIG_fail;
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 result = (int)(arg1)->GetXMax();
12148
12149 wxPyEndAllowThreads(__tstate);
12150 if (PyErr_Occurred()) SWIG_fail;
12151 }
12152 {
12153 resultobj = SWIG_From_int((int)(result));
12154 }
12155 return resultobj;
12156 fail:
12157 return NULL;
12158 }
12159
12160
12161 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12162 PyObject *resultobj;
12163 wxJoystick *arg1 = (wxJoystick *) 0 ;
12164 int result;
12165 PyObject * obj0 = 0 ;
12166 char *kwnames[] = {
12167 (char *) "self", NULL
12168 };
12169
12170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12172 if (SWIG_arg_fail(1)) SWIG_fail;
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 result = (int)(arg1)->GetYMax();
12176
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 {
12181 resultobj = SWIG_From_int((int)(result));
12182 }
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12190 PyObject *resultobj;
12191 wxJoystick *arg1 = (wxJoystick *) 0 ;
12192 int result;
12193 PyObject * obj0 = 0 ;
12194 char *kwnames[] = {
12195 (char *) "self", NULL
12196 };
12197
12198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12200 if (SWIG_arg_fail(1)) SWIG_fail;
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 result = (int)(arg1)->GetZMax();
12204
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 {
12209 resultobj = SWIG_From_int((int)(result));
12210 }
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj;
12219 wxJoystick *arg1 = (wxJoystick *) 0 ;
12220 int result;
12221 PyObject * obj0 = 0 ;
12222 char *kwnames[] = {
12223 (char *) "self", NULL
12224 };
12225
12226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12228 if (SWIG_arg_fail(1)) SWIG_fail;
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (int)(arg1)->GetNumberButtons();
12232
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 {
12237 resultobj = SWIG_From_int((int)(result));
12238 }
12239 return resultobj;
12240 fail:
12241 return NULL;
12242 }
12243
12244
12245 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12246 PyObject *resultobj;
12247 wxJoystick *arg1 = (wxJoystick *) 0 ;
12248 int result;
12249 PyObject * obj0 = 0 ;
12250 char *kwnames[] = {
12251 (char *) "self", NULL
12252 };
12253
12254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12256 if (SWIG_arg_fail(1)) SWIG_fail;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 result = (int)(arg1)->GetNumberAxes();
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 {
12265 resultobj = SWIG_From_int((int)(result));
12266 }
12267 return resultobj;
12268 fail:
12269 return NULL;
12270 }
12271
12272
12273 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12274 PyObject *resultobj;
12275 wxJoystick *arg1 = (wxJoystick *) 0 ;
12276 int result;
12277 PyObject * obj0 = 0 ;
12278 char *kwnames[] = {
12279 (char *) "self", NULL
12280 };
12281
12282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12284 if (SWIG_arg_fail(1)) SWIG_fail;
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (int)(arg1)->GetMaxButtons();
12288
12289 wxPyEndAllowThreads(__tstate);
12290 if (PyErr_Occurred()) SWIG_fail;
12291 }
12292 {
12293 resultobj = SWIG_From_int((int)(result));
12294 }
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj;
12303 wxJoystick *arg1 = (wxJoystick *) 0 ;
12304 int result;
12305 PyObject * obj0 = 0 ;
12306 char *kwnames[] = {
12307 (char *) "self", NULL
12308 };
12309
12310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12312 if (SWIG_arg_fail(1)) SWIG_fail;
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 result = (int)(arg1)->GetMaxAxes();
12316
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 {
12321 resultobj = SWIG_From_int((int)(result));
12322 }
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj;
12331 wxJoystick *arg1 = (wxJoystick *) 0 ;
12332 int result;
12333 PyObject * obj0 = 0 ;
12334 char *kwnames[] = {
12335 (char *) "self", NULL
12336 };
12337
12338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12340 if (SWIG_arg_fail(1)) SWIG_fail;
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 result = (int)(arg1)->GetPollingMin();
12344
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 {
12349 resultobj = SWIG_From_int((int)(result));
12350 }
12351 return resultobj;
12352 fail:
12353 return NULL;
12354 }
12355
12356
12357 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12358 PyObject *resultobj;
12359 wxJoystick *arg1 = (wxJoystick *) 0 ;
12360 int result;
12361 PyObject * obj0 = 0 ;
12362 char *kwnames[] = {
12363 (char *) "self", NULL
12364 };
12365
12366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12368 if (SWIG_arg_fail(1)) SWIG_fail;
12369 {
12370 PyThreadState* __tstate = wxPyBeginAllowThreads();
12371 result = (int)(arg1)->GetPollingMax();
12372
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 {
12377 resultobj = SWIG_From_int((int)(result));
12378 }
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj;
12387 wxJoystick *arg1 = (wxJoystick *) 0 ;
12388 int result;
12389 PyObject * obj0 = 0 ;
12390 char *kwnames[] = {
12391 (char *) "self", NULL
12392 };
12393
12394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12396 if (SWIG_arg_fail(1)) SWIG_fail;
12397 {
12398 PyThreadState* __tstate = wxPyBeginAllowThreads();
12399 result = (int)(arg1)->GetRudderMin();
12400
12401 wxPyEndAllowThreads(__tstate);
12402 if (PyErr_Occurred()) SWIG_fail;
12403 }
12404 {
12405 resultobj = SWIG_From_int((int)(result));
12406 }
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj;
12415 wxJoystick *arg1 = (wxJoystick *) 0 ;
12416 int result;
12417 PyObject * obj0 = 0 ;
12418 char *kwnames[] = {
12419 (char *) "self", NULL
12420 };
12421
12422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12424 if (SWIG_arg_fail(1)) SWIG_fail;
12425 {
12426 PyThreadState* __tstate = wxPyBeginAllowThreads();
12427 result = (int)(arg1)->GetRudderMax();
12428
12429 wxPyEndAllowThreads(__tstate);
12430 if (PyErr_Occurred()) SWIG_fail;
12431 }
12432 {
12433 resultobj = SWIG_From_int((int)(result));
12434 }
12435 return resultobj;
12436 fail:
12437 return NULL;
12438 }
12439
12440
12441 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12442 PyObject *resultobj;
12443 wxJoystick *arg1 = (wxJoystick *) 0 ;
12444 int result;
12445 PyObject * obj0 = 0 ;
12446 char *kwnames[] = {
12447 (char *) "self", NULL
12448 };
12449
12450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12452 if (SWIG_arg_fail(1)) SWIG_fail;
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 result = (int)(arg1)->GetUMin();
12456
12457 wxPyEndAllowThreads(__tstate);
12458 if (PyErr_Occurred()) SWIG_fail;
12459 }
12460 {
12461 resultobj = SWIG_From_int((int)(result));
12462 }
12463 return resultobj;
12464 fail:
12465 return NULL;
12466 }
12467
12468
12469 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12470 PyObject *resultobj;
12471 wxJoystick *arg1 = (wxJoystick *) 0 ;
12472 int result;
12473 PyObject * obj0 = 0 ;
12474 char *kwnames[] = {
12475 (char *) "self", NULL
12476 };
12477
12478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12480 if (SWIG_arg_fail(1)) SWIG_fail;
12481 {
12482 PyThreadState* __tstate = wxPyBeginAllowThreads();
12483 result = (int)(arg1)->GetUMax();
12484
12485 wxPyEndAllowThreads(__tstate);
12486 if (PyErr_Occurred()) SWIG_fail;
12487 }
12488 {
12489 resultobj = SWIG_From_int((int)(result));
12490 }
12491 return resultobj;
12492 fail:
12493 return NULL;
12494 }
12495
12496
12497 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12498 PyObject *resultobj;
12499 wxJoystick *arg1 = (wxJoystick *) 0 ;
12500 int result;
12501 PyObject * obj0 = 0 ;
12502 char *kwnames[] = {
12503 (char *) "self", NULL
12504 };
12505
12506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12508 if (SWIG_arg_fail(1)) SWIG_fail;
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 result = (int)(arg1)->GetVMin();
12512
12513 wxPyEndAllowThreads(__tstate);
12514 if (PyErr_Occurred()) SWIG_fail;
12515 }
12516 {
12517 resultobj = SWIG_From_int((int)(result));
12518 }
12519 return resultobj;
12520 fail:
12521 return NULL;
12522 }
12523
12524
12525 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12526 PyObject *resultobj;
12527 wxJoystick *arg1 = (wxJoystick *) 0 ;
12528 int result;
12529 PyObject * obj0 = 0 ;
12530 char *kwnames[] = {
12531 (char *) "self", NULL
12532 };
12533
12534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12536 if (SWIG_arg_fail(1)) SWIG_fail;
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 result = (int)(arg1)->GetVMax();
12540
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 {
12545 resultobj = SWIG_From_int((int)(result));
12546 }
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj;
12555 wxJoystick *arg1 = (wxJoystick *) 0 ;
12556 bool result;
12557 PyObject * obj0 = 0 ;
12558 char *kwnames[] = {
12559 (char *) "self", NULL
12560 };
12561
12562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12564 if (SWIG_arg_fail(1)) SWIG_fail;
12565 {
12566 PyThreadState* __tstate = wxPyBeginAllowThreads();
12567 result = (bool)(arg1)->HasRudder();
12568
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 {
12573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12574 }
12575 return resultobj;
12576 fail:
12577 return NULL;
12578 }
12579
12580
12581 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj;
12583 wxJoystick *arg1 = (wxJoystick *) 0 ;
12584 bool result;
12585 PyObject * obj0 = 0 ;
12586 char *kwnames[] = {
12587 (char *) "self", NULL
12588 };
12589
12590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12592 if (SWIG_arg_fail(1)) SWIG_fail;
12593 {
12594 PyThreadState* __tstate = wxPyBeginAllowThreads();
12595 result = (bool)(arg1)->HasZ();
12596
12597 wxPyEndAllowThreads(__tstate);
12598 if (PyErr_Occurred()) SWIG_fail;
12599 }
12600 {
12601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12602 }
12603 return resultobj;
12604 fail:
12605 return NULL;
12606 }
12607
12608
12609 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12610 PyObject *resultobj;
12611 wxJoystick *arg1 = (wxJoystick *) 0 ;
12612 bool result;
12613 PyObject * obj0 = 0 ;
12614 char *kwnames[] = {
12615 (char *) "self", NULL
12616 };
12617
12618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12620 if (SWIG_arg_fail(1)) SWIG_fail;
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 result = (bool)(arg1)->HasU();
12624
12625 wxPyEndAllowThreads(__tstate);
12626 if (PyErr_Occurred()) SWIG_fail;
12627 }
12628 {
12629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12630 }
12631 return resultobj;
12632 fail:
12633 return NULL;
12634 }
12635
12636
12637 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12638 PyObject *resultobj;
12639 wxJoystick *arg1 = (wxJoystick *) 0 ;
12640 bool result;
12641 PyObject * obj0 = 0 ;
12642 char *kwnames[] = {
12643 (char *) "self", NULL
12644 };
12645
12646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12648 if (SWIG_arg_fail(1)) SWIG_fail;
12649 {
12650 PyThreadState* __tstate = wxPyBeginAllowThreads();
12651 result = (bool)(arg1)->HasV();
12652
12653 wxPyEndAllowThreads(__tstate);
12654 if (PyErr_Occurred()) SWIG_fail;
12655 }
12656 {
12657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12658 }
12659 return resultobj;
12660 fail:
12661 return NULL;
12662 }
12663
12664
12665 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12666 PyObject *resultobj;
12667 wxJoystick *arg1 = (wxJoystick *) 0 ;
12668 bool result;
12669 PyObject * obj0 = 0 ;
12670 char *kwnames[] = {
12671 (char *) "self", NULL
12672 };
12673
12674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12676 if (SWIG_arg_fail(1)) SWIG_fail;
12677 {
12678 PyThreadState* __tstate = wxPyBeginAllowThreads();
12679 result = (bool)(arg1)->HasPOV();
12680
12681 wxPyEndAllowThreads(__tstate);
12682 if (PyErr_Occurred()) SWIG_fail;
12683 }
12684 {
12685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12686 }
12687 return resultobj;
12688 fail:
12689 return NULL;
12690 }
12691
12692
12693 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12694 PyObject *resultobj;
12695 wxJoystick *arg1 = (wxJoystick *) 0 ;
12696 bool result;
12697 PyObject * obj0 = 0 ;
12698 char *kwnames[] = {
12699 (char *) "self", NULL
12700 };
12701
12702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12704 if (SWIG_arg_fail(1)) SWIG_fail;
12705 {
12706 PyThreadState* __tstate = wxPyBeginAllowThreads();
12707 result = (bool)(arg1)->HasPOV4Dir();
12708
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 {
12713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12714 }
12715 return resultobj;
12716 fail:
12717 return NULL;
12718 }
12719
12720
12721 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12722 PyObject *resultobj;
12723 wxJoystick *arg1 = (wxJoystick *) 0 ;
12724 bool result;
12725 PyObject * obj0 = 0 ;
12726 char *kwnames[] = {
12727 (char *) "self", NULL
12728 };
12729
12730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12732 if (SWIG_arg_fail(1)) SWIG_fail;
12733 {
12734 PyThreadState* __tstate = wxPyBeginAllowThreads();
12735 result = (bool)(arg1)->HasPOVCTS();
12736
12737 wxPyEndAllowThreads(__tstate);
12738 if (PyErr_Occurred()) SWIG_fail;
12739 }
12740 {
12741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12742 }
12743 return resultobj;
12744 fail:
12745 return NULL;
12746 }
12747
12748
12749 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12750 PyObject *resultobj;
12751 wxJoystick *arg1 = (wxJoystick *) 0 ;
12752 wxWindow *arg2 = (wxWindow *) 0 ;
12753 int arg3 = (int) 0 ;
12754 bool result;
12755 PyObject * obj0 = 0 ;
12756 PyObject * obj1 = 0 ;
12757 PyObject * obj2 = 0 ;
12758 char *kwnames[] = {
12759 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12760 };
12761
12762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12764 if (SWIG_arg_fail(1)) SWIG_fail;
12765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12766 if (SWIG_arg_fail(2)) SWIG_fail;
12767 if (obj2) {
12768 {
12769 arg3 = (int)(SWIG_As_int(obj2));
12770 if (SWIG_arg_fail(3)) SWIG_fail;
12771 }
12772 }
12773 {
12774 PyThreadState* __tstate = wxPyBeginAllowThreads();
12775 result = (bool)(arg1)->SetCapture(arg2,arg3);
12776
12777 wxPyEndAllowThreads(__tstate);
12778 if (PyErr_Occurred()) SWIG_fail;
12779 }
12780 {
12781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12782 }
12783 return resultobj;
12784 fail:
12785 return NULL;
12786 }
12787
12788
12789 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12790 PyObject *resultobj;
12791 wxJoystick *arg1 = (wxJoystick *) 0 ;
12792 bool result;
12793 PyObject * obj0 = 0 ;
12794 char *kwnames[] = {
12795 (char *) "self", NULL
12796 };
12797
12798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12800 if (SWIG_arg_fail(1)) SWIG_fail;
12801 {
12802 PyThreadState* __tstate = wxPyBeginAllowThreads();
12803 result = (bool)(arg1)->ReleaseCapture();
12804
12805 wxPyEndAllowThreads(__tstate);
12806 if (PyErr_Occurred()) SWIG_fail;
12807 }
12808 {
12809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12810 }
12811 return resultobj;
12812 fail:
12813 return NULL;
12814 }
12815
12816
12817 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12818 PyObject *obj;
12819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12820 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12821 Py_INCREF(obj);
12822 return Py_BuildValue((char *)"");
12823 }
12824 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12825 PyObject *resultobj;
12826 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12827 int arg2 = (int) 0 ;
12828 int arg3 = (int) wxJOYSTICK1 ;
12829 int arg4 = (int) 0 ;
12830 wxJoystickEvent *result;
12831 PyObject * obj0 = 0 ;
12832 PyObject * obj1 = 0 ;
12833 PyObject * obj2 = 0 ;
12834 PyObject * obj3 = 0 ;
12835 char *kwnames[] = {
12836 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12837 };
12838
12839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12840 if (obj0) {
12841 {
12842 arg1 = (wxEventType)(SWIG_As_int(obj0));
12843 if (SWIG_arg_fail(1)) SWIG_fail;
12844 }
12845 }
12846 if (obj1) {
12847 {
12848 arg2 = (int)(SWIG_As_int(obj1));
12849 if (SWIG_arg_fail(2)) SWIG_fail;
12850 }
12851 }
12852 if (obj2) {
12853 {
12854 arg3 = (int)(SWIG_As_int(obj2));
12855 if (SWIG_arg_fail(3)) SWIG_fail;
12856 }
12857 }
12858 if (obj3) {
12859 {
12860 arg4 = (int)(SWIG_As_int(obj3));
12861 if (SWIG_arg_fail(4)) SWIG_fail;
12862 }
12863 }
12864 {
12865 PyThreadState* __tstate = wxPyBeginAllowThreads();
12866 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12867
12868 wxPyEndAllowThreads(__tstate);
12869 if (PyErr_Occurred()) SWIG_fail;
12870 }
12871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12872 return resultobj;
12873 fail:
12874 return NULL;
12875 }
12876
12877
12878 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12879 PyObject *resultobj;
12880 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12881 wxPoint result;
12882 PyObject * obj0 = 0 ;
12883 char *kwnames[] = {
12884 (char *) "self", NULL
12885 };
12886
12887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12889 if (SWIG_arg_fail(1)) SWIG_fail;
12890 {
12891 PyThreadState* __tstate = wxPyBeginAllowThreads();
12892 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12893
12894 wxPyEndAllowThreads(__tstate);
12895 if (PyErr_Occurred()) SWIG_fail;
12896 }
12897 {
12898 wxPoint * resultptr;
12899 resultptr = new wxPoint((wxPoint &)(result));
12900 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12901 }
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12909 PyObject *resultobj;
12910 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12911 int result;
12912 PyObject * obj0 = 0 ;
12913 char *kwnames[] = {
12914 (char *) "self", NULL
12915 };
12916
12917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12919 if (SWIG_arg_fail(1)) SWIG_fail;
12920 {
12921 PyThreadState* __tstate = wxPyBeginAllowThreads();
12922 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12923
12924 wxPyEndAllowThreads(__tstate);
12925 if (PyErr_Occurred()) SWIG_fail;
12926 }
12927 {
12928 resultobj = SWIG_From_int((int)(result));
12929 }
12930 return resultobj;
12931 fail:
12932 return NULL;
12933 }
12934
12935
12936 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12937 PyObject *resultobj;
12938 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12939 int result;
12940 PyObject * obj0 = 0 ;
12941 char *kwnames[] = {
12942 (char *) "self", NULL
12943 };
12944
12945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12947 if (SWIG_arg_fail(1)) SWIG_fail;
12948 {
12949 PyThreadState* __tstate = wxPyBeginAllowThreads();
12950 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12951
12952 wxPyEndAllowThreads(__tstate);
12953 if (PyErr_Occurred()) SWIG_fail;
12954 }
12955 {
12956 resultobj = SWIG_From_int((int)(result));
12957 }
12958 return resultobj;
12959 fail:
12960 return NULL;
12961 }
12962
12963
12964 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12965 PyObject *resultobj;
12966 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12967 int result;
12968 PyObject * obj0 = 0 ;
12969 char *kwnames[] = {
12970 (char *) "self", NULL
12971 };
12972
12973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12975 if (SWIG_arg_fail(1)) SWIG_fail;
12976 {
12977 PyThreadState* __tstate = wxPyBeginAllowThreads();
12978 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12979
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 {
12984 resultobj = SWIG_From_int((int)(result));
12985 }
12986 return resultobj;
12987 fail:
12988 return NULL;
12989 }
12990
12991
12992 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12993 PyObject *resultobj;
12994 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12995 int result;
12996 PyObject * obj0 = 0 ;
12997 char *kwnames[] = {
12998 (char *) "self", NULL
12999 };
13000
13001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13003 if (SWIG_arg_fail(1)) SWIG_fail;
13004 {
13005 PyThreadState* __tstate = wxPyBeginAllowThreads();
13006 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13007
13008 wxPyEndAllowThreads(__tstate);
13009 if (PyErr_Occurred()) SWIG_fail;
13010 }
13011 {
13012 resultobj = SWIG_From_int((int)(result));
13013 }
13014 return resultobj;
13015 fail:
13016 return NULL;
13017 }
13018
13019
13020 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13021 PyObject *resultobj;
13022 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13023 int arg2 ;
13024 PyObject * obj0 = 0 ;
13025 PyObject * obj1 = 0 ;
13026 char *kwnames[] = {
13027 (char *) "self",(char *) "stick", NULL
13028 };
13029
13030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13032 if (SWIG_arg_fail(1)) SWIG_fail;
13033 {
13034 arg2 = (int)(SWIG_As_int(obj1));
13035 if (SWIG_arg_fail(2)) SWIG_fail;
13036 }
13037 {
13038 PyThreadState* __tstate = wxPyBeginAllowThreads();
13039 (arg1)->SetJoystick(arg2);
13040
13041 wxPyEndAllowThreads(__tstate);
13042 if (PyErr_Occurred()) SWIG_fail;
13043 }
13044 Py_INCREF(Py_None); resultobj = Py_None;
13045 return resultobj;
13046 fail:
13047 return NULL;
13048 }
13049
13050
13051 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj;
13053 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13054 int arg2 ;
13055 PyObject * obj0 = 0 ;
13056 PyObject * obj1 = 0 ;
13057 char *kwnames[] = {
13058 (char *) "self",(char *) "state", NULL
13059 };
13060
13061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13063 if (SWIG_arg_fail(1)) SWIG_fail;
13064 {
13065 arg2 = (int)(SWIG_As_int(obj1));
13066 if (SWIG_arg_fail(2)) SWIG_fail;
13067 }
13068 {
13069 PyThreadState* __tstate = wxPyBeginAllowThreads();
13070 (arg1)->SetButtonState(arg2);
13071
13072 wxPyEndAllowThreads(__tstate);
13073 if (PyErr_Occurred()) SWIG_fail;
13074 }
13075 Py_INCREF(Py_None); resultobj = Py_None;
13076 return resultobj;
13077 fail:
13078 return NULL;
13079 }
13080
13081
13082 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13083 PyObject *resultobj;
13084 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13085 int arg2 ;
13086 PyObject * obj0 = 0 ;
13087 PyObject * obj1 = 0 ;
13088 char *kwnames[] = {
13089 (char *) "self",(char *) "change", NULL
13090 };
13091
13092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13094 if (SWIG_arg_fail(1)) SWIG_fail;
13095 {
13096 arg2 = (int)(SWIG_As_int(obj1));
13097 if (SWIG_arg_fail(2)) SWIG_fail;
13098 }
13099 {
13100 PyThreadState* __tstate = wxPyBeginAllowThreads();
13101 (arg1)->SetButtonChange(arg2);
13102
13103 wxPyEndAllowThreads(__tstate);
13104 if (PyErr_Occurred()) SWIG_fail;
13105 }
13106 Py_INCREF(Py_None); resultobj = Py_None;
13107 return resultobj;
13108 fail:
13109 return NULL;
13110 }
13111
13112
13113 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13114 PyObject *resultobj;
13115 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13116 wxPoint *arg2 = 0 ;
13117 wxPoint temp2 ;
13118 PyObject * obj0 = 0 ;
13119 PyObject * obj1 = 0 ;
13120 char *kwnames[] = {
13121 (char *) "self",(char *) "pos", NULL
13122 };
13123
13124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13126 if (SWIG_arg_fail(1)) SWIG_fail;
13127 {
13128 arg2 = &temp2;
13129 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13130 }
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 (arg1)->SetPosition((wxPoint const &)*arg2);
13134
13135 wxPyEndAllowThreads(__tstate);
13136 if (PyErr_Occurred()) SWIG_fail;
13137 }
13138 Py_INCREF(Py_None); resultobj = Py_None;
13139 return resultobj;
13140 fail:
13141 return NULL;
13142 }
13143
13144
13145 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13146 PyObject *resultobj;
13147 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13148 int arg2 ;
13149 PyObject * obj0 = 0 ;
13150 PyObject * obj1 = 0 ;
13151 char *kwnames[] = {
13152 (char *) "self",(char *) "zPos", NULL
13153 };
13154
13155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13157 if (SWIG_arg_fail(1)) SWIG_fail;
13158 {
13159 arg2 = (int)(SWIG_As_int(obj1));
13160 if (SWIG_arg_fail(2)) SWIG_fail;
13161 }
13162 {
13163 PyThreadState* __tstate = wxPyBeginAllowThreads();
13164 (arg1)->SetZPosition(arg2);
13165
13166 wxPyEndAllowThreads(__tstate);
13167 if (PyErr_Occurred()) SWIG_fail;
13168 }
13169 Py_INCREF(Py_None); resultobj = Py_None;
13170 return resultobj;
13171 fail:
13172 return NULL;
13173 }
13174
13175
13176 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj;
13178 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13179 bool result;
13180 PyObject * obj0 = 0 ;
13181 char *kwnames[] = {
13182 (char *) "self", NULL
13183 };
13184
13185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13187 if (SWIG_arg_fail(1)) SWIG_fail;
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13191
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 {
13196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13197 }
13198 return resultobj;
13199 fail:
13200 return NULL;
13201 }
13202
13203
13204 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13205 PyObject *resultobj;
13206 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13207 bool result;
13208 PyObject * obj0 = 0 ;
13209 char *kwnames[] = {
13210 (char *) "self", NULL
13211 };
13212
13213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13215 if (SWIG_arg_fail(1)) SWIG_fail;
13216 {
13217 PyThreadState* __tstate = wxPyBeginAllowThreads();
13218 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13219
13220 wxPyEndAllowThreads(__tstate);
13221 if (PyErr_Occurred()) SWIG_fail;
13222 }
13223 {
13224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13225 }
13226 return resultobj;
13227 fail:
13228 return NULL;
13229 }
13230
13231
13232 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13233 PyObject *resultobj;
13234 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13235 bool result;
13236 PyObject * obj0 = 0 ;
13237 char *kwnames[] = {
13238 (char *) "self", NULL
13239 };
13240
13241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13243 if (SWIG_arg_fail(1)) SWIG_fail;
13244 {
13245 PyThreadState* __tstate = wxPyBeginAllowThreads();
13246 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13247
13248 wxPyEndAllowThreads(__tstate);
13249 if (PyErr_Occurred()) SWIG_fail;
13250 }
13251 {
13252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13253 }
13254 return resultobj;
13255 fail:
13256 return NULL;
13257 }
13258
13259
13260 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13261 PyObject *resultobj;
13262 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13263 int arg2 = (int) wxJOY_BUTTON_ANY ;
13264 bool result;
13265 PyObject * obj0 = 0 ;
13266 PyObject * obj1 = 0 ;
13267 char *kwnames[] = {
13268 (char *) "self",(char *) "but", NULL
13269 };
13270
13271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13273 if (SWIG_arg_fail(1)) SWIG_fail;
13274 if (obj1) {
13275 {
13276 arg2 = (int)(SWIG_As_int(obj1));
13277 if (SWIG_arg_fail(2)) SWIG_fail;
13278 }
13279 }
13280 {
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13283
13284 wxPyEndAllowThreads(__tstate);
13285 if (PyErr_Occurred()) SWIG_fail;
13286 }
13287 {
13288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13289 }
13290 return resultobj;
13291 fail:
13292 return NULL;
13293 }
13294
13295
13296 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13297 PyObject *resultobj;
13298 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13299 int arg2 = (int) wxJOY_BUTTON_ANY ;
13300 bool result;
13301 PyObject * obj0 = 0 ;
13302 PyObject * obj1 = 0 ;
13303 char *kwnames[] = {
13304 (char *) "self",(char *) "but", NULL
13305 };
13306
13307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13309 if (SWIG_arg_fail(1)) SWIG_fail;
13310 if (obj1) {
13311 {
13312 arg2 = (int)(SWIG_As_int(obj1));
13313 if (SWIG_arg_fail(2)) SWIG_fail;
13314 }
13315 }
13316 {
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13319
13320 wxPyEndAllowThreads(__tstate);
13321 if (PyErr_Occurred()) SWIG_fail;
13322 }
13323 {
13324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13325 }
13326 return resultobj;
13327 fail:
13328 return NULL;
13329 }
13330
13331
13332 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13333 PyObject *resultobj;
13334 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13335 int arg2 = (int) wxJOY_BUTTON_ANY ;
13336 bool result;
13337 PyObject * obj0 = 0 ;
13338 PyObject * obj1 = 0 ;
13339 char *kwnames[] = {
13340 (char *) "self",(char *) "but", NULL
13341 };
13342
13343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13345 if (SWIG_arg_fail(1)) SWIG_fail;
13346 if (obj1) {
13347 {
13348 arg2 = (int)(SWIG_As_int(obj1));
13349 if (SWIG_arg_fail(2)) SWIG_fail;
13350 }
13351 }
13352 {
13353 PyThreadState* __tstate = wxPyBeginAllowThreads();
13354 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13355
13356 wxPyEndAllowThreads(__tstate);
13357 if (PyErr_Occurred()) SWIG_fail;
13358 }
13359 {
13360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13361 }
13362 return resultobj;
13363 fail:
13364 return NULL;
13365 }
13366
13367
13368 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13369 PyObject *obj;
13370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13371 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13372 Py_INCREF(obj);
13373 return Py_BuildValue((char *)"");
13374 }
13375 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj;
13377 wxString const &arg1_defvalue = wxPyEmptyString ;
13378 wxString *arg1 = (wxString *) &arg1_defvalue ;
13379 wxSound *result;
13380 bool temp1 = false ;
13381 PyObject * obj0 = 0 ;
13382 char *kwnames[] = {
13383 (char *) "fileName", NULL
13384 };
13385
13386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13387 if (obj0) {
13388 {
13389 arg1 = wxString_in_helper(obj0);
13390 if (arg1 == NULL) SWIG_fail;
13391 temp1 = true;
13392 }
13393 }
13394 {
13395 if (!wxPyCheckForApp()) SWIG_fail;
13396 PyThreadState* __tstate = wxPyBeginAllowThreads();
13397 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13398
13399 wxPyEndAllowThreads(__tstate);
13400 if (PyErr_Occurred()) SWIG_fail;
13401 }
13402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13403 {
13404 if (temp1)
13405 delete arg1;
13406 }
13407 return resultobj;
13408 fail:
13409 {
13410 if (temp1)
13411 delete arg1;
13412 }
13413 return NULL;
13414 }
13415
13416
13417 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13418 PyObject *resultobj;
13419 PyObject *arg1 = (PyObject *) 0 ;
13420 wxSound *result;
13421 PyObject * obj0 = 0 ;
13422 char *kwnames[] = {
13423 (char *) "data", NULL
13424 };
13425
13426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13427 arg1 = obj0;
13428 {
13429 if (!wxPyCheckForApp()) SWIG_fail;
13430 PyThreadState* __tstate = wxPyBeginAllowThreads();
13431 result = (wxSound *)new_wxSound(arg1);
13432
13433 wxPyEndAllowThreads(__tstate);
13434 if (PyErr_Occurred()) SWIG_fail;
13435 }
13436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13437 return resultobj;
13438 fail:
13439 return NULL;
13440 }
13441
13442
13443 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13444 PyObject *resultobj;
13445 wxSound *arg1 = (wxSound *) 0 ;
13446 PyObject * obj0 = 0 ;
13447 char *kwnames[] = {
13448 (char *) "self", NULL
13449 };
13450
13451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13453 if (SWIG_arg_fail(1)) SWIG_fail;
13454 {
13455 PyThreadState* __tstate = wxPyBeginAllowThreads();
13456 delete arg1;
13457
13458 wxPyEndAllowThreads(__tstate);
13459 if (PyErr_Occurred()) SWIG_fail;
13460 }
13461 Py_INCREF(Py_None); resultobj = Py_None;
13462 return resultobj;
13463 fail:
13464 return NULL;
13465 }
13466
13467
13468 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13469 PyObject *resultobj;
13470 wxSound *arg1 = (wxSound *) 0 ;
13471 wxString *arg2 = 0 ;
13472 bool result;
13473 bool temp2 = false ;
13474 PyObject * obj0 = 0 ;
13475 PyObject * obj1 = 0 ;
13476 char *kwnames[] = {
13477 (char *) "self",(char *) "fileName", NULL
13478 };
13479
13480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13482 if (SWIG_arg_fail(1)) SWIG_fail;
13483 {
13484 arg2 = wxString_in_helper(obj1);
13485 if (arg2 == NULL) SWIG_fail;
13486 temp2 = true;
13487 }
13488 {
13489 PyThreadState* __tstate = wxPyBeginAllowThreads();
13490 result = (bool)(arg1)->Create((wxString const &)*arg2);
13491
13492 wxPyEndAllowThreads(__tstate);
13493 if (PyErr_Occurred()) SWIG_fail;
13494 }
13495 {
13496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13497 }
13498 {
13499 if (temp2)
13500 delete arg2;
13501 }
13502 return resultobj;
13503 fail:
13504 {
13505 if (temp2)
13506 delete arg2;
13507 }
13508 return NULL;
13509 }
13510
13511
13512 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13513 PyObject *resultobj;
13514 wxSound *arg1 = (wxSound *) 0 ;
13515 PyObject *arg2 = (PyObject *) 0 ;
13516 bool result;
13517 PyObject * obj0 = 0 ;
13518 PyObject * obj1 = 0 ;
13519 char *kwnames[] = {
13520 (char *) "self",(char *) "data", NULL
13521 };
13522
13523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13525 if (SWIG_arg_fail(1)) SWIG_fail;
13526 arg2 = obj1;
13527 {
13528 PyThreadState* __tstate = wxPyBeginAllowThreads();
13529 result = (bool)wxSound_CreateFromData(arg1,arg2);
13530
13531 wxPyEndAllowThreads(__tstate);
13532 if (PyErr_Occurred()) SWIG_fail;
13533 }
13534 {
13535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13536 }
13537 return resultobj;
13538 fail:
13539 return NULL;
13540 }
13541
13542
13543 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13544 PyObject *resultobj;
13545 wxSound *arg1 = (wxSound *) 0 ;
13546 bool result;
13547 PyObject * obj0 = 0 ;
13548 char *kwnames[] = {
13549 (char *) "self", NULL
13550 };
13551
13552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13554 if (SWIG_arg_fail(1)) SWIG_fail;
13555 {
13556 PyThreadState* __tstate = wxPyBeginAllowThreads();
13557 result = (bool)(arg1)->IsOk();
13558
13559 wxPyEndAllowThreads(__tstate);
13560 if (PyErr_Occurred()) SWIG_fail;
13561 }
13562 {
13563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13564 }
13565 return resultobj;
13566 fail:
13567 return NULL;
13568 }
13569
13570
13571 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13572 PyObject *resultobj;
13573 wxSound *arg1 = (wxSound *) 0 ;
13574 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13575 bool result;
13576 PyObject * obj0 = 0 ;
13577 PyObject * obj1 = 0 ;
13578 char *kwnames[] = {
13579 (char *) "self",(char *) "flags", NULL
13580 };
13581
13582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13584 if (SWIG_arg_fail(1)) SWIG_fail;
13585 if (obj1) {
13586 {
13587 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13588 if (SWIG_arg_fail(2)) SWIG_fail;
13589 }
13590 }
13591 {
13592 if (!wxPyCheckForApp()) SWIG_fail;
13593 PyThreadState* __tstate = wxPyBeginAllowThreads();
13594 result = (bool)((wxSound const *)arg1)->Play(arg2);
13595
13596 wxPyEndAllowThreads(__tstate);
13597 if (PyErr_Occurred()) SWIG_fail;
13598 }
13599 {
13600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13601 }
13602 return resultobj;
13603 fail:
13604 return NULL;
13605 }
13606
13607
13608 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13609 PyObject *resultobj;
13610 wxString *arg1 = 0 ;
13611 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13612 bool result;
13613 bool temp1 = false ;
13614 PyObject * obj0 = 0 ;
13615 PyObject * obj1 = 0 ;
13616 char *kwnames[] = {
13617 (char *) "filename",(char *) "flags", NULL
13618 };
13619
13620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13621 {
13622 arg1 = wxString_in_helper(obj0);
13623 if (arg1 == NULL) SWIG_fail;
13624 temp1 = true;
13625 }
13626 if (obj1) {
13627 {
13628 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13629 if (SWIG_arg_fail(2)) SWIG_fail;
13630 }
13631 }
13632 {
13633 if (!wxPyCheckForApp()) SWIG_fail;
13634 PyThreadState* __tstate = wxPyBeginAllowThreads();
13635 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13636
13637 wxPyEndAllowThreads(__tstate);
13638 if (PyErr_Occurred()) SWIG_fail;
13639 }
13640 {
13641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13642 }
13643 {
13644 if (temp1)
13645 delete arg1;
13646 }
13647 return resultobj;
13648 fail:
13649 {
13650 if (temp1)
13651 delete arg1;
13652 }
13653 return NULL;
13654 }
13655
13656
13657 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13658 PyObject *resultobj;
13659 char *kwnames[] = {
13660 NULL
13661 };
13662
13663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13664 {
13665 if (!wxPyCheckForApp()) SWIG_fail;
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 wxSound::Stop();
13668
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 Py_INCREF(Py_None); resultobj = Py_None;
13673 return resultobj;
13674 fail:
13675 return NULL;
13676 }
13677
13678
13679 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13680 PyObject *obj;
13681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13682 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13683 Py_INCREF(obj);
13684 return Py_BuildValue((char *)"");
13685 }
13686 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13687 PyObject *resultobj;
13688 wxString *arg1 = 0 ;
13689 wxString *arg2 = 0 ;
13690 wxString *arg3 = 0 ;
13691 wxString *arg4 = 0 ;
13692 wxFileTypeInfo *result;
13693 bool temp1 = false ;
13694 bool temp2 = false ;
13695 bool temp3 = false ;
13696 bool temp4 = false ;
13697 PyObject * obj0 = 0 ;
13698 PyObject * obj1 = 0 ;
13699 PyObject * obj2 = 0 ;
13700 PyObject * obj3 = 0 ;
13701 char *kwnames[] = {
13702 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13703 };
13704
13705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13706 {
13707 arg1 = wxString_in_helper(obj0);
13708 if (arg1 == NULL) SWIG_fail;
13709 temp1 = true;
13710 }
13711 {
13712 arg2 = wxString_in_helper(obj1);
13713 if (arg2 == NULL) SWIG_fail;
13714 temp2 = true;
13715 }
13716 {
13717 arg3 = wxString_in_helper(obj2);
13718 if (arg3 == NULL) SWIG_fail;
13719 temp3 = true;
13720 }
13721 {
13722 arg4 = wxString_in_helper(obj3);
13723 if (arg4 == NULL) SWIG_fail;
13724 temp4 = true;
13725 }
13726 {
13727 PyThreadState* __tstate = wxPyBeginAllowThreads();
13728 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13729
13730 wxPyEndAllowThreads(__tstate);
13731 if (PyErr_Occurred()) SWIG_fail;
13732 }
13733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13734 {
13735 if (temp1)
13736 delete arg1;
13737 }
13738 {
13739 if (temp2)
13740 delete arg2;
13741 }
13742 {
13743 if (temp3)
13744 delete arg3;
13745 }
13746 {
13747 if (temp4)
13748 delete arg4;
13749 }
13750 return resultobj;
13751 fail:
13752 {
13753 if (temp1)
13754 delete arg1;
13755 }
13756 {
13757 if (temp2)
13758 delete arg2;
13759 }
13760 {
13761 if (temp3)
13762 delete arg3;
13763 }
13764 {
13765 if (temp4)
13766 delete arg4;
13767 }
13768 return NULL;
13769 }
13770
13771
13772 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13773 PyObject *resultobj;
13774 wxArrayString *arg1 = 0 ;
13775 wxFileTypeInfo *result;
13776 bool temp1 = false ;
13777 PyObject * obj0 = 0 ;
13778 char *kwnames[] = {
13779 (char *) "sArray", NULL
13780 };
13781
13782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13783 {
13784 if (! PySequence_Check(obj0)) {
13785 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13786 SWIG_fail;
13787 }
13788 arg1 = new wxArrayString;
13789 temp1 = true;
13790 int i, len=PySequence_Length(obj0);
13791 for (i=0; i<len; i++) {
13792 PyObject* item = PySequence_GetItem(obj0, i);
13793 #if wxUSE_UNICODE
13794 PyObject* str = PyObject_Unicode(item);
13795 #else
13796 PyObject* str = PyObject_Str(item);
13797 #endif
13798 if (PyErr_Occurred()) SWIG_fail;
13799 arg1->Add(Py2wxString(str));
13800 Py_DECREF(item);
13801 Py_DECREF(str);
13802 }
13803 }
13804 {
13805 PyThreadState* __tstate = wxPyBeginAllowThreads();
13806 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13807
13808 wxPyEndAllowThreads(__tstate);
13809 if (PyErr_Occurred()) SWIG_fail;
13810 }
13811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13812 {
13813 if (temp1) delete arg1;
13814 }
13815 return resultobj;
13816 fail:
13817 {
13818 if (temp1) delete arg1;
13819 }
13820 return NULL;
13821 }
13822
13823
13824 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13825 PyObject *resultobj;
13826 wxFileTypeInfo *result;
13827 char *kwnames[] = {
13828 NULL
13829 };
13830
13831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13832 {
13833 PyThreadState* __tstate = wxPyBeginAllowThreads();
13834 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13835
13836 wxPyEndAllowThreads(__tstate);
13837 if (PyErr_Occurred()) SWIG_fail;
13838 }
13839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13840 return resultobj;
13841 fail:
13842 return NULL;
13843 }
13844
13845
13846 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13847 PyObject *resultobj;
13848 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13849 bool result;
13850 PyObject * obj0 = 0 ;
13851 char *kwnames[] = {
13852 (char *) "self", NULL
13853 };
13854
13855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13857 if (SWIG_arg_fail(1)) SWIG_fail;
13858 {
13859 PyThreadState* __tstate = wxPyBeginAllowThreads();
13860 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13861
13862 wxPyEndAllowThreads(__tstate);
13863 if (PyErr_Occurred()) SWIG_fail;
13864 }
13865 {
13866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13867 }
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj;
13876 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13877 wxString *arg2 = 0 ;
13878 int arg3 = (int) 0 ;
13879 bool temp2 = false ;
13880 PyObject * obj0 = 0 ;
13881 PyObject * obj1 = 0 ;
13882 PyObject * obj2 = 0 ;
13883 char *kwnames[] = {
13884 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13885 };
13886
13887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13889 if (SWIG_arg_fail(1)) SWIG_fail;
13890 {
13891 arg2 = wxString_in_helper(obj1);
13892 if (arg2 == NULL) SWIG_fail;
13893 temp2 = true;
13894 }
13895 if (obj2) {
13896 {
13897 arg3 = (int)(SWIG_As_int(obj2));
13898 if (SWIG_arg_fail(3)) SWIG_fail;
13899 }
13900 }
13901 {
13902 PyThreadState* __tstate = wxPyBeginAllowThreads();
13903 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13904
13905 wxPyEndAllowThreads(__tstate);
13906 if (PyErr_Occurred()) SWIG_fail;
13907 }
13908 Py_INCREF(Py_None); resultobj = Py_None;
13909 {
13910 if (temp2)
13911 delete arg2;
13912 }
13913 return resultobj;
13914 fail:
13915 {
13916 if (temp2)
13917 delete arg2;
13918 }
13919 return NULL;
13920 }
13921
13922
13923 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13924 PyObject *resultobj;
13925 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13926 wxString *arg2 = 0 ;
13927 bool temp2 = false ;
13928 PyObject * obj0 = 0 ;
13929 PyObject * obj1 = 0 ;
13930 char *kwnames[] = {
13931 (char *) "self",(char *) "shortDesc", NULL
13932 };
13933
13934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13936 if (SWIG_arg_fail(1)) SWIG_fail;
13937 {
13938 arg2 = wxString_in_helper(obj1);
13939 if (arg2 == NULL) SWIG_fail;
13940 temp2 = true;
13941 }
13942 {
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 (arg1)->SetShortDesc((wxString const &)*arg2);
13945
13946 wxPyEndAllowThreads(__tstate);
13947 if (PyErr_Occurred()) SWIG_fail;
13948 }
13949 Py_INCREF(Py_None); resultobj = Py_None;
13950 {
13951 if (temp2)
13952 delete arg2;
13953 }
13954 return resultobj;
13955 fail:
13956 {
13957 if (temp2)
13958 delete arg2;
13959 }
13960 return NULL;
13961 }
13962
13963
13964 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13965 PyObject *resultobj;
13966 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13967 wxString *result;
13968 PyObject * obj0 = 0 ;
13969 char *kwnames[] = {
13970 (char *) "self", NULL
13971 };
13972
13973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13975 if (SWIG_arg_fail(1)) SWIG_fail;
13976 {
13977 PyThreadState* __tstate = wxPyBeginAllowThreads();
13978 {
13979 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13980 result = (wxString *) &_result_ref;
13981 }
13982
13983 wxPyEndAllowThreads(__tstate);
13984 if (PyErr_Occurred()) SWIG_fail;
13985 }
13986 {
13987 #if wxUSE_UNICODE
13988 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13989 #else
13990 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13991 #endif
13992 }
13993 return resultobj;
13994 fail:
13995 return NULL;
13996 }
13997
13998
13999 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14000 PyObject *resultobj;
14001 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14002 wxString *result;
14003 PyObject * obj0 = 0 ;
14004 char *kwnames[] = {
14005 (char *) "self", NULL
14006 };
14007
14008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14010 if (SWIG_arg_fail(1)) SWIG_fail;
14011 {
14012 PyThreadState* __tstate = wxPyBeginAllowThreads();
14013 {
14014 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14015 result = (wxString *) &_result_ref;
14016 }
14017
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 {
14022 #if wxUSE_UNICODE
14023 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14024 #else
14025 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14026 #endif
14027 }
14028 return resultobj;
14029 fail:
14030 return NULL;
14031 }
14032
14033
14034 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14035 PyObject *resultobj;
14036 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14037 wxString *result;
14038 PyObject * obj0 = 0 ;
14039 char *kwnames[] = {
14040 (char *) "self", NULL
14041 };
14042
14043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14045 if (SWIG_arg_fail(1)) SWIG_fail;
14046 {
14047 PyThreadState* __tstate = wxPyBeginAllowThreads();
14048 {
14049 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14050 result = (wxString *) &_result_ref;
14051 }
14052
14053 wxPyEndAllowThreads(__tstate);
14054 if (PyErr_Occurred()) SWIG_fail;
14055 }
14056 {
14057 #if wxUSE_UNICODE
14058 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14059 #else
14060 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14061 #endif
14062 }
14063 return resultobj;
14064 fail:
14065 return NULL;
14066 }
14067
14068
14069 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14070 PyObject *resultobj;
14071 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14072 wxString *result;
14073 PyObject * obj0 = 0 ;
14074 char *kwnames[] = {
14075 (char *) "self", NULL
14076 };
14077
14078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14080 if (SWIG_arg_fail(1)) SWIG_fail;
14081 {
14082 PyThreadState* __tstate = wxPyBeginAllowThreads();
14083 {
14084 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14085 result = (wxString *) &_result_ref;
14086 }
14087
14088 wxPyEndAllowThreads(__tstate);
14089 if (PyErr_Occurred()) SWIG_fail;
14090 }
14091 {
14092 #if wxUSE_UNICODE
14093 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14094 #else
14095 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14096 #endif
14097 }
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14105 PyObject *resultobj;
14106 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14107 wxString *result;
14108 PyObject * obj0 = 0 ;
14109 char *kwnames[] = {
14110 (char *) "self", NULL
14111 };
14112
14113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14115 if (SWIG_arg_fail(1)) SWIG_fail;
14116 {
14117 PyThreadState* __tstate = wxPyBeginAllowThreads();
14118 {
14119 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14120 result = (wxString *) &_result_ref;
14121 }
14122
14123 wxPyEndAllowThreads(__tstate);
14124 if (PyErr_Occurred()) SWIG_fail;
14125 }
14126 {
14127 #if wxUSE_UNICODE
14128 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14129 #else
14130 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14131 #endif
14132 }
14133 return resultobj;
14134 fail:
14135 return NULL;
14136 }
14137
14138
14139 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14140 PyObject *resultobj;
14141 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14142 wxArrayString *result;
14143 PyObject * obj0 = 0 ;
14144 char *kwnames[] = {
14145 (char *) "self", NULL
14146 };
14147
14148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14150 if (SWIG_arg_fail(1)) SWIG_fail;
14151 {
14152 PyThreadState* __tstate = wxPyBeginAllowThreads();
14153 {
14154 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14155 result = (wxArrayString *) &_result_ref;
14156 }
14157
14158 wxPyEndAllowThreads(__tstate);
14159 if (PyErr_Occurred()) SWIG_fail;
14160 }
14161 {
14162 resultobj = wxArrayString2PyList_helper(*result);
14163 }
14164 return resultobj;
14165 fail:
14166 return NULL;
14167 }
14168
14169
14170 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14171 PyObject *resultobj;
14172 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14173 int result;
14174 PyObject * obj0 = 0 ;
14175 char *kwnames[] = {
14176 (char *) "self", NULL
14177 };
14178
14179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14181 if (SWIG_arg_fail(1)) SWIG_fail;
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14185
14186 wxPyEndAllowThreads(__tstate);
14187 if (PyErr_Occurred()) SWIG_fail;
14188 }
14189 {
14190 resultobj = SWIG_From_int((int)(result));
14191 }
14192 return resultobj;
14193 fail:
14194 return NULL;
14195 }
14196
14197
14198 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14199 PyObject *resultobj;
14200 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14201 wxString *result;
14202 PyObject * obj0 = 0 ;
14203 char *kwnames[] = {
14204 (char *) "self", NULL
14205 };
14206
14207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14209 if (SWIG_arg_fail(1)) SWIG_fail;
14210 {
14211 PyThreadState* __tstate = wxPyBeginAllowThreads();
14212 {
14213 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14214 result = (wxString *) &_result_ref;
14215 }
14216
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 {
14221 #if wxUSE_UNICODE
14222 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14223 #else
14224 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14225 #endif
14226 }
14227 return resultobj;
14228 fail:
14229 return NULL;
14230 }
14231
14232
14233 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14234 PyObject *resultobj;
14235 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14236 int result;
14237 PyObject * obj0 = 0 ;
14238 char *kwnames[] = {
14239 (char *) "self", NULL
14240 };
14241
14242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14244 if (SWIG_arg_fail(1)) SWIG_fail;
14245 {
14246 PyThreadState* __tstate = wxPyBeginAllowThreads();
14247 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14248
14249 wxPyEndAllowThreads(__tstate);
14250 if (PyErr_Occurred()) SWIG_fail;
14251 }
14252 {
14253 resultobj = SWIG_From_int((int)(result));
14254 }
14255 return resultobj;
14256 fail:
14257 return NULL;
14258 }
14259
14260
14261 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14262 PyObject *obj;
14263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14264 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14265 Py_INCREF(obj);
14266 return Py_BuildValue((char *)"");
14267 }
14268 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14269 PyObject *resultobj;
14270 wxFileTypeInfo *arg1 = 0 ;
14271 wxFileType *result;
14272 PyObject * obj0 = 0 ;
14273 char *kwnames[] = {
14274 (char *) "ftInfo", NULL
14275 };
14276
14277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14278 {
14279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14280 if (SWIG_arg_fail(1)) SWIG_fail;
14281 if (arg1 == NULL) {
14282 SWIG_null_ref("wxFileTypeInfo");
14283 }
14284 if (SWIG_arg_fail(1)) SWIG_fail;
14285 }
14286 {
14287 PyThreadState* __tstate = wxPyBeginAllowThreads();
14288 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14289
14290 wxPyEndAllowThreads(__tstate);
14291 if (PyErr_Occurred()) SWIG_fail;
14292 }
14293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14294 return resultobj;
14295 fail:
14296 return NULL;
14297 }
14298
14299
14300 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14301 PyObject *resultobj;
14302 wxFileType *arg1 = (wxFileType *) 0 ;
14303 PyObject * obj0 = 0 ;
14304 char *kwnames[] = {
14305 (char *) "self", NULL
14306 };
14307
14308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14310 if (SWIG_arg_fail(1)) SWIG_fail;
14311 {
14312 PyThreadState* __tstate = wxPyBeginAllowThreads();
14313 delete arg1;
14314
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 Py_INCREF(Py_None); resultobj = Py_None;
14319 return resultobj;
14320 fail:
14321 return NULL;
14322 }
14323
14324
14325 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14326 PyObject *resultobj;
14327 wxFileType *arg1 = (wxFileType *) 0 ;
14328 PyObject *result;
14329 PyObject * obj0 = 0 ;
14330 char *kwnames[] = {
14331 (char *) "self", NULL
14332 };
14333
14334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14336 if (SWIG_arg_fail(1)) SWIG_fail;
14337 {
14338 PyThreadState* __tstate = wxPyBeginAllowThreads();
14339 result = (PyObject *)wxFileType_GetMimeType(arg1);
14340
14341 wxPyEndAllowThreads(__tstate);
14342 if (PyErr_Occurred()) SWIG_fail;
14343 }
14344 resultobj = result;
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14352 PyObject *resultobj;
14353 wxFileType *arg1 = (wxFileType *) 0 ;
14354 PyObject *result;
14355 PyObject * obj0 = 0 ;
14356 char *kwnames[] = {
14357 (char *) "self", NULL
14358 };
14359
14360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14362 if (SWIG_arg_fail(1)) SWIG_fail;
14363 {
14364 PyThreadState* __tstate = wxPyBeginAllowThreads();
14365 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14366
14367 wxPyEndAllowThreads(__tstate);
14368 if (PyErr_Occurred()) SWIG_fail;
14369 }
14370 resultobj = result;
14371 return resultobj;
14372 fail:
14373 return NULL;
14374 }
14375
14376
14377 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14378 PyObject *resultobj;
14379 wxFileType *arg1 = (wxFileType *) 0 ;
14380 PyObject *result;
14381 PyObject * obj0 = 0 ;
14382 char *kwnames[] = {
14383 (char *) "self", NULL
14384 };
14385
14386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14388 if (SWIG_arg_fail(1)) SWIG_fail;
14389 {
14390 PyThreadState* __tstate = wxPyBeginAllowThreads();
14391 result = (PyObject *)wxFileType_GetExtensions(arg1);
14392
14393 wxPyEndAllowThreads(__tstate);
14394 if (PyErr_Occurred()) SWIG_fail;
14395 }
14396 resultobj = result;
14397 return resultobj;
14398 fail:
14399 return NULL;
14400 }
14401
14402
14403 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14404 PyObject *resultobj;
14405 wxFileType *arg1 = (wxFileType *) 0 ;
14406 wxIcon *result;
14407 PyObject * obj0 = 0 ;
14408 char *kwnames[] = {
14409 (char *) "self", NULL
14410 };
14411
14412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14414 if (SWIG_arg_fail(1)) SWIG_fail;
14415 {
14416 PyThreadState* __tstate = wxPyBeginAllowThreads();
14417 result = (wxIcon *)wxFileType_GetIcon(arg1);
14418
14419 wxPyEndAllowThreads(__tstate);
14420 if (PyErr_Occurred()) SWIG_fail;
14421 }
14422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14423 return resultobj;
14424 fail:
14425 return NULL;
14426 }
14427
14428
14429 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14430 PyObject *resultobj;
14431 wxFileType *arg1 = (wxFileType *) 0 ;
14432 PyObject *result;
14433 PyObject * obj0 = 0 ;
14434 char *kwnames[] = {
14435 (char *) "self", NULL
14436 };
14437
14438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14440 if (SWIG_arg_fail(1)) SWIG_fail;
14441 {
14442 PyThreadState* __tstate = wxPyBeginAllowThreads();
14443 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14444
14445 wxPyEndAllowThreads(__tstate);
14446 if (PyErr_Occurred()) SWIG_fail;
14447 }
14448 resultobj = result;
14449 return resultobj;
14450 fail:
14451 return NULL;
14452 }
14453
14454
14455 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14456 PyObject *resultobj;
14457 wxFileType *arg1 = (wxFileType *) 0 ;
14458 PyObject *result;
14459 PyObject * obj0 = 0 ;
14460 char *kwnames[] = {
14461 (char *) "self", NULL
14462 };
14463
14464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14466 if (SWIG_arg_fail(1)) SWIG_fail;
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 result = (PyObject *)wxFileType_GetDescription(arg1);
14470
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 resultobj = result;
14475 return resultobj;
14476 fail:
14477 return NULL;
14478 }
14479
14480
14481 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14482 PyObject *resultobj;
14483 wxFileType *arg1 = (wxFileType *) 0 ;
14484 wxString *arg2 = 0 ;
14485 wxString const &arg3_defvalue = wxPyEmptyString ;
14486 wxString *arg3 = (wxString *) &arg3_defvalue ;
14487 PyObject *result;
14488 bool temp2 = false ;
14489 bool temp3 = false ;
14490 PyObject * obj0 = 0 ;
14491 PyObject * obj1 = 0 ;
14492 PyObject * obj2 = 0 ;
14493 char *kwnames[] = {
14494 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14495 };
14496
14497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14499 if (SWIG_arg_fail(1)) SWIG_fail;
14500 {
14501 arg2 = wxString_in_helper(obj1);
14502 if (arg2 == NULL) SWIG_fail;
14503 temp2 = true;
14504 }
14505 if (obj2) {
14506 {
14507 arg3 = wxString_in_helper(obj2);
14508 if (arg3 == NULL) SWIG_fail;
14509 temp3 = true;
14510 }
14511 }
14512 {
14513 PyThreadState* __tstate = wxPyBeginAllowThreads();
14514 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14515
14516 wxPyEndAllowThreads(__tstate);
14517 if (PyErr_Occurred()) SWIG_fail;
14518 }
14519 resultobj = result;
14520 {
14521 if (temp2)
14522 delete arg2;
14523 }
14524 {
14525 if (temp3)
14526 delete arg3;
14527 }
14528 return resultobj;
14529 fail:
14530 {
14531 if (temp2)
14532 delete arg2;
14533 }
14534 {
14535 if (temp3)
14536 delete arg3;
14537 }
14538 return NULL;
14539 }
14540
14541
14542 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14543 PyObject *resultobj;
14544 wxFileType *arg1 = (wxFileType *) 0 ;
14545 wxString *arg2 = 0 ;
14546 wxString const &arg3_defvalue = wxPyEmptyString ;
14547 wxString *arg3 = (wxString *) &arg3_defvalue ;
14548 PyObject *result;
14549 bool temp2 = false ;
14550 bool temp3 = false ;
14551 PyObject * obj0 = 0 ;
14552 PyObject * obj1 = 0 ;
14553 PyObject * obj2 = 0 ;
14554 char *kwnames[] = {
14555 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14556 };
14557
14558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14560 if (SWIG_arg_fail(1)) SWIG_fail;
14561 {
14562 arg2 = wxString_in_helper(obj1);
14563 if (arg2 == NULL) SWIG_fail;
14564 temp2 = true;
14565 }
14566 if (obj2) {
14567 {
14568 arg3 = wxString_in_helper(obj2);
14569 if (arg3 == NULL) SWIG_fail;
14570 temp3 = true;
14571 }
14572 }
14573 {
14574 PyThreadState* __tstate = wxPyBeginAllowThreads();
14575 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14576
14577 wxPyEndAllowThreads(__tstate);
14578 if (PyErr_Occurred()) SWIG_fail;
14579 }
14580 resultobj = result;
14581 {
14582 if (temp2)
14583 delete arg2;
14584 }
14585 {
14586 if (temp3)
14587 delete arg3;
14588 }
14589 return resultobj;
14590 fail:
14591 {
14592 if (temp2)
14593 delete arg2;
14594 }
14595 {
14596 if (temp3)
14597 delete arg3;
14598 }
14599 return NULL;
14600 }
14601
14602
14603 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14604 PyObject *resultobj;
14605 wxFileType *arg1 = (wxFileType *) 0 ;
14606 wxString *arg2 = 0 ;
14607 wxString const &arg3_defvalue = wxPyEmptyString ;
14608 wxString *arg3 = (wxString *) &arg3_defvalue ;
14609 PyObject *result;
14610 bool temp2 = false ;
14611 bool temp3 = false ;
14612 PyObject * obj0 = 0 ;
14613 PyObject * obj1 = 0 ;
14614 PyObject * obj2 = 0 ;
14615 char *kwnames[] = {
14616 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14617 };
14618
14619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14621 if (SWIG_arg_fail(1)) SWIG_fail;
14622 {
14623 arg2 = wxString_in_helper(obj1);
14624 if (arg2 == NULL) SWIG_fail;
14625 temp2 = true;
14626 }
14627 if (obj2) {
14628 {
14629 arg3 = wxString_in_helper(obj2);
14630 if (arg3 == NULL) SWIG_fail;
14631 temp3 = true;
14632 }
14633 }
14634 {
14635 PyThreadState* __tstate = wxPyBeginAllowThreads();
14636 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14637
14638 wxPyEndAllowThreads(__tstate);
14639 if (PyErr_Occurred()) SWIG_fail;
14640 }
14641 resultobj = result;
14642 {
14643 if (temp2)
14644 delete arg2;
14645 }
14646 {
14647 if (temp3)
14648 delete arg3;
14649 }
14650 return resultobj;
14651 fail:
14652 {
14653 if (temp2)
14654 delete arg2;
14655 }
14656 {
14657 if (temp3)
14658 delete arg3;
14659 }
14660 return NULL;
14661 }
14662
14663
14664 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14665 PyObject *resultobj;
14666 wxFileType *arg1 = (wxFileType *) 0 ;
14667 wxString *arg2 = 0 ;
14668 wxString *arg3 = 0 ;
14669 bool arg4 = (bool) true ;
14670 bool result;
14671 bool temp2 = false ;
14672 bool temp3 = false ;
14673 PyObject * obj0 = 0 ;
14674 PyObject * obj1 = 0 ;
14675 PyObject * obj2 = 0 ;
14676 PyObject * obj3 = 0 ;
14677 char *kwnames[] = {
14678 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14679 };
14680
14681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14683 if (SWIG_arg_fail(1)) SWIG_fail;
14684 {
14685 arg2 = wxString_in_helper(obj1);
14686 if (arg2 == NULL) SWIG_fail;
14687 temp2 = true;
14688 }
14689 {
14690 arg3 = wxString_in_helper(obj2);
14691 if (arg3 == NULL) SWIG_fail;
14692 temp3 = true;
14693 }
14694 if (obj3) {
14695 {
14696 arg4 = (bool)(SWIG_As_bool(obj3));
14697 if (SWIG_arg_fail(4)) SWIG_fail;
14698 }
14699 }
14700 {
14701 PyThreadState* __tstate = wxPyBeginAllowThreads();
14702 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14703
14704 wxPyEndAllowThreads(__tstate);
14705 if (PyErr_Occurred()) SWIG_fail;
14706 }
14707 {
14708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14709 }
14710 {
14711 if (temp2)
14712 delete arg2;
14713 }
14714 {
14715 if (temp3)
14716 delete arg3;
14717 }
14718 return resultobj;
14719 fail:
14720 {
14721 if (temp2)
14722 delete arg2;
14723 }
14724 {
14725 if (temp3)
14726 delete arg3;
14727 }
14728 return NULL;
14729 }
14730
14731
14732 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14733 PyObject *resultobj;
14734 wxFileType *arg1 = (wxFileType *) 0 ;
14735 wxString const &arg2_defvalue = wxPyEmptyString ;
14736 wxString *arg2 = (wxString *) &arg2_defvalue ;
14737 int arg3 = (int) 0 ;
14738 bool result;
14739 bool temp2 = false ;
14740 PyObject * obj0 = 0 ;
14741 PyObject * obj1 = 0 ;
14742 PyObject * obj2 = 0 ;
14743 char *kwnames[] = {
14744 (char *) "self",(char *) "cmd",(char *) "index", NULL
14745 };
14746
14747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14749 if (SWIG_arg_fail(1)) SWIG_fail;
14750 if (obj1) {
14751 {
14752 arg2 = wxString_in_helper(obj1);
14753 if (arg2 == NULL) SWIG_fail;
14754 temp2 = true;
14755 }
14756 }
14757 if (obj2) {
14758 {
14759 arg3 = (int)(SWIG_As_int(obj2));
14760 if (SWIG_arg_fail(3)) SWIG_fail;
14761 }
14762 }
14763 {
14764 PyThreadState* __tstate = wxPyBeginAllowThreads();
14765 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14766
14767 wxPyEndAllowThreads(__tstate);
14768 if (PyErr_Occurred()) SWIG_fail;
14769 }
14770 {
14771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14772 }
14773 {
14774 if (temp2)
14775 delete arg2;
14776 }
14777 return resultobj;
14778 fail:
14779 {
14780 if (temp2)
14781 delete arg2;
14782 }
14783 return NULL;
14784 }
14785
14786
14787 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14788 PyObject *resultobj;
14789 wxFileType *arg1 = (wxFileType *) 0 ;
14790 bool result;
14791 PyObject * obj0 = 0 ;
14792 char *kwnames[] = {
14793 (char *) "self", NULL
14794 };
14795
14796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14798 if (SWIG_arg_fail(1)) SWIG_fail;
14799 {
14800 PyThreadState* __tstate = wxPyBeginAllowThreads();
14801 result = (bool)(arg1)->Unassociate();
14802
14803 wxPyEndAllowThreads(__tstate);
14804 if (PyErr_Occurred()) SWIG_fail;
14805 }
14806 {
14807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14808 }
14809 return resultobj;
14810 fail:
14811 return NULL;
14812 }
14813
14814
14815 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14816 PyObject *resultobj;
14817 wxString *arg1 = 0 ;
14818 wxString *arg2 = 0 ;
14819 wxString const &arg3_defvalue = wxPyEmptyString ;
14820 wxString *arg3 = (wxString *) &arg3_defvalue ;
14821 wxString result;
14822 bool temp1 = false ;
14823 bool temp2 = false ;
14824 bool temp3 = false ;
14825 PyObject * obj0 = 0 ;
14826 PyObject * obj1 = 0 ;
14827 PyObject * obj2 = 0 ;
14828 char *kwnames[] = {
14829 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14830 };
14831
14832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14833 {
14834 arg1 = wxString_in_helper(obj0);
14835 if (arg1 == NULL) SWIG_fail;
14836 temp1 = true;
14837 }
14838 {
14839 arg2 = wxString_in_helper(obj1);
14840 if (arg2 == NULL) SWIG_fail;
14841 temp2 = true;
14842 }
14843 if (obj2) {
14844 {
14845 arg3 = wxString_in_helper(obj2);
14846 if (arg3 == NULL) SWIG_fail;
14847 temp3 = true;
14848 }
14849 }
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14853
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 {
14858 #if wxUSE_UNICODE
14859 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14860 #else
14861 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14862 #endif
14863 }
14864 {
14865 if (temp1)
14866 delete arg1;
14867 }
14868 {
14869 if (temp2)
14870 delete arg2;
14871 }
14872 {
14873 if (temp3)
14874 delete arg3;
14875 }
14876 return resultobj;
14877 fail:
14878 {
14879 if (temp1)
14880 delete arg1;
14881 }
14882 {
14883 if (temp2)
14884 delete arg2;
14885 }
14886 {
14887 if (temp3)
14888 delete arg3;
14889 }
14890 return NULL;
14891 }
14892
14893
14894 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14895 PyObject *obj;
14896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14897 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14898 Py_INCREF(obj);
14899 return Py_BuildValue((char *)"");
14900 }
14901 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14902 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14903 return 1;
14904 }
14905
14906
14907 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14908 PyObject *pyobj;
14909
14910 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14911 return pyobj;
14912 }
14913
14914
14915 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14916 PyObject *resultobj;
14917 wxString *arg1 = 0 ;
14918 wxString *arg2 = 0 ;
14919 bool result;
14920 bool temp1 = false ;
14921 bool temp2 = false ;
14922 PyObject * obj0 = 0 ;
14923 PyObject * obj1 = 0 ;
14924 char *kwnames[] = {
14925 (char *) "mimeType",(char *) "wildcard", NULL
14926 };
14927
14928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14929 {
14930 arg1 = wxString_in_helper(obj0);
14931 if (arg1 == NULL) SWIG_fail;
14932 temp1 = true;
14933 }
14934 {
14935 arg2 = wxString_in_helper(obj1);
14936 if (arg2 == NULL) SWIG_fail;
14937 temp2 = true;
14938 }
14939 {
14940 PyThreadState* __tstate = wxPyBeginAllowThreads();
14941 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14942
14943 wxPyEndAllowThreads(__tstate);
14944 if (PyErr_Occurred()) SWIG_fail;
14945 }
14946 {
14947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14948 }
14949 {
14950 if (temp1)
14951 delete arg1;
14952 }
14953 {
14954 if (temp2)
14955 delete arg2;
14956 }
14957 return resultobj;
14958 fail:
14959 {
14960 if (temp1)
14961 delete arg1;
14962 }
14963 {
14964 if (temp2)
14965 delete arg2;
14966 }
14967 return NULL;
14968 }
14969
14970
14971 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14972 PyObject *resultobj;
14973 wxMimeTypesManager *result;
14974 char *kwnames[] = {
14975 NULL
14976 };
14977
14978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14982
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14994 PyObject *resultobj;
14995 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14996 int arg2 = (int) wxMAILCAP_ALL ;
14997 wxString const &arg3_defvalue = wxPyEmptyString ;
14998 wxString *arg3 = (wxString *) &arg3_defvalue ;
14999 bool temp3 = false ;
15000 PyObject * obj0 = 0 ;
15001 PyObject * obj1 = 0 ;
15002 PyObject * obj2 = 0 ;
15003 char *kwnames[] = {
15004 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15005 };
15006
15007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15009 if (SWIG_arg_fail(1)) SWIG_fail;
15010 if (obj1) {
15011 {
15012 arg2 = (int)(SWIG_As_int(obj1));
15013 if (SWIG_arg_fail(2)) SWIG_fail;
15014 }
15015 }
15016 if (obj2) {
15017 {
15018 arg3 = wxString_in_helper(obj2);
15019 if (arg3 == NULL) SWIG_fail;
15020 temp3 = true;
15021 }
15022 }
15023 {
15024 PyThreadState* __tstate = wxPyBeginAllowThreads();
15025 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15026
15027 wxPyEndAllowThreads(__tstate);
15028 if (PyErr_Occurred()) SWIG_fail;
15029 }
15030 Py_INCREF(Py_None); resultobj = Py_None;
15031 {
15032 if (temp3)
15033 delete arg3;
15034 }
15035 return resultobj;
15036 fail:
15037 {
15038 if (temp3)
15039 delete arg3;
15040 }
15041 return NULL;
15042 }
15043
15044
15045 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15046 PyObject *resultobj;
15047 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15048 PyObject * obj0 = 0 ;
15049 char *kwnames[] = {
15050 (char *) "self", NULL
15051 };
15052
15053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15055 if (SWIG_arg_fail(1)) SWIG_fail;
15056 {
15057 PyThreadState* __tstate = wxPyBeginAllowThreads();
15058 (arg1)->ClearData();
15059
15060 wxPyEndAllowThreads(__tstate);
15061 if (PyErr_Occurred()) SWIG_fail;
15062 }
15063 Py_INCREF(Py_None); resultobj = Py_None;
15064 return resultobj;
15065 fail:
15066 return NULL;
15067 }
15068
15069
15070 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15071 PyObject *resultobj;
15072 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15073 wxString *arg2 = 0 ;
15074 wxFileType *result;
15075 bool temp2 = false ;
15076 PyObject * obj0 = 0 ;
15077 PyObject * obj1 = 0 ;
15078 char *kwnames[] = {
15079 (char *) "self",(char *) "ext", NULL
15080 };
15081
15082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15084 if (SWIG_arg_fail(1)) SWIG_fail;
15085 {
15086 arg2 = wxString_in_helper(obj1);
15087 if (arg2 == NULL) SWIG_fail;
15088 temp2 = true;
15089 }
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15093
15094 wxPyEndAllowThreads(__tstate);
15095 if (PyErr_Occurred()) SWIG_fail;
15096 }
15097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15098 {
15099 if (temp2)
15100 delete arg2;
15101 }
15102 return resultobj;
15103 fail:
15104 {
15105 if (temp2)
15106 delete arg2;
15107 }
15108 return NULL;
15109 }
15110
15111
15112 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj;
15114 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15115 wxString *arg2 = 0 ;
15116 wxFileType *result;
15117 bool temp2 = false ;
15118 PyObject * obj0 = 0 ;
15119 PyObject * obj1 = 0 ;
15120 char *kwnames[] = {
15121 (char *) "self",(char *) "mimeType", NULL
15122 };
15123
15124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15126 if (SWIG_arg_fail(1)) SWIG_fail;
15127 {
15128 arg2 = wxString_in_helper(obj1);
15129 if (arg2 == NULL) SWIG_fail;
15130 temp2 = true;
15131 }
15132 {
15133 PyThreadState* __tstate = wxPyBeginAllowThreads();
15134 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15135
15136 wxPyEndAllowThreads(__tstate);
15137 if (PyErr_Occurred()) SWIG_fail;
15138 }
15139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15140 {
15141 if (temp2)
15142 delete arg2;
15143 }
15144 return resultobj;
15145 fail:
15146 {
15147 if (temp2)
15148 delete arg2;
15149 }
15150 return NULL;
15151 }
15152
15153
15154 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15155 PyObject *resultobj;
15156 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15157 wxString *arg2 = 0 ;
15158 bool arg3 = (bool) false ;
15159 bool result;
15160 bool temp2 = false ;
15161 PyObject * obj0 = 0 ;
15162 PyObject * obj1 = 0 ;
15163 PyObject * obj2 = 0 ;
15164 char *kwnames[] = {
15165 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15166 };
15167
15168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15170 if (SWIG_arg_fail(1)) SWIG_fail;
15171 {
15172 arg2 = wxString_in_helper(obj1);
15173 if (arg2 == NULL) SWIG_fail;
15174 temp2 = true;
15175 }
15176 if (obj2) {
15177 {
15178 arg3 = (bool)(SWIG_As_bool(obj2));
15179 if (SWIG_arg_fail(3)) SWIG_fail;
15180 }
15181 }
15182 {
15183 PyThreadState* __tstate = wxPyBeginAllowThreads();
15184 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15185
15186 wxPyEndAllowThreads(__tstate);
15187 if (PyErr_Occurred()) SWIG_fail;
15188 }
15189 {
15190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15191 }
15192 {
15193 if (temp2)
15194 delete arg2;
15195 }
15196 return resultobj;
15197 fail:
15198 {
15199 if (temp2)
15200 delete arg2;
15201 }
15202 return NULL;
15203 }
15204
15205
15206 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15207 PyObject *resultobj;
15208 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15209 wxString *arg2 = 0 ;
15210 bool result;
15211 bool temp2 = false ;
15212 PyObject * obj0 = 0 ;
15213 PyObject * obj1 = 0 ;
15214 char *kwnames[] = {
15215 (char *) "self",(char *) "filename", NULL
15216 };
15217
15218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15220 if (SWIG_arg_fail(1)) SWIG_fail;
15221 {
15222 arg2 = wxString_in_helper(obj1);
15223 if (arg2 == NULL) SWIG_fail;
15224 temp2 = true;
15225 }
15226 {
15227 PyThreadState* __tstate = wxPyBeginAllowThreads();
15228 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15229
15230 wxPyEndAllowThreads(__tstate);
15231 if (PyErr_Occurred()) SWIG_fail;
15232 }
15233 {
15234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15235 }
15236 {
15237 if (temp2)
15238 delete arg2;
15239 }
15240 return resultobj;
15241 fail:
15242 {
15243 if (temp2)
15244 delete arg2;
15245 }
15246 return NULL;
15247 }
15248
15249
15250 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15251 PyObject *resultobj;
15252 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15253 PyObject *result;
15254 PyObject * obj0 = 0 ;
15255 char *kwnames[] = {
15256 (char *) "self", NULL
15257 };
15258
15259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15261 if (SWIG_arg_fail(1)) SWIG_fail;
15262 {
15263 PyThreadState* __tstate = wxPyBeginAllowThreads();
15264 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15265
15266 wxPyEndAllowThreads(__tstate);
15267 if (PyErr_Occurred()) SWIG_fail;
15268 }
15269 resultobj = result;
15270 return resultobj;
15271 fail:
15272 return NULL;
15273 }
15274
15275
15276 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15277 PyObject *resultobj;
15278 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15279 wxFileTypeInfo *arg2 = 0 ;
15280 PyObject * obj0 = 0 ;
15281 PyObject * obj1 = 0 ;
15282 char *kwnames[] = {
15283 (char *) "self",(char *) "ft", NULL
15284 };
15285
15286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15288 if (SWIG_arg_fail(1)) SWIG_fail;
15289 {
15290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15291 if (SWIG_arg_fail(2)) SWIG_fail;
15292 if (arg2 == NULL) {
15293 SWIG_null_ref("wxFileTypeInfo");
15294 }
15295 if (SWIG_arg_fail(2)) SWIG_fail;
15296 }
15297 {
15298 PyThreadState* __tstate = wxPyBeginAllowThreads();
15299 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15300
15301 wxPyEndAllowThreads(__tstate);
15302 if (PyErr_Occurred()) SWIG_fail;
15303 }
15304 Py_INCREF(Py_None); resultobj = Py_None;
15305 return resultobj;
15306 fail:
15307 return NULL;
15308 }
15309
15310
15311 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15312 PyObject *resultobj;
15313 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15314 wxFileTypeInfo *arg2 = 0 ;
15315 wxFileType *result;
15316 PyObject * obj0 = 0 ;
15317 PyObject * obj1 = 0 ;
15318 char *kwnames[] = {
15319 (char *) "self",(char *) "ftInfo", NULL
15320 };
15321
15322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15324 if (SWIG_arg_fail(1)) SWIG_fail;
15325 {
15326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15327 if (SWIG_arg_fail(2)) SWIG_fail;
15328 if (arg2 == NULL) {
15329 SWIG_null_ref("wxFileTypeInfo");
15330 }
15331 if (SWIG_arg_fail(2)) SWIG_fail;
15332 }
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15336
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15348 PyObject *resultobj;
15349 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15350 wxFileType *arg2 = (wxFileType *) 0 ;
15351 bool result;
15352 PyObject * obj0 = 0 ;
15353 PyObject * obj1 = 0 ;
15354 char *kwnames[] = {
15355 (char *) "self",(char *) "ft", NULL
15356 };
15357
15358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15360 if (SWIG_arg_fail(1)) SWIG_fail;
15361 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15362 if (SWIG_arg_fail(2)) SWIG_fail;
15363 {
15364 PyThreadState* __tstate = wxPyBeginAllowThreads();
15365 result = (bool)(arg1)->Unassociate(arg2);
15366
15367 wxPyEndAllowThreads(__tstate);
15368 if (PyErr_Occurred()) SWIG_fail;
15369 }
15370 {
15371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15372 }
15373 return resultobj;
15374 fail:
15375 return NULL;
15376 }
15377
15378
15379 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15380 PyObject *resultobj;
15381 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15382 PyObject * obj0 = 0 ;
15383 char *kwnames[] = {
15384 (char *) "self", NULL
15385 };
15386
15387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15389 if (SWIG_arg_fail(1)) SWIG_fail;
15390 {
15391 PyThreadState* __tstate = wxPyBeginAllowThreads();
15392 delete arg1;
15393
15394 wxPyEndAllowThreads(__tstate);
15395 if (PyErr_Occurred()) SWIG_fail;
15396 }
15397 Py_INCREF(Py_None); resultobj = Py_None;
15398 return resultobj;
15399 fail:
15400 return NULL;
15401 }
15402
15403
15404 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15405 PyObject *obj;
15406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15407 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15408 Py_INCREF(obj);
15409 return Py_BuildValue((char *)"");
15410 }
15411 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15412 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15413 return 1;
15414 }
15415
15416
15417 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15418 PyObject *pyobj;
15419
15420 {
15421 #if wxUSE_UNICODE
15422 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15423 #else
15424 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15425 #endif
15426 }
15427 return pyobj;
15428 }
15429
15430
15431 static int _wrap_ART_MENU_set(PyObject *) {
15432 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15433 return 1;
15434 }
15435
15436
15437 static PyObject *_wrap_ART_MENU_get(void) {
15438 PyObject *pyobj;
15439
15440 {
15441 #if wxUSE_UNICODE
15442 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15443 #else
15444 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15445 #endif
15446 }
15447 return pyobj;
15448 }
15449
15450
15451 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15452 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15453 return 1;
15454 }
15455
15456
15457 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15458 PyObject *pyobj;
15459
15460 {
15461 #if wxUSE_UNICODE
15462 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15463 #else
15464 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15465 #endif
15466 }
15467 return pyobj;
15468 }
15469
15470
15471 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15472 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15473 return 1;
15474 }
15475
15476
15477 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15478 PyObject *pyobj;
15479
15480 {
15481 #if wxUSE_UNICODE
15482 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15483 #else
15484 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15485 #endif
15486 }
15487 return pyobj;
15488 }
15489
15490
15491 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15492 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15493 return 1;
15494 }
15495
15496
15497 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15498 PyObject *pyobj;
15499
15500 {
15501 #if wxUSE_UNICODE
15502 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15503 #else
15504 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15505 #endif
15506 }
15507 return pyobj;
15508 }
15509
15510
15511 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15512 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15513 return 1;
15514 }
15515
15516
15517 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15518 PyObject *pyobj;
15519
15520 {
15521 #if wxUSE_UNICODE
15522 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15523 #else
15524 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15525 #endif
15526 }
15527 return pyobj;
15528 }
15529
15530
15531 static int _wrap_ART_BUTTON_set(PyObject *) {
15532 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15533 return 1;
15534 }
15535
15536
15537 static PyObject *_wrap_ART_BUTTON_get(void) {
15538 PyObject *pyobj;
15539
15540 {
15541 #if wxUSE_UNICODE
15542 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15543 #else
15544 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15545 #endif
15546 }
15547 return pyobj;
15548 }
15549
15550
15551 static int _wrap_ART_OTHER_set(PyObject *) {
15552 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15553 return 1;
15554 }
15555
15556
15557 static PyObject *_wrap_ART_OTHER_get(void) {
15558 PyObject *pyobj;
15559
15560 {
15561 #if wxUSE_UNICODE
15562 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15563 #else
15564 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15565 #endif
15566 }
15567 return pyobj;
15568 }
15569
15570
15571 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15572 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15573 return 1;
15574 }
15575
15576
15577 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15578 PyObject *pyobj;
15579
15580 {
15581 #if wxUSE_UNICODE
15582 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15583 #else
15584 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15585 #endif
15586 }
15587 return pyobj;
15588 }
15589
15590
15591 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15592 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15593 return 1;
15594 }
15595
15596
15597 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15598 PyObject *pyobj;
15599
15600 {
15601 #if wxUSE_UNICODE
15602 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15603 #else
15604 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15605 #endif
15606 }
15607 return pyobj;
15608 }
15609
15610
15611 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15612 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15613 return 1;
15614 }
15615
15616
15617 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15618 PyObject *pyobj;
15619
15620 {
15621 #if wxUSE_UNICODE
15622 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15623 #else
15624 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15625 #endif
15626 }
15627 return pyobj;
15628 }
15629
15630
15631 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15632 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15633 return 1;
15634 }
15635
15636
15637 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15638 PyObject *pyobj;
15639
15640 {
15641 #if wxUSE_UNICODE
15642 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15643 #else
15644 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15645 #endif
15646 }
15647 return pyobj;
15648 }
15649
15650
15651 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15652 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15653 return 1;
15654 }
15655
15656
15657 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15658 PyObject *pyobj;
15659
15660 {
15661 #if wxUSE_UNICODE
15662 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15663 #else
15664 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15665 #endif
15666 }
15667 return pyobj;
15668 }
15669
15670
15671 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15672 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15673 return 1;
15674 }
15675
15676
15677 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15678 PyObject *pyobj;
15679
15680 {
15681 #if wxUSE_UNICODE
15682 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15683 #else
15684 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15685 #endif
15686 }
15687 return pyobj;
15688 }
15689
15690
15691 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15692 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15693 return 1;
15694 }
15695
15696
15697 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15698 PyObject *pyobj;
15699
15700 {
15701 #if wxUSE_UNICODE
15702 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15703 #else
15704 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15705 #endif
15706 }
15707 return pyobj;
15708 }
15709
15710
15711 static int _wrap_ART_GO_BACK_set(PyObject *) {
15712 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15713 return 1;
15714 }
15715
15716
15717 static PyObject *_wrap_ART_GO_BACK_get(void) {
15718 PyObject *pyobj;
15719
15720 {
15721 #if wxUSE_UNICODE
15722 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15723 #else
15724 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15725 #endif
15726 }
15727 return pyobj;
15728 }
15729
15730
15731 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15732 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15733 return 1;
15734 }
15735
15736
15737 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15738 PyObject *pyobj;
15739
15740 {
15741 #if wxUSE_UNICODE
15742 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15743 #else
15744 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15745 #endif
15746 }
15747 return pyobj;
15748 }
15749
15750
15751 static int _wrap_ART_GO_UP_set(PyObject *) {
15752 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15753 return 1;
15754 }
15755
15756
15757 static PyObject *_wrap_ART_GO_UP_get(void) {
15758 PyObject *pyobj;
15759
15760 {
15761 #if wxUSE_UNICODE
15762 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15763 #else
15764 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15765 #endif
15766 }
15767 return pyobj;
15768 }
15769
15770
15771 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15772 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15773 return 1;
15774 }
15775
15776
15777 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15778 PyObject *pyobj;
15779
15780 {
15781 #if wxUSE_UNICODE
15782 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15783 #else
15784 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15785 #endif
15786 }
15787 return pyobj;
15788 }
15789
15790
15791 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15792 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15793 return 1;
15794 }
15795
15796
15797 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15798 PyObject *pyobj;
15799
15800 {
15801 #if wxUSE_UNICODE
15802 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15803 #else
15804 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15805 #endif
15806 }
15807 return pyobj;
15808 }
15809
15810
15811 static int _wrap_ART_GO_HOME_set(PyObject *) {
15812 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15813 return 1;
15814 }
15815
15816
15817 static PyObject *_wrap_ART_GO_HOME_get(void) {
15818 PyObject *pyobj;
15819
15820 {
15821 #if wxUSE_UNICODE
15822 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15823 #else
15824 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15825 #endif
15826 }
15827 return pyobj;
15828 }
15829
15830
15831 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15832 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15833 return 1;
15834 }
15835
15836
15837 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15838 PyObject *pyobj;
15839
15840 {
15841 #if wxUSE_UNICODE
15842 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15843 #else
15844 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15845 #endif
15846 }
15847 return pyobj;
15848 }
15849
15850
15851 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15852 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15853 return 1;
15854 }
15855
15856
15857 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15858 PyObject *pyobj;
15859
15860 {
15861 #if wxUSE_UNICODE
15862 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15863 #else
15864 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15865 #endif
15866 }
15867 return pyobj;
15868 }
15869
15870
15871 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15872 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15873 return 1;
15874 }
15875
15876
15877 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15878 PyObject *pyobj;
15879
15880 {
15881 #if wxUSE_UNICODE
15882 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15883 #else
15884 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15885 #endif
15886 }
15887 return pyobj;
15888 }
15889
15890
15891 static int _wrap_ART_PRINT_set(PyObject *) {
15892 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15893 return 1;
15894 }
15895
15896
15897 static PyObject *_wrap_ART_PRINT_get(void) {
15898 PyObject *pyobj;
15899
15900 {
15901 #if wxUSE_UNICODE
15902 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15903 #else
15904 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15905 #endif
15906 }
15907 return pyobj;
15908 }
15909
15910
15911 static int _wrap_ART_HELP_set(PyObject *) {
15912 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15913 return 1;
15914 }
15915
15916
15917 static PyObject *_wrap_ART_HELP_get(void) {
15918 PyObject *pyobj;
15919
15920 {
15921 #if wxUSE_UNICODE
15922 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15923 #else
15924 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15925 #endif
15926 }
15927 return pyobj;
15928 }
15929
15930
15931 static int _wrap_ART_TIP_set(PyObject *) {
15932 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15933 return 1;
15934 }
15935
15936
15937 static PyObject *_wrap_ART_TIP_get(void) {
15938 PyObject *pyobj;
15939
15940 {
15941 #if wxUSE_UNICODE
15942 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15943 #else
15944 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15945 #endif
15946 }
15947 return pyobj;
15948 }
15949
15950
15951 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15952 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15953 return 1;
15954 }
15955
15956
15957 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15958 PyObject *pyobj;
15959
15960 {
15961 #if wxUSE_UNICODE
15962 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15963 #else
15964 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15965 #endif
15966 }
15967 return pyobj;
15968 }
15969
15970
15971 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15972 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15973 return 1;
15974 }
15975
15976
15977 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15978 PyObject *pyobj;
15979
15980 {
15981 #if wxUSE_UNICODE
15982 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15983 #else
15984 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15985 #endif
15986 }
15987 return pyobj;
15988 }
15989
15990
15991 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15992 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15993 return 1;
15994 }
15995
15996
15997 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15998 PyObject *pyobj;
15999
16000 {
16001 #if wxUSE_UNICODE
16002 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16003 #else
16004 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16005 #endif
16006 }
16007 return pyobj;
16008 }
16009
16010
16011 static int _wrap_ART_HARDDISK_set(PyObject *) {
16012 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16013 return 1;
16014 }
16015
16016
16017 static PyObject *_wrap_ART_HARDDISK_get(void) {
16018 PyObject *pyobj;
16019
16020 {
16021 #if wxUSE_UNICODE
16022 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16023 #else
16024 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16025 #endif
16026 }
16027 return pyobj;
16028 }
16029
16030
16031 static int _wrap_ART_FLOPPY_set(PyObject *) {
16032 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16033 return 1;
16034 }
16035
16036
16037 static PyObject *_wrap_ART_FLOPPY_get(void) {
16038 PyObject *pyobj;
16039
16040 {
16041 #if wxUSE_UNICODE
16042 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16043 #else
16044 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16045 #endif
16046 }
16047 return pyobj;
16048 }
16049
16050
16051 static int _wrap_ART_CDROM_set(PyObject *) {
16052 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16053 return 1;
16054 }
16055
16056
16057 static PyObject *_wrap_ART_CDROM_get(void) {
16058 PyObject *pyobj;
16059
16060 {
16061 #if wxUSE_UNICODE
16062 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16063 #else
16064 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16065 #endif
16066 }
16067 return pyobj;
16068 }
16069
16070
16071 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16072 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16073 return 1;
16074 }
16075
16076
16077 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16078 PyObject *pyobj;
16079
16080 {
16081 #if wxUSE_UNICODE
16082 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16083 #else
16084 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16085 #endif
16086 }
16087 return pyobj;
16088 }
16089
16090
16091 static int _wrap_ART_FOLDER_set(PyObject *) {
16092 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16093 return 1;
16094 }
16095
16096
16097 static PyObject *_wrap_ART_FOLDER_get(void) {
16098 PyObject *pyobj;
16099
16100 {
16101 #if wxUSE_UNICODE
16102 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16103 #else
16104 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16105 #endif
16106 }
16107 return pyobj;
16108 }
16109
16110
16111 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16112 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16113 return 1;
16114 }
16115
16116
16117 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16118 PyObject *pyobj;
16119
16120 {
16121 #if wxUSE_UNICODE
16122 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16123 #else
16124 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16125 #endif
16126 }
16127 return pyobj;
16128 }
16129
16130
16131 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16132 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16133 return 1;
16134 }
16135
16136
16137 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16138 PyObject *pyobj;
16139
16140 {
16141 #if wxUSE_UNICODE
16142 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16143 #else
16144 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16145 #endif
16146 }
16147 return pyobj;
16148 }
16149
16150
16151 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16152 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16153 return 1;
16154 }
16155
16156
16157 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16158 PyObject *pyobj;
16159
16160 {
16161 #if wxUSE_UNICODE
16162 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16163 #else
16164 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16165 #endif
16166 }
16167 return pyobj;
16168 }
16169
16170
16171 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16172 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16173 return 1;
16174 }
16175
16176
16177 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16178 PyObject *pyobj;
16179
16180 {
16181 #if wxUSE_UNICODE
16182 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16183 #else
16184 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16185 #endif
16186 }
16187 return pyobj;
16188 }
16189
16190
16191 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16192 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16193 return 1;
16194 }
16195
16196
16197 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16198 PyObject *pyobj;
16199
16200 {
16201 #if wxUSE_UNICODE
16202 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16203 #else
16204 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16205 #endif
16206 }
16207 return pyobj;
16208 }
16209
16210
16211 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16212 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16213 return 1;
16214 }
16215
16216
16217 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16218 PyObject *pyobj;
16219
16220 {
16221 #if wxUSE_UNICODE
16222 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16223 #else
16224 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16225 #endif
16226 }
16227 return pyobj;
16228 }
16229
16230
16231 static int _wrap_ART_ERROR_set(PyObject *) {
16232 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16233 return 1;
16234 }
16235
16236
16237 static PyObject *_wrap_ART_ERROR_get(void) {
16238 PyObject *pyobj;
16239
16240 {
16241 #if wxUSE_UNICODE
16242 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16243 #else
16244 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16245 #endif
16246 }
16247 return pyobj;
16248 }
16249
16250
16251 static int _wrap_ART_QUESTION_set(PyObject *) {
16252 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16253 return 1;
16254 }
16255
16256
16257 static PyObject *_wrap_ART_QUESTION_get(void) {
16258 PyObject *pyobj;
16259
16260 {
16261 #if wxUSE_UNICODE
16262 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16263 #else
16264 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16265 #endif
16266 }
16267 return pyobj;
16268 }
16269
16270
16271 static int _wrap_ART_WARNING_set(PyObject *) {
16272 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16273 return 1;
16274 }
16275
16276
16277 static PyObject *_wrap_ART_WARNING_get(void) {
16278 PyObject *pyobj;
16279
16280 {
16281 #if wxUSE_UNICODE
16282 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16283 #else
16284 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16285 #endif
16286 }
16287 return pyobj;
16288 }
16289
16290
16291 static int _wrap_ART_INFORMATION_set(PyObject *) {
16292 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16293 return 1;
16294 }
16295
16296
16297 static PyObject *_wrap_ART_INFORMATION_get(void) {
16298 PyObject *pyobj;
16299
16300 {
16301 #if wxUSE_UNICODE
16302 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16303 #else
16304 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16305 #endif
16306 }
16307 return pyobj;
16308 }
16309
16310
16311 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16312 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16313 return 1;
16314 }
16315
16316
16317 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16318 PyObject *pyobj;
16319
16320 {
16321 #if wxUSE_UNICODE
16322 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16323 #else
16324 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16325 #endif
16326 }
16327 return pyobj;
16328 }
16329
16330
16331 static int _wrap_ART_COPY_set(PyObject *) {
16332 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16333 return 1;
16334 }
16335
16336
16337 static PyObject *_wrap_ART_COPY_get(void) {
16338 PyObject *pyobj;
16339
16340 {
16341 #if wxUSE_UNICODE
16342 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16343 #else
16344 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16345 #endif
16346 }
16347 return pyobj;
16348 }
16349
16350
16351 static int _wrap_ART_CUT_set(PyObject *) {
16352 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16353 return 1;
16354 }
16355
16356
16357 static PyObject *_wrap_ART_CUT_get(void) {
16358 PyObject *pyobj;
16359
16360 {
16361 #if wxUSE_UNICODE
16362 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16363 #else
16364 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16365 #endif
16366 }
16367 return pyobj;
16368 }
16369
16370
16371 static int _wrap_ART_PASTE_set(PyObject *) {
16372 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16373 return 1;
16374 }
16375
16376
16377 static PyObject *_wrap_ART_PASTE_get(void) {
16378 PyObject *pyobj;
16379
16380 {
16381 #if wxUSE_UNICODE
16382 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16383 #else
16384 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16385 #endif
16386 }
16387 return pyobj;
16388 }
16389
16390
16391 static int _wrap_ART_DELETE_set(PyObject *) {
16392 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16393 return 1;
16394 }
16395
16396
16397 static PyObject *_wrap_ART_DELETE_get(void) {
16398 PyObject *pyobj;
16399
16400 {
16401 #if wxUSE_UNICODE
16402 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16403 #else
16404 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16405 #endif
16406 }
16407 return pyobj;
16408 }
16409
16410
16411 static int _wrap_ART_UNDO_set(PyObject *) {
16412 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16413 return 1;
16414 }
16415
16416
16417 static PyObject *_wrap_ART_UNDO_get(void) {
16418 PyObject *pyobj;
16419
16420 {
16421 #if wxUSE_UNICODE
16422 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16423 #else
16424 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16425 #endif
16426 }
16427 return pyobj;
16428 }
16429
16430
16431 static int _wrap_ART_REDO_set(PyObject *) {
16432 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16433 return 1;
16434 }
16435
16436
16437 static PyObject *_wrap_ART_REDO_get(void) {
16438 PyObject *pyobj;
16439
16440 {
16441 #if wxUSE_UNICODE
16442 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16443 #else
16444 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16445 #endif
16446 }
16447 return pyobj;
16448 }
16449
16450
16451 static int _wrap_ART_QUIT_set(PyObject *) {
16452 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16453 return 1;
16454 }
16455
16456
16457 static PyObject *_wrap_ART_QUIT_get(void) {
16458 PyObject *pyobj;
16459
16460 {
16461 #if wxUSE_UNICODE
16462 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16463 #else
16464 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16465 #endif
16466 }
16467 return pyobj;
16468 }
16469
16470
16471 static int _wrap_ART_FIND_set(PyObject *) {
16472 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16473 return 1;
16474 }
16475
16476
16477 static PyObject *_wrap_ART_FIND_get(void) {
16478 PyObject *pyobj;
16479
16480 {
16481 #if wxUSE_UNICODE
16482 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16483 #else
16484 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16485 #endif
16486 }
16487 return pyobj;
16488 }
16489
16490
16491 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16492 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16493 return 1;
16494 }
16495
16496
16497 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16498 PyObject *pyobj;
16499
16500 {
16501 #if wxUSE_UNICODE
16502 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16503 #else
16504 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16505 #endif
16506 }
16507 return pyobj;
16508 }
16509
16510
16511 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16512 PyObject *resultobj;
16513 wxPyArtProvider *result;
16514 char *kwnames[] = {
16515 NULL
16516 };
16517
16518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16519 {
16520 if (!wxPyCheckForApp()) SWIG_fail;
16521 PyThreadState* __tstate = wxPyBeginAllowThreads();
16522 result = (wxPyArtProvider *)new wxPyArtProvider();
16523
16524 wxPyEndAllowThreads(__tstate);
16525 if (PyErr_Occurred()) SWIG_fail;
16526 }
16527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16535 PyObject *resultobj;
16536 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16537 PyObject *arg2 = (PyObject *) 0 ;
16538 PyObject *arg3 = (PyObject *) 0 ;
16539 PyObject * obj0 = 0 ;
16540 PyObject * obj1 = 0 ;
16541 PyObject * obj2 = 0 ;
16542 char *kwnames[] = {
16543 (char *) "self",(char *) "self",(char *) "_class", NULL
16544 };
16545
16546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16548 if (SWIG_arg_fail(1)) SWIG_fail;
16549 arg2 = obj1;
16550 arg3 = obj2;
16551 {
16552 PyThreadState* __tstate = wxPyBeginAllowThreads();
16553 (arg1)->_setCallbackInfo(arg2,arg3);
16554
16555 wxPyEndAllowThreads(__tstate);
16556 if (PyErr_Occurred()) SWIG_fail;
16557 }
16558 Py_INCREF(Py_None); resultobj = Py_None;
16559 return resultobj;
16560 fail:
16561 return NULL;
16562 }
16563
16564
16565 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16566 PyObject *resultobj;
16567 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16568 PyObject * obj0 = 0 ;
16569 char *kwnames[] = {
16570 (char *) "provider", NULL
16571 };
16572
16573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16575 if (SWIG_arg_fail(1)) SWIG_fail;
16576 {
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 wxPyArtProvider::PushProvider(arg1);
16579
16580 wxPyEndAllowThreads(__tstate);
16581 if (PyErr_Occurred()) SWIG_fail;
16582 }
16583 Py_INCREF(Py_None); resultobj = Py_None;
16584 return resultobj;
16585 fail:
16586 return NULL;
16587 }
16588
16589
16590 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16591 PyObject *resultobj;
16592 bool result;
16593 char *kwnames[] = {
16594 NULL
16595 };
16596
16597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16598 {
16599 PyThreadState* __tstate = wxPyBeginAllowThreads();
16600 result = (bool)wxPyArtProvider::PopProvider();
16601
16602 wxPyEndAllowThreads(__tstate);
16603 if (PyErr_Occurred()) SWIG_fail;
16604 }
16605 {
16606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16607 }
16608 return resultobj;
16609 fail:
16610 return NULL;
16611 }
16612
16613
16614 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16615 PyObject *resultobj;
16616 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16617 bool result;
16618 PyObject * obj0 = 0 ;
16619 char *kwnames[] = {
16620 (char *) "provider", NULL
16621 };
16622
16623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16625 if (SWIG_arg_fail(1)) SWIG_fail;
16626 {
16627 PyThreadState* __tstate = wxPyBeginAllowThreads();
16628 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16629
16630 wxPyEndAllowThreads(__tstate);
16631 if (PyErr_Occurred()) SWIG_fail;
16632 }
16633 {
16634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16635 }
16636 return resultobj;
16637 fail:
16638 return NULL;
16639 }
16640
16641
16642 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16643 PyObject *resultobj;
16644 wxString *arg1 = 0 ;
16645 wxString const &arg2_defvalue = wxPyART_OTHER ;
16646 wxString *arg2 = (wxString *) &arg2_defvalue ;
16647 wxSize const &arg3_defvalue = wxDefaultSize ;
16648 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16649 wxBitmap result;
16650 bool temp1 = false ;
16651 bool temp2 = false ;
16652 wxSize temp3 ;
16653 PyObject * obj0 = 0 ;
16654 PyObject * obj1 = 0 ;
16655 PyObject * obj2 = 0 ;
16656 char *kwnames[] = {
16657 (char *) "id",(char *) "client",(char *) "size", NULL
16658 };
16659
16660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16661 {
16662 arg1 = wxString_in_helper(obj0);
16663 if (arg1 == NULL) SWIG_fail;
16664 temp1 = true;
16665 }
16666 if (obj1) {
16667 {
16668 arg2 = wxString_in_helper(obj1);
16669 if (arg2 == NULL) SWIG_fail;
16670 temp2 = true;
16671 }
16672 }
16673 if (obj2) {
16674 {
16675 arg3 = &temp3;
16676 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16677 }
16678 }
16679 {
16680 if (!wxPyCheckForApp()) SWIG_fail;
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16683
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 {
16688 wxBitmap * resultptr;
16689 resultptr = new wxBitmap((wxBitmap &)(result));
16690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16691 }
16692 {
16693 if (temp1)
16694 delete arg1;
16695 }
16696 {
16697 if (temp2)
16698 delete arg2;
16699 }
16700 return resultobj;
16701 fail:
16702 {
16703 if (temp1)
16704 delete arg1;
16705 }
16706 {
16707 if (temp2)
16708 delete arg2;
16709 }
16710 return NULL;
16711 }
16712
16713
16714 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16715 PyObject *resultobj;
16716 wxString *arg1 = 0 ;
16717 wxString const &arg2_defvalue = wxPyART_OTHER ;
16718 wxString *arg2 = (wxString *) &arg2_defvalue ;
16719 wxSize const &arg3_defvalue = wxDefaultSize ;
16720 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16721 wxIcon result;
16722 bool temp1 = false ;
16723 bool temp2 = false ;
16724 wxSize temp3 ;
16725 PyObject * obj0 = 0 ;
16726 PyObject * obj1 = 0 ;
16727 PyObject * obj2 = 0 ;
16728 char *kwnames[] = {
16729 (char *) "id",(char *) "client",(char *) "size", NULL
16730 };
16731
16732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16733 {
16734 arg1 = wxString_in_helper(obj0);
16735 if (arg1 == NULL) SWIG_fail;
16736 temp1 = true;
16737 }
16738 if (obj1) {
16739 {
16740 arg2 = wxString_in_helper(obj1);
16741 if (arg2 == NULL) SWIG_fail;
16742 temp2 = true;
16743 }
16744 }
16745 if (obj2) {
16746 {
16747 arg3 = &temp3;
16748 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16749 }
16750 }
16751 {
16752 if (!wxPyCheckForApp()) SWIG_fail;
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16755
16756 wxPyEndAllowThreads(__tstate);
16757 if (PyErr_Occurred()) SWIG_fail;
16758 }
16759 {
16760 wxIcon * resultptr;
16761 resultptr = new wxIcon((wxIcon &)(result));
16762 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16763 }
16764 {
16765 if (temp1)
16766 delete arg1;
16767 }
16768 {
16769 if (temp2)
16770 delete arg2;
16771 }
16772 return resultobj;
16773 fail:
16774 {
16775 if (temp1)
16776 delete arg1;
16777 }
16778 {
16779 if (temp2)
16780 delete arg2;
16781 }
16782 return NULL;
16783 }
16784
16785
16786 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16787 PyObject *resultobj;
16788 wxString *arg1 = 0 ;
16789 bool arg2 = (bool) false ;
16790 wxSize result;
16791 bool temp1 = false ;
16792 PyObject * obj0 = 0 ;
16793 PyObject * obj1 = 0 ;
16794 char *kwnames[] = {
16795 (char *) "client",(char *) "platform_dependent", NULL
16796 };
16797
16798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16799 {
16800 arg1 = wxString_in_helper(obj0);
16801 if (arg1 == NULL) SWIG_fail;
16802 temp1 = true;
16803 }
16804 if (obj1) {
16805 {
16806 arg2 = (bool)(SWIG_As_bool(obj1));
16807 if (SWIG_arg_fail(2)) SWIG_fail;
16808 }
16809 }
16810 {
16811 PyThreadState* __tstate = wxPyBeginAllowThreads();
16812 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16813
16814 wxPyEndAllowThreads(__tstate);
16815 if (PyErr_Occurred()) SWIG_fail;
16816 }
16817 {
16818 wxSize * resultptr;
16819 resultptr = new wxSize((wxSize &)(result));
16820 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16821 }
16822 {
16823 if (temp1)
16824 delete arg1;
16825 }
16826 return resultobj;
16827 fail:
16828 {
16829 if (temp1)
16830 delete arg1;
16831 }
16832 return NULL;
16833 }
16834
16835
16836 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj;
16838 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16839 PyObject * obj0 = 0 ;
16840 char *kwnames[] = {
16841 (char *) "self", NULL
16842 };
16843
16844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16846 if (SWIG_arg_fail(1)) SWIG_fail;
16847 {
16848 PyThreadState* __tstate = wxPyBeginAllowThreads();
16849 wxPyArtProvider_Destroy(arg1);
16850
16851 wxPyEndAllowThreads(__tstate);
16852 if (PyErr_Occurred()) SWIG_fail;
16853 }
16854 Py_INCREF(Py_None); resultobj = Py_None;
16855 return resultobj;
16856 fail:
16857 return NULL;
16858 }
16859
16860
16861 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16862 PyObject *obj;
16863 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16864 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16865 Py_INCREF(obj);
16866 return Py_BuildValue((char *)"");
16867 }
16868 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16869 PyObject *resultobj;
16870 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16871 PyObject * obj0 = 0 ;
16872 char *kwnames[] = {
16873 (char *) "self", NULL
16874 };
16875
16876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16878 if (SWIG_arg_fail(1)) SWIG_fail;
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 delete arg1;
16882
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 Py_INCREF(Py_None); resultobj = Py_None;
16887 return resultobj;
16888 fail:
16889 return NULL;
16890 }
16891
16892
16893 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16894 PyObject *resultobj;
16895 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16896 wxConfigBase *result;
16897 PyObject * obj0 = 0 ;
16898 char *kwnames[] = {
16899 (char *) "config", NULL
16900 };
16901
16902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16904 if (SWIG_arg_fail(1)) SWIG_fail;
16905 {
16906 PyThreadState* __tstate = wxPyBeginAllowThreads();
16907 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16908
16909 wxPyEndAllowThreads(__tstate);
16910 if (PyErr_Occurred()) SWIG_fail;
16911 }
16912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16913 return resultobj;
16914 fail:
16915 return NULL;
16916 }
16917
16918
16919 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16920 PyObject *resultobj;
16921 bool arg1 = (bool) true ;
16922 wxConfigBase *result;
16923 PyObject * obj0 = 0 ;
16924 char *kwnames[] = {
16925 (char *) "createOnDemand", NULL
16926 };
16927
16928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16929 if (obj0) {
16930 {
16931 arg1 = (bool)(SWIG_As_bool(obj0));
16932 if (SWIG_arg_fail(1)) SWIG_fail;
16933 }
16934 }
16935 {
16936 PyThreadState* __tstate = wxPyBeginAllowThreads();
16937 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16938
16939 wxPyEndAllowThreads(__tstate);
16940 if (PyErr_Occurred()) SWIG_fail;
16941 }
16942 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16943 return resultobj;
16944 fail:
16945 return NULL;
16946 }
16947
16948
16949 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16950 PyObject *resultobj;
16951 wxConfigBase *result;
16952 char *kwnames[] = {
16953 NULL
16954 };
16955
16956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 result = (wxConfigBase *)wxConfigBase::Create();
16960
16961 wxPyEndAllowThreads(__tstate);
16962 if (PyErr_Occurred()) SWIG_fail;
16963 }
16964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16965 return resultobj;
16966 fail:
16967 return NULL;
16968 }
16969
16970
16971 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16972 PyObject *resultobj;
16973 char *kwnames[] = {
16974 NULL
16975 };
16976
16977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16978 {
16979 PyThreadState* __tstate = wxPyBeginAllowThreads();
16980 wxConfigBase::DontCreateOnDemand();
16981
16982 wxPyEndAllowThreads(__tstate);
16983 if (PyErr_Occurred()) SWIG_fail;
16984 }
16985 Py_INCREF(Py_None); resultobj = Py_None;
16986 return resultobj;
16987 fail:
16988 return NULL;
16989 }
16990
16991
16992 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16993 PyObject *resultobj;
16994 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16995 wxString *arg2 = 0 ;
16996 bool temp2 = false ;
16997 PyObject * obj0 = 0 ;
16998 PyObject * obj1 = 0 ;
16999 char *kwnames[] = {
17000 (char *) "self",(char *) "path", NULL
17001 };
17002
17003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17005 if (SWIG_arg_fail(1)) SWIG_fail;
17006 {
17007 arg2 = wxString_in_helper(obj1);
17008 if (arg2 == NULL) SWIG_fail;
17009 temp2 = true;
17010 }
17011 {
17012 PyThreadState* __tstate = wxPyBeginAllowThreads();
17013 (arg1)->SetPath((wxString const &)*arg2);
17014
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 Py_INCREF(Py_None); resultobj = Py_None;
17019 {
17020 if (temp2)
17021 delete arg2;
17022 }
17023 return resultobj;
17024 fail:
17025 {
17026 if (temp2)
17027 delete arg2;
17028 }
17029 return NULL;
17030 }
17031
17032
17033 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17034 PyObject *resultobj;
17035 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17036 wxString *result;
17037 PyObject * obj0 = 0 ;
17038 char *kwnames[] = {
17039 (char *) "self", NULL
17040 };
17041
17042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17044 if (SWIG_arg_fail(1)) SWIG_fail;
17045 {
17046 PyThreadState* __tstate = wxPyBeginAllowThreads();
17047 {
17048 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17049 result = (wxString *) &_result_ref;
17050 }
17051
17052 wxPyEndAllowThreads(__tstate);
17053 if (PyErr_Occurred()) SWIG_fail;
17054 }
17055 {
17056 #if wxUSE_UNICODE
17057 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17058 #else
17059 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17060 #endif
17061 }
17062 return resultobj;
17063 fail:
17064 return NULL;
17065 }
17066
17067
17068 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17069 PyObject *resultobj;
17070 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17071 PyObject *result;
17072 PyObject * obj0 = 0 ;
17073 char *kwnames[] = {
17074 (char *) "self", NULL
17075 };
17076
17077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17079 if (SWIG_arg_fail(1)) SWIG_fail;
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17083
17084 wxPyEndAllowThreads(__tstate);
17085 if (PyErr_Occurred()) SWIG_fail;
17086 }
17087 resultobj = result;
17088 return resultobj;
17089 fail:
17090 return NULL;
17091 }
17092
17093
17094 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17095 PyObject *resultobj;
17096 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17097 long arg2 ;
17098 PyObject *result;
17099 PyObject * obj0 = 0 ;
17100 PyObject * obj1 = 0 ;
17101 char *kwnames[] = {
17102 (char *) "self",(char *) "index", NULL
17103 };
17104
17105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17107 if (SWIG_arg_fail(1)) SWIG_fail;
17108 {
17109 arg2 = (long)(SWIG_As_long(obj1));
17110 if (SWIG_arg_fail(2)) SWIG_fail;
17111 }
17112 {
17113 PyThreadState* __tstate = wxPyBeginAllowThreads();
17114 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17115
17116 wxPyEndAllowThreads(__tstate);
17117 if (PyErr_Occurred()) SWIG_fail;
17118 }
17119 resultobj = result;
17120 return resultobj;
17121 fail:
17122 return NULL;
17123 }
17124
17125
17126 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17127 PyObject *resultobj;
17128 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17129 PyObject *result;
17130 PyObject * obj0 = 0 ;
17131 char *kwnames[] = {
17132 (char *) "self", NULL
17133 };
17134
17135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17137 if (SWIG_arg_fail(1)) SWIG_fail;
17138 {
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17141
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 resultobj = result;
17146 return resultobj;
17147 fail:
17148 return NULL;
17149 }
17150
17151
17152 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj;
17154 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17155 long arg2 ;
17156 PyObject *result;
17157 PyObject * obj0 = 0 ;
17158 PyObject * obj1 = 0 ;
17159 char *kwnames[] = {
17160 (char *) "self",(char *) "index", NULL
17161 };
17162
17163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17165 if (SWIG_arg_fail(1)) SWIG_fail;
17166 {
17167 arg2 = (long)(SWIG_As_long(obj1));
17168 if (SWIG_arg_fail(2)) SWIG_fail;
17169 }
17170 {
17171 PyThreadState* __tstate = wxPyBeginAllowThreads();
17172 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17173
17174 wxPyEndAllowThreads(__tstate);
17175 if (PyErr_Occurred()) SWIG_fail;
17176 }
17177 resultobj = result;
17178 return resultobj;
17179 fail:
17180 return NULL;
17181 }
17182
17183
17184 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17185 PyObject *resultobj;
17186 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17187 bool arg2 = (bool) false ;
17188 size_t result;
17189 PyObject * obj0 = 0 ;
17190 PyObject * obj1 = 0 ;
17191 char *kwnames[] = {
17192 (char *) "self",(char *) "recursive", NULL
17193 };
17194
17195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17197 if (SWIG_arg_fail(1)) SWIG_fail;
17198 if (obj1) {
17199 {
17200 arg2 = (bool)(SWIG_As_bool(obj1));
17201 if (SWIG_arg_fail(2)) SWIG_fail;
17202 }
17203 }
17204 {
17205 PyThreadState* __tstate = wxPyBeginAllowThreads();
17206 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17207
17208 wxPyEndAllowThreads(__tstate);
17209 if (PyErr_Occurred()) SWIG_fail;
17210 }
17211 {
17212 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17213 }
17214 return resultobj;
17215 fail:
17216 return NULL;
17217 }
17218
17219
17220 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17221 PyObject *resultobj;
17222 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17223 bool arg2 = (bool) false ;
17224 size_t result;
17225 PyObject * obj0 = 0 ;
17226 PyObject * obj1 = 0 ;
17227 char *kwnames[] = {
17228 (char *) "self",(char *) "recursive", NULL
17229 };
17230
17231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17233 if (SWIG_arg_fail(1)) SWIG_fail;
17234 if (obj1) {
17235 {
17236 arg2 = (bool)(SWIG_As_bool(obj1));
17237 if (SWIG_arg_fail(2)) SWIG_fail;
17238 }
17239 }
17240 {
17241 PyThreadState* __tstate = wxPyBeginAllowThreads();
17242 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17243
17244 wxPyEndAllowThreads(__tstate);
17245 if (PyErr_Occurred()) SWIG_fail;
17246 }
17247 {
17248 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17249 }
17250 return resultobj;
17251 fail:
17252 return NULL;
17253 }
17254
17255
17256 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17257 PyObject *resultobj;
17258 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17259 wxString *arg2 = 0 ;
17260 bool result;
17261 bool temp2 = false ;
17262 PyObject * obj0 = 0 ;
17263 PyObject * obj1 = 0 ;
17264 char *kwnames[] = {
17265 (char *) "self",(char *) "name", NULL
17266 };
17267
17268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) 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 {
17277 PyThreadState* __tstate = wxPyBeginAllowThreads();
17278 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17279
17280 wxPyEndAllowThreads(__tstate);
17281 if (PyErr_Occurred()) SWIG_fail;
17282 }
17283 {
17284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17285 }
17286 {
17287 if (temp2)
17288 delete arg2;
17289 }
17290 return resultobj;
17291 fail:
17292 {
17293 if (temp2)
17294 delete arg2;
17295 }
17296 return NULL;
17297 }
17298
17299
17300 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17301 PyObject *resultobj;
17302 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17303 wxString *arg2 = 0 ;
17304 bool result;
17305 bool temp2 = false ;
17306 PyObject * obj0 = 0 ;
17307 PyObject * obj1 = 0 ;
17308 char *kwnames[] = {
17309 (char *) "self",(char *) "name", NULL
17310 };
17311
17312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17314 if (SWIG_arg_fail(1)) SWIG_fail;
17315 {
17316 arg2 = wxString_in_helper(obj1);
17317 if (arg2 == NULL) SWIG_fail;
17318 temp2 = true;
17319 }
17320 {
17321 PyThreadState* __tstate = wxPyBeginAllowThreads();
17322 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17323
17324 wxPyEndAllowThreads(__tstate);
17325 if (PyErr_Occurred()) SWIG_fail;
17326 }
17327 {
17328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17329 }
17330 {
17331 if (temp2)
17332 delete arg2;
17333 }
17334 return resultobj;
17335 fail:
17336 {
17337 if (temp2)
17338 delete arg2;
17339 }
17340 return NULL;
17341 }
17342
17343
17344 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17345 PyObject *resultobj;
17346 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17347 wxString *arg2 = 0 ;
17348 bool result;
17349 bool temp2 = false ;
17350 PyObject * obj0 = 0 ;
17351 PyObject * obj1 = 0 ;
17352 char *kwnames[] = {
17353 (char *) "self",(char *) "name", NULL
17354 };
17355
17356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17358 if (SWIG_arg_fail(1)) SWIG_fail;
17359 {
17360 arg2 = wxString_in_helper(obj1);
17361 if (arg2 == NULL) SWIG_fail;
17362 temp2 = true;
17363 }
17364 {
17365 PyThreadState* __tstate = wxPyBeginAllowThreads();
17366 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17367
17368 wxPyEndAllowThreads(__tstate);
17369 if (PyErr_Occurred()) SWIG_fail;
17370 }
17371 {
17372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17373 }
17374 {
17375 if (temp2)
17376 delete arg2;
17377 }
17378 return resultobj;
17379 fail:
17380 {
17381 if (temp2)
17382 delete arg2;
17383 }
17384 return NULL;
17385 }
17386
17387
17388 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17389 PyObject *resultobj;
17390 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17391 wxString *arg2 = 0 ;
17392 wxConfigBase::EntryType result;
17393 bool temp2 = false ;
17394 PyObject * obj0 = 0 ;
17395 PyObject * obj1 = 0 ;
17396 char *kwnames[] = {
17397 (char *) "self",(char *) "name", NULL
17398 };
17399
17400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17402 if (SWIG_arg_fail(1)) SWIG_fail;
17403 {
17404 arg2 = wxString_in_helper(obj1);
17405 if (arg2 == NULL) SWIG_fail;
17406 temp2 = true;
17407 }
17408 {
17409 PyThreadState* __tstate = wxPyBeginAllowThreads();
17410 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17411
17412 wxPyEndAllowThreads(__tstate);
17413 if (PyErr_Occurred()) SWIG_fail;
17414 }
17415 resultobj = SWIG_From_int((result));
17416 {
17417 if (temp2)
17418 delete arg2;
17419 }
17420 return resultobj;
17421 fail:
17422 {
17423 if (temp2)
17424 delete arg2;
17425 }
17426 return NULL;
17427 }
17428
17429
17430 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17431 PyObject *resultobj;
17432 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17433 wxString *arg2 = 0 ;
17434 wxString const &arg3_defvalue = wxPyEmptyString ;
17435 wxString *arg3 = (wxString *) &arg3_defvalue ;
17436 wxString result;
17437 bool temp2 = false ;
17438 bool temp3 = false ;
17439 PyObject * obj0 = 0 ;
17440 PyObject * obj1 = 0 ;
17441 PyObject * obj2 = 0 ;
17442 char *kwnames[] = {
17443 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17444 };
17445
17446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17448 if (SWIG_arg_fail(1)) SWIG_fail;
17449 {
17450 arg2 = wxString_in_helper(obj1);
17451 if (arg2 == NULL) SWIG_fail;
17452 temp2 = true;
17453 }
17454 if (obj2) {
17455 {
17456 arg3 = wxString_in_helper(obj2);
17457 if (arg3 == NULL) SWIG_fail;
17458 temp3 = true;
17459 }
17460 }
17461 {
17462 PyThreadState* __tstate = wxPyBeginAllowThreads();
17463 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17464
17465 wxPyEndAllowThreads(__tstate);
17466 if (PyErr_Occurred()) SWIG_fail;
17467 }
17468 {
17469 #if wxUSE_UNICODE
17470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17471 #else
17472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17473 #endif
17474 }
17475 {
17476 if (temp2)
17477 delete arg2;
17478 }
17479 {
17480 if (temp3)
17481 delete arg3;
17482 }
17483 return resultobj;
17484 fail:
17485 {
17486 if (temp2)
17487 delete arg2;
17488 }
17489 {
17490 if (temp3)
17491 delete arg3;
17492 }
17493 return NULL;
17494 }
17495
17496
17497 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17498 PyObject *resultobj;
17499 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17500 wxString *arg2 = 0 ;
17501 long arg3 = (long) 0 ;
17502 long result;
17503 bool temp2 = false ;
17504 PyObject * obj0 = 0 ;
17505 PyObject * obj1 = 0 ;
17506 PyObject * obj2 = 0 ;
17507 char *kwnames[] = {
17508 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17509 };
17510
17511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17513 if (SWIG_arg_fail(1)) SWIG_fail;
17514 {
17515 arg2 = wxString_in_helper(obj1);
17516 if (arg2 == NULL) SWIG_fail;
17517 temp2 = true;
17518 }
17519 if (obj2) {
17520 {
17521 arg3 = (long)(SWIG_As_long(obj2));
17522 if (SWIG_arg_fail(3)) SWIG_fail;
17523 }
17524 }
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17528
17529 wxPyEndAllowThreads(__tstate);
17530 if (PyErr_Occurred()) SWIG_fail;
17531 }
17532 {
17533 resultobj = SWIG_From_long((long)(result));
17534 }
17535 {
17536 if (temp2)
17537 delete arg2;
17538 }
17539 return resultobj;
17540 fail:
17541 {
17542 if (temp2)
17543 delete arg2;
17544 }
17545 return NULL;
17546 }
17547
17548
17549 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17550 PyObject *resultobj;
17551 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17552 wxString *arg2 = 0 ;
17553 double arg3 = (double) 0.0 ;
17554 double result;
17555 bool temp2 = false ;
17556 PyObject * obj0 = 0 ;
17557 PyObject * obj1 = 0 ;
17558 PyObject * obj2 = 0 ;
17559 char *kwnames[] = {
17560 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17561 };
17562
17563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17565 if (SWIG_arg_fail(1)) SWIG_fail;
17566 {
17567 arg2 = wxString_in_helper(obj1);
17568 if (arg2 == NULL) SWIG_fail;
17569 temp2 = true;
17570 }
17571 if (obj2) {
17572 {
17573 arg3 = (double)(SWIG_As_double(obj2));
17574 if (SWIG_arg_fail(3)) SWIG_fail;
17575 }
17576 }
17577 {
17578 PyThreadState* __tstate = wxPyBeginAllowThreads();
17579 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17580
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 {
17585 resultobj = SWIG_From_double((double)(result));
17586 }
17587 {
17588 if (temp2)
17589 delete arg2;
17590 }
17591 return resultobj;
17592 fail:
17593 {
17594 if (temp2)
17595 delete arg2;
17596 }
17597 return NULL;
17598 }
17599
17600
17601 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17602 PyObject *resultobj;
17603 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17604 wxString *arg2 = 0 ;
17605 bool arg3 = (bool) false ;
17606 bool result;
17607 bool temp2 = false ;
17608 PyObject * obj0 = 0 ;
17609 PyObject * obj1 = 0 ;
17610 PyObject * obj2 = 0 ;
17611 char *kwnames[] = {
17612 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17613 };
17614
17615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17617 if (SWIG_arg_fail(1)) SWIG_fail;
17618 {
17619 arg2 = wxString_in_helper(obj1);
17620 if (arg2 == NULL) SWIG_fail;
17621 temp2 = true;
17622 }
17623 if (obj2) {
17624 {
17625 arg3 = (bool)(SWIG_As_bool(obj2));
17626 if (SWIG_arg_fail(3)) SWIG_fail;
17627 }
17628 }
17629 {
17630 PyThreadState* __tstate = wxPyBeginAllowThreads();
17631 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17632
17633 wxPyEndAllowThreads(__tstate);
17634 if (PyErr_Occurred()) SWIG_fail;
17635 }
17636 {
17637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17638 }
17639 {
17640 if (temp2)
17641 delete arg2;
17642 }
17643 return resultobj;
17644 fail:
17645 {
17646 if (temp2)
17647 delete arg2;
17648 }
17649 return NULL;
17650 }
17651
17652
17653 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj;
17655 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17656 wxString *arg2 = 0 ;
17657 wxString *arg3 = 0 ;
17658 bool result;
17659 bool temp2 = false ;
17660 bool temp3 = false ;
17661 PyObject * obj0 = 0 ;
17662 PyObject * obj1 = 0 ;
17663 PyObject * obj2 = 0 ;
17664 char *kwnames[] = {
17665 (char *) "self",(char *) "key",(char *) "value", NULL
17666 };
17667
17668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17670 if (SWIG_arg_fail(1)) SWIG_fail;
17671 {
17672 arg2 = wxString_in_helper(obj1);
17673 if (arg2 == NULL) SWIG_fail;
17674 temp2 = true;
17675 }
17676 {
17677 arg3 = wxString_in_helper(obj2);
17678 if (arg3 == NULL) SWIG_fail;
17679 temp3 = true;
17680 }
17681 {
17682 PyThreadState* __tstate = wxPyBeginAllowThreads();
17683 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17684
17685 wxPyEndAllowThreads(__tstate);
17686 if (PyErr_Occurred()) SWIG_fail;
17687 }
17688 {
17689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17690 }
17691 {
17692 if (temp2)
17693 delete arg2;
17694 }
17695 {
17696 if (temp3)
17697 delete arg3;
17698 }
17699 return resultobj;
17700 fail:
17701 {
17702 if (temp2)
17703 delete arg2;
17704 }
17705 {
17706 if (temp3)
17707 delete arg3;
17708 }
17709 return NULL;
17710 }
17711
17712
17713 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17714 PyObject *resultobj;
17715 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17716 wxString *arg2 = 0 ;
17717 long arg3 ;
17718 bool result;
17719 bool temp2 = false ;
17720 PyObject * obj0 = 0 ;
17721 PyObject * obj1 = 0 ;
17722 PyObject * obj2 = 0 ;
17723 char *kwnames[] = {
17724 (char *) "self",(char *) "key",(char *) "value", NULL
17725 };
17726
17727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17729 if (SWIG_arg_fail(1)) SWIG_fail;
17730 {
17731 arg2 = wxString_in_helper(obj1);
17732 if (arg2 == NULL) SWIG_fail;
17733 temp2 = true;
17734 }
17735 {
17736 arg3 = (long)(SWIG_As_long(obj2));
17737 if (SWIG_arg_fail(3)) SWIG_fail;
17738 }
17739 {
17740 PyThreadState* __tstate = wxPyBeginAllowThreads();
17741 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17742
17743 wxPyEndAllowThreads(__tstate);
17744 if (PyErr_Occurred()) SWIG_fail;
17745 }
17746 {
17747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17748 }
17749 {
17750 if (temp2)
17751 delete arg2;
17752 }
17753 return resultobj;
17754 fail:
17755 {
17756 if (temp2)
17757 delete arg2;
17758 }
17759 return NULL;
17760 }
17761
17762
17763 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj;
17765 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17766 wxString *arg2 = 0 ;
17767 double arg3 ;
17768 bool result;
17769 bool temp2 = false ;
17770 PyObject * obj0 = 0 ;
17771 PyObject * obj1 = 0 ;
17772 PyObject * obj2 = 0 ;
17773 char *kwnames[] = {
17774 (char *) "self",(char *) "key",(char *) "value", NULL
17775 };
17776
17777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17779 if (SWIG_arg_fail(1)) SWIG_fail;
17780 {
17781 arg2 = wxString_in_helper(obj1);
17782 if (arg2 == NULL) SWIG_fail;
17783 temp2 = true;
17784 }
17785 {
17786 arg3 = (double)(SWIG_As_double(obj2));
17787 if (SWIG_arg_fail(3)) SWIG_fail;
17788 }
17789 {
17790 PyThreadState* __tstate = wxPyBeginAllowThreads();
17791 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17792
17793 wxPyEndAllowThreads(__tstate);
17794 if (PyErr_Occurred()) SWIG_fail;
17795 }
17796 {
17797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17798 }
17799 {
17800 if (temp2)
17801 delete arg2;
17802 }
17803 return resultobj;
17804 fail:
17805 {
17806 if (temp2)
17807 delete arg2;
17808 }
17809 return NULL;
17810 }
17811
17812
17813 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17814 PyObject *resultobj;
17815 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17816 wxString *arg2 = 0 ;
17817 bool arg3 ;
17818 bool result;
17819 bool temp2 = false ;
17820 PyObject * obj0 = 0 ;
17821 PyObject * obj1 = 0 ;
17822 PyObject * obj2 = 0 ;
17823 char *kwnames[] = {
17824 (char *) "self",(char *) "key",(char *) "value", NULL
17825 };
17826
17827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17829 if (SWIG_arg_fail(1)) SWIG_fail;
17830 {
17831 arg2 = wxString_in_helper(obj1);
17832 if (arg2 == NULL) SWIG_fail;
17833 temp2 = true;
17834 }
17835 {
17836 arg3 = (bool)(SWIG_As_bool(obj2));
17837 if (SWIG_arg_fail(3)) SWIG_fail;
17838 }
17839 {
17840 PyThreadState* __tstate = wxPyBeginAllowThreads();
17841 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17842
17843 wxPyEndAllowThreads(__tstate);
17844 if (PyErr_Occurred()) SWIG_fail;
17845 }
17846 {
17847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17848 }
17849 {
17850 if (temp2)
17851 delete arg2;
17852 }
17853 return resultobj;
17854 fail:
17855 {
17856 if (temp2)
17857 delete arg2;
17858 }
17859 return NULL;
17860 }
17861
17862
17863 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17864 PyObject *resultobj;
17865 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17866 bool arg2 = (bool) false ;
17867 bool result;
17868 PyObject * obj0 = 0 ;
17869 PyObject * obj1 = 0 ;
17870 char *kwnames[] = {
17871 (char *) "self",(char *) "currentOnly", NULL
17872 };
17873
17874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17876 if (SWIG_arg_fail(1)) SWIG_fail;
17877 if (obj1) {
17878 {
17879 arg2 = (bool)(SWIG_As_bool(obj1));
17880 if (SWIG_arg_fail(2)) SWIG_fail;
17881 }
17882 }
17883 {
17884 PyThreadState* __tstate = wxPyBeginAllowThreads();
17885 result = (bool)(arg1)->Flush(arg2);
17886
17887 wxPyEndAllowThreads(__tstate);
17888 if (PyErr_Occurred()) SWIG_fail;
17889 }
17890 {
17891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17892 }
17893 return resultobj;
17894 fail:
17895 return NULL;
17896 }
17897
17898
17899 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17900 PyObject *resultobj;
17901 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17902 wxString *arg2 = 0 ;
17903 wxString *arg3 = 0 ;
17904 bool result;
17905 bool temp2 = false ;
17906 bool temp3 = false ;
17907 PyObject * obj0 = 0 ;
17908 PyObject * obj1 = 0 ;
17909 PyObject * obj2 = 0 ;
17910 char *kwnames[] = {
17911 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17912 };
17913
17914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17916 if (SWIG_arg_fail(1)) SWIG_fail;
17917 {
17918 arg2 = wxString_in_helper(obj1);
17919 if (arg2 == NULL) SWIG_fail;
17920 temp2 = true;
17921 }
17922 {
17923 arg3 = wxString_in_helper(obj2);
17924 if (arg3 == NULL) SWIG_fail;
17925 temp3 = true;
17926 }
17927 {
17928 PyThreadState* __tstate = wxPyBeginAllowThreads();
17929 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17930
17931 wxPyEndAllowThreads(__tstate);
17932 if (PyErr_Occurred()) SWIG_fail;
17933 }
17934 {
17935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17936 }
17937 {
17938 if (temp2)
17939 delete arg2;
17940 }
17941 {
17942 if (temp3)
17943 delete arg3;
17944 }
17945 return resultobj;
17946 fail:
17947 {
17948 if (temp2)
17949 delete arg2;
17950 }
17951 {
17952 if (temp3)
17953 delete arg3;
17954 }
17955 return NULL;
17956 }
17957
17958
17959 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj;
17961 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17962 wxString *arg2 = 0 ;
17963 wxString *arg3 = 0 ;
17964 bool result;
17965 bool temp2 = false ;
17966 bool temp3 = false ;
17967 PyObject * obj0 = 0 ;
17968 PyObject * obj1 = 0 ;
17969 PyObject * obj2 = 0 ;
17970 char *kwnames[] = {
17971 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17972 };
17973
17974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17976 if (SWIG_arg_fail(1)) SWIG_fail;
17977 {
17978 arg2 = wxString_in_helper(obj1);
17979 if (arg2 == NULL) SWIG_fail;
17980 temp2 = true;
17981 }
17982 {
17983 arg3 = wxString_in_helper(obj2);
17984 if (arg3 == NULL) SWIG_fail;
17985 temp3 = true;
17986 }
17987 {
17988 PyThreadState* __tstate = wxPyBeginAllowThreads();
17989 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17990
17991 wxPyEndAllowThreads(__tstate);
17992 if (PyErr_Occurred()) SWIG_fail;
17993 }
17994 {
17995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17996 }
17997 {
17998 if (temp2)
17999 delete arg2;
18000 }
18001 {
18002 if (temp3)
18003 delete arg3;
18004 }
18005 return resultobj;
18006 fail:
18007 {
18008 if (temp2)
18009 delete arg2;
18010 }
18011 {
18012 if (temp3)
18013 delete arg3;
18014 }
18015 return NULL;
18016 }
18017
18018
18019 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18020 PyObject *resultobj;
18021 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18022 wxString *arg2 = 0 ;
18023 bool arg3 = (bool) true ;
18024 bool result;
18025 bool temp2 = false ;
18026 PyObject * obj0 = 0 ;
18027 PyObject * obj1 = 0 ;
18028 PyObject * obj2 = 0 ;
18029 char *kwnames[] = {
18030 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18031 };
18032
18033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18035 if (SWIG_arg_fail(1)) SWIG_fail;
18036 {
18037 arg2 = wxString_in_helper(obj1);
18038 if (arg2 == NULL) SWIG_fail;
18039 temp2 = true;
18040 }
18041 if (obj2) {
18042 {
18043 arg3 = (bool)(SWIG_As_bool(obj2));
18044 if (SWIG_arg_fail(3)) SWIG_fail;
18045 }
18046 }
18047 {
18048 PyThreadState* __tstate = wxPyBeginAllowThreads();
18049 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18050
18051 wxPyEndAllowThreads(__tstate);
18052 if (PyErr_Occurred()) SWIG_fail;
18053 }
18054 {
18055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18056 }
18057 {
18058 if (temp2)
18059 delete arg2;
18060 }
18061 return resultobj;
18062 fail:
18063 {
18064 if (temp2)
18065 delete arg2;
18066 }
18067 return NULL;
18068 }
18069
18070
18071 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18072 PyObject *resultobj;
18073 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18074 wxString *arg2 = 0 ;
18075 bool result;
18076 bool temp2 = false ;
18077 PyObject * obj0 = 0 ;
18078 PyObject * obj1 = 0 ;
18079 char *kwnames[] = {
18080 (char *) "self",(char *) "key", NULL
18081 };
18082
18083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18085 if (SWIG_arg_fail(1)) SWIG_fail;
18086 {
18087 arg2 = wxString_in_helper(obj1);
18088 if (arg2 == NULL) SWIG_fail;
18089 temp2 = true;
18090 }
18091 {
18092 PyThreadState* __tstate = wxPyBeginAllowThreads();
18093 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18094
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
18097 }
18098 {
18099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18100 }
18101 {
18102 if (temp2)
18103 delete arg2;
18104 }
18105 return resultobj;
18106 fail:
18107 {
18108 if (temp2)
18109 delete arg2;
18110 }
18111 return NULL;
18112 }
18113
18114
18115 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18116 PyObject *resultobj;
18117 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18118 bool result;
18119 PyObject * obj0 = 0 ;
18120 char *kwnames[] = {
18121 (char *) "self", NULL
18122 };
18123
18124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18126 if (SWIG_arg_fail(1)) SWIG_fail;
18127 {
18128 PyThreadState* __tstate = wxPyBeginAllowThreads();
18129 result = (bool)(arg1)->DeleteAll();
18130
18131 wxPyEndAllowThreads(__tstate);
18132 if (PyErr_Occurred()) SWIG_fail;
18133 }
18134 {
18135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18136 }
18137 return resultobj;
18138 fail:
18139 return NULL;
18140 }
18141
18142
18143 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18144 PyObject *resultobj;
18145 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18146 bool arg2 = (bool) true ;
18147 PyObject * obj0 = 0 ;
18148 PyObject * obj1 = 0 ;
18149 char *kwnames[] = {
18150 (char *) "self",(char *) "doIt", NULL
18151 };
18152
18153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18155 if (SWIG_arg_fail(1)) SWIG_fail;
18156 if (obj1) {
18157 {
18158 arg2 = (bool)(SWIG_As_bool(obj1));
18159 if (SWIG_arg_fail(2)) SWIG_fail;
18160 }
18161 }
18162 {
18163 PyThreadState* __tstate = wxPyBeginAllowThreads();
18164 (arg1)->SetExpandEnvVars(arg2);
18165
18166 wxPyEndAllowThreads(__tstate);
18167 if (PyErr_Occurred()) SWIG_fail;
18168 }
18169 Py_INCREF(Py_None); resultobj = Py_None;
18170 return resultobj;
18171 fail:
18172 return NULL;
18173 }
18174
18175
18176 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18177 PyObject *resultobj;
18178 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18179 bool result;
18180 PyObject * obj0 = 0 ;
18181 char *kwnames[] = {
18182 (char *) "self", NULL
18183 };
18184
18185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18187 if (SWIG_arg_fail(1)) SWIG_fail;
18188 {
18189 PyThreadState* __tstate = wxPyBeginAllowThreads();
18190 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18191
18192 wxPyEndAllowThreads(__tstate);
18193 if (PyErr_Occurred()) SWIG_fail;
18194 }
18195 {
18196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18197 }
18198 return resultobj;
18199 fail:
18200 return NULL;
18201 }
18202
18203
18204 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18205 PyObject *resultobj;
18206 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18207 bool arg2 = (bool) true ;
18208 PyObject * obj0 = 0 ;
18209 PyObject * obj1 = 0 ;
18210 char *kwnames[] = {
18211 (char *) "self",(char *) "doIt", NULL
18212 };
18213
18214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18216 if (SWIG_arg_fail(1)) SWIG_fail;
18217 if (obj1) {
18218 {
18219 arg2 = (bool)(SWIG_As_bool(obj1));
18220 if (SWIG_arg_fail(2)) SWIG_fail;
18221 }
18222 }
18223 {
18224 PyThreadState* __tstate = wxPyBeginAllowThreads();
18225 (arg1)->SetRecordDefaults(arg2);
18226
18227 wxPyEndAllowThreads(__tstate);
18228 if (PyErr_Occurred()) SWIG_fail;
18229 }
18230 Py_INCREF(Py_None); resultobj = Py_None;
18231 return resultobj;
18232 fail:
18233 return NULL;
18234 }
18235
18236
18237 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18238 PyObject *resultobj;
18239 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18240 bool result;
18241 PyObject * obj0 = 0 ;
18242 char *kwnames[] = {
18243 (char *) "self", NULL
18244 };
18245
18246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18248 if (SWIG_arg_fail(1)) SWIG_fail;
18249 {
18250 PyThreadState* __tstate = wxPyBeginAllowThreads();
18251 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18252
18253 wxPyEndAllowThreads(__tstate);
18254 if (PyErr_Occurred()) SWIG_fail;
18255 }
18256 {
18257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18258 }
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18266 PyObject *resultobj;
18267 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18268 wxString *arg2 = 0 ;
18269 wxString result;
18270 bool temp2 = false ;
18271 PyObject * obj0 = 0 ;
18272 PyObject * obj1 = 0 ;
18273 char *kwnames[] = {
18274 (char *) "self",(char *) "str", NULL
18275 };
18276
18277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18279 if (SWIG_arg_fail(1)) SWIG_fail;
18280 {
18281 arg2 = wxString_in_helper(obj1);
18282 if (arg2 == NULL) SWIG_fail;
18283 temp2 = true;
18284 }
18285 {
18286 PyThreadState* __tstate = wxPyBeginAllowThreads();
18287 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18288
18289 wxPyEndAllowThreads(__tstate);
18290 if (PyErr_Occurred()) SWIG_fail;
18291 }
18292 {
18293 #if wxUSE_UNICODE
18294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18295 #else
18296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18297 #endif
18298 }
18299 {
18300 if (temp2)
18301 delete arg2;
18302 }
18303 return resultobj;
18304 fail:
18305 {
18306 if (temp2)
18307 delete arg2;
18308 }
18309 return NULL;
18310 }
18311
18312
18313 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18314 PyObject *resultobj;
18315 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18316 wxString result;
18317 PyObject * obj0 = 0 ;
18318 char *kwnames[] = {
18319 (char *) "self", NULL
18320 };
18321
18322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18324 if (SWIG_arg_fail(1)) SWIG_fail;
18325 {
18326 PyThreadState* __tstate = wxPyBeginAllowThreads();
18327 result = ((wxConfigBase const *)arg1)->GetAppName();
18328
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 {
18333 #if wxUSE_UNICODE
18334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18335 #else
18336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18337 #endif
18338 }
18339 return resultobj;
18340 fail:
18341 return NULL;
18342 }
18343
18344
18345 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18346 PyObject *resultobj;
18347 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18348 wxString result;
18349 PyObject * obj0 = 0 ;
18350 char *kwnames[] = {
18351 (char *) "self", NULL
18352 };
18353
18354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18356 if (SWIG_arg_fail(1)) SWIG_fail;
18357 {
18358 PyThreadState* __tstate = wxPyBeginAllowThreads();
18359 result = ((wxConfigBase const *)arg1)->GetVendorName();
18360
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 {
18365 #if wxUSE_UNICODE
18366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18367 #else
18368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18369 #endif
18370 }
18371 return resultobj;
18372 fail:
18373 return NULL;
18374 }
18375
18376
18377 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18378 PyObject *resultobj;
18379 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18380 wxString *arg2 = 0 ;
18381 bool temp2 = false ;
18382 PyObject * obj0 = 0 ;
18383 PyObject * obj1 = 0 ;
18384 char *kwnames[] = {
18385 (char *) "self",(char *) "appName", NULL
18386 };
18387
18388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18390 if (SWIG_arg_fail(1)) SWIG_fail;
18391 {
18392 arg2 = wxString_in_helper(obj1);
18393 if (arg2 == NULL) SWIG_fail;
18394 temp2 = true;
18395 }
18396 {
18397 PyThreadState* __tstate = wxPyBeginAllowThreads();
18398 (arg1)->SetAppName((wxString const &)*arg2);
18399
18400 wxPyEndAllowThreads(__tstate);
18401 if (PyErr_Occurred()) SWIG_fail;
18402 }
18403 Py_INCREF(Py_None); resultobj = Py_None;
18404 {
18405 if (temp2)
18406 delete arg2;
18407 }
18408 return resultobj;
18409 fail:
18410 {
18411 if (temp2)
18412 delete arg2;
18413 }
18414 return NULL;
18415 }
18416
18417
18418 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj;
18420 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18421 wxString *arg2 = 0 ;
18422 bool temp2 = false ;
18423 PyObject * obj0 = 0 ;
18424 PyObject * obj1 = 0 ;
18425 char *kwnames[] = {
18426 (char *) "self",(char *) "vendorName", NULL
18427 };
18428
18429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18431 if (SWIG_arg_fail(1)) SWIG_fail;
18432 {
18433 arg2 = wxString_in_helper(obj1);
18434 if (arg2 == NULL) SWIG_fail;
18435 temp2 = true;
18436 }
18437 {
18438 PyThreadState* __tstate = wxPyBeginAllowThreads();
18439 (arg1)->SetVendorName((wxString const &)*arg2);
18440
18441 wxPyEndAllowThreads(__tstate);
18442 if (PyErr_Occurred()) SWIG_fail;
18443 }
18444 Py_INCREF(Py_None); resultobj = Py_None;
18445 {
18446 if (temp2)
18447 delete arg2;
18448 }
18449 return resultobj;
18450 fail:
18451 {
18452 if (temp2)
18453 delete arg2;
18454 }
18455 return NULL;
18456 }
18457
18458
18459 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18460 PyObject *resultobj;
18461 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18462 long arg2 ;
18463 PyObject * obj0 = 0 ;
18464 PyObject * obj1 = 0 ;
18465 char *kwnames[] = {
18466 (char *) "self",(char *) "style", NULL
18467 };
18468
18469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18471 if (SWIG_arg_fail(1)) SWIG_fail;
18472 {
18473 arg2 = (long)(SWIG_As_long(obj1));
18474 if (SWIG_arg_fail(2)) SWIG_fail;
18475 }
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 (arg1)->SetStyle(arg2);
18479
18480 wxPyEndAllowThreads(__tstate);
18481 if (PyErr_Occurred()) SWIG_fail;
18482 }
18483 Py_INCREF(Py_None); resultobj = Py_None;
18484 return resultobj;
18485 fail:
18486 return NULL;
18487 }
18488
18489
18490 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18491 PyObject *resultobj;
18492 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18493 long result;
18494 PyObject * obj0 = 0 ;
18495 char *kwnames[] = {
18496 (char *) "self", NULL
18497 };
18498
18499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18501 if (SWIG_arg_fail(1)) SWIG_fail;
18502 {
18503 PyThreadState* __tstate = wxPyBeginAllowThreads();
18504 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18505
18506 wxPyEndAllowThreads(__tstate);
18507 if (PyErr_Occurred()) SWIG_fail;
18508 }
18509 {
18510 resultobj = SWIG_From_long((long)(result));
18511 }
18512 return resultobj;
18513 fail:
18514 return NULL;
18515 }
18516
18517
18518 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18519 PyObject *obj;
18520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18521 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18522 Py_INCREF(obj);
18523 return Py_BuildValue((char *)"");
18524 }
18525 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18526 PyObject *resultobj;
18527 wxString const &arg1_defvalue = wxPyEmptyString ;
18528 wxString *arg1 = (wxString *) &arg1_defvalue ;
18529 wxString const &arg2_defvalue = wxPyEmptyString ;
18530 wxString *arg2 = (wxString *) &arg2_defvalue ;
18531 wxString const &arg3_defvalue = wxPyEmptyString ;
18532 wxString *arg3 = (wxString *) &arg3_defvalue ;
18533 wxString const &arg4_defvalue = wxPyEmptyString ;
18534 wxString *arg4 = (wxString *) &arg4_defvalue ;
18535 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18536 wxConfig *result;
18537 bool temp1 = false ;
18538 bool temp2 = false ;
18539 bool temp3 = false ;
18540 bool temp4 = false ;
18541 PyObject * obj0 = 0 ;
18542 PyObject * obj1 = 0 ;
18543 PyObject * obj2 = 0 ;
18544 PyObject * obj3 = 0 ;
18545 PyObject * obj4 = 0 ;
18546 char *kwnames[] = {
18547 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18548 };
18549
18550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18551 if (obj0) {
18552 {
18553 arg1 = wxString_in_helper(obj0);
18554 if (arg1 == NULL) SWIG_fail;
18555 temp1 = true;
18556 }
18557 }
18558 if (obj1) {
18559 {
18560 arg2 = wxString_in_helper(obj1);
18561 if (arg2 == NULL) SWIG_fail;
18562 temp2 = true;
18563 }
18564 }
18565 if (obj2) {
18566 {
18567 arg3 = wxString_in_helper(obj2);
18568 if (arg3 == NULL) SWIG_fail;
18569 temp3 = true;
18570 }
18571 }
18572 if (obj3) {
18573 {
18574 arg4 = wxString_in_helper(obj3);
18575 if (arg4 == NULL) SWIG_fail;
18576 temp4 = true;
18577 }
18578 }
18579 if (obj4) {
18580 {
18581 arg5 = (long)(SWIG_As_long(obj4));
18582 if (SWIG_arg_fail(5)) SWIG_fail;
18583 }
18584 }
18585 {
18586 PyThreadState* __tstate = wxPyBeginAllowThreads();
18587 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18588
18589 wxPyEndAllowThreads(__tstate);
18590 if (PyErr_Occurred()) SWIG_fail;
18591 }
18592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18593 {
18594 if (temp1)
18595 delete arg1;
18596 }
18597 {
18598 if (temp2)
18599 delete arg2;
18600 }
18601 {
18602 if (temp3)
18603 delete arg3;
18604 }
18605 {
18606 if (temp4)
18607 delete arg4;
18608 }
18609 return resultobj;
18610 fail:
18611 {
18612 if (temp1)
18613 delete arg1;
18614 }
18615 {
18616 if (temp2)
18617 delete arg2;
18618 }
18619 {
18620 if (temp3)
18621 delete arg3;
18622 }
18623 {
18624 if (temp4)
18625 delete arg4;
18626 }
18627 return NULL;
18628 }
18629
18630
18631 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18632 PyObject *resultobj;
18633 wxConfig *arg1 = (wxConfig *) 0 ;
18634 PyObject * obj0 = 0 ;
18635 char *kwnames[] = {
18636 (char *) "self", NULL
18637 };
18638
18639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18641 if (SWIG_arg_fail(1)) SWIG_fail;
18642 {
18643 PyThreadState* __tstate = wxPyBeginAllowThreads();
18644 delete arg1;
18645
18646 wxPyEndAllowThreads(__tstate);
18647 if (PyErr_Occurred()) SWIG_fail;
18648 }
18649 Py_INCREF(Py_None); resultobj = Py_None;
18650 return resultobj;
18651 fail:
18652 return NULL;
18653 }
18654
18655
18656 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18657 PyObject *obj;
18658 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18659 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18660 Py_INCREF(obj);
18661 return Py_BuildValue((char *)"");
18662 }
18663 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18664 PyObject *resultobj;
18665 wxString const &arg1_defvalue = wxPyEmptyString ;
18666 wxString *arg1 = (wxString *) &arg1_defvalue ;
18667 wxString const &arg2_defvalue = wxPyEmptyString ;
18668 wxString *arg2 = (wxString *) &arg2_defvalue ;
18669 wxString const &arg3_defvalue = wxPyEmptyString ;
18670 wxString *arg3 = (wxString *) &arg3_defvalue ;
18671 wxString const &arg4_defvalue = wxPyEmptyString ;
18672 wxString *arg4 = (wxString *) &arg4_defvalue ;
18673 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18674 wxFileConfig *result;
18675 bool temp1 = false ;
18676 bool temp2 = false ;
18677 bool temp3 = false ;
18678 bool temp4 = false ;
18679 PyObject * obj0 = 0 ;
18680 PyObject * obj1 = 0 ;
18681 PyObject * obj2 = 0 ;
18682 PyObject * obj3 = 0 ;
18683 PyObject * obj4 = 0 ;
18684 char *kwnames[] = {
18685 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18686 };
18687
18688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18689 if (obj0) {
18690 {
18691 arg1 = wxString_in_helper(obj0);
18692 if (arg1 == NULL) SWIG_fail;
18693 temp1 = true;
18694 }
18695 }
18696 if (obj1) {
18697 {
18698 arg2 = wxString_in_helper(obj1);
18699 if (arg2 == NULL) SWIG_fail;
18700 temp2 = true;
18701 }
18702 }
18703 if (obj2) {
18704 {
18705 arg3 = wxString_in_helper(obj2);
18706 if (arg3 == NULL) SWIG_fail;
18707 temp3 = true;
18708 }
18709 }
18710 if (obj3) {
18711 {
18712 arg4 = wxString_in_helper(obj3);
18713 if (arg4 == NULL) SWIG_fail;
18714 temp4 = true;
18715 }
18716 }
18717 if (obj4) {
18718 {
18719 arg5 = (long)(SWIG_As_long(obj4));
18720 if (SWIG_arg_fail(5)) SWIG_fail;
18721 }
18722 }
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18726
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18731 {
18732 if (temp1)
18733 delete arg1;
18734 }
18735 {
18736 if (temp2)
18737 delete arg2;
18738 }
18739 {
18740 if (temp3)
18741 delete arg3;
18742 }
18743 {
18744 if (temp4)
18745 delete arg4;
18746 }
18747 return resultobj;
18748 fail:
18749 {
18750 if (temp1)
18751 delete arg1;
18752 }
18753 {
18754 if (temp2)
18755 delete arg2;
18756 }
18757 {
18758 if (temp3)
18759 delete arg3;
18760 }
18761 {
18762 if (temp4)
18763 delete arg4;
18764 }
18765 return NULL;
18766 }
18767
18768
18769 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18770 PyObject *resultobj;
18771 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18772 PyObject * obj0 = 0 ;
18773 char *kwnames[] = {
18774 (char *) "self", NULL
18775 };
18776
18777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18779 if (SWIG_arg_fail(1)) SWIG_fail;
18780 {
18781 PyThreadState* __tstate = wxPyBeginAllowThreads();
18782 delete arg1;
18783
18784 wxPyEndAllowThreads(__tstate);
18785 if (PyErr_Occurred()) SWIG_fail;
18786 }
18787 Py_INCREF(Py_None); resultobj = Py_None;
18788 return resultobj;
18789 fail:
18790 return NULL;
18791 }
18792
18793
18794 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18795 PyObject *obj;
18796 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18797 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18798 Py_INCREF(obj);
18799 return Py_BuildValue((char *)"");
18800 }
18801 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18802 PyObject *resultobj;
18803 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18804 wxString *arg2 = 0 ;
18805 wxConfigPathChanger *result;
18806 bool temp2 = false ;
18807 PyObject * obj0 = 0 ;
18808 PyObject * obj1 = 0 ;
18809 char *kwnames[] = {
18810 (char *) "config",(char *) "entry", NULL
18811 };
18812
18813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18815 if (SWIG_arg_fail(1)) SWIG_fail;
18816 {
18817 arg2 = wxString_in_helper(obj1);
18818 if (arg2 == NULL) SWIG_fail;
18819 temp2 = true;
18820 }
18821 {
18822 PyThreadState* __tstate = wxPyBeginAllowThreads();
18823 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18824
18825 wxPyEndAllowThreads(__tstate);
18826 if (PyErr_Occurred()) SWIG_fail;
18827 }
18828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18829 {
18830 if (temp2)
18831 delete arg2;
18832 }
18833 return resultobj;
18834 fail:
18835 {
18836 if (temp2)
18837 delete arg2;
18838 }
18839 return NULL;
18840 }
18841
18842
18843 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj;
18845 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18846 PyObject * obj0 = 0 ;
18847 char *kwnames[] = {
18848 (char *) "self", NULL
18849 };
18850
18851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18853 if (SWIG_arg_fail(1)) SWIG_fail;
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 delete arg1;
18857
18858 wxPyEndAllowThreads(__tstate);
18859 if (PyErr_Occurred()) SWIG_fail;
18860 }
18861 Py_INCREF(Py_None); resultobj = Py_None;
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18869 PyObject *resultobj;
18870 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18871 wxString *result;
18872 PyObject * obj0 = 0 ;
18873 char *kwnames[] = {
18874 (char *) "self", NULL
18875 };
18876
18877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18879 if (SWIG_arg_fail(1)) SWIG_fail;
18880 {
18881 PyThreadState* __tstate = wxPyBeginAllowThreads();
18882 {
18883 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18884 result = (wxString *) &_result_ref;
18885 }
18886
18887 wxPyEndAllowThreads(__tstate);
18888 if (PyErr_Occurred()) SWIG_fail;
18889 }
18890 {
18891 #if wxUSE_UNICODE
18892 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18893 #else
18894 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18895 #endif
18896 }
18897 return resultobj;
18898 fail:
18899 return NULL;
18900 }
18901
18902
18903 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18904 PyObject *obj;
18905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18906 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18907 Py_INCREF(obj);
18908 return Py_BuildValue((char *)"");
18909 }
18910 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj;
18912 wxString *arg1 = 0 ;
18913 wxString result;
18914 bool temp1 = false ;
18915 PyObject * obj0 = 0 ;
18916 char *kwnames[] = {
18917 (char *) "sz", NULL
18918 };
18919
18920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18921 {
18922 arg1 = wxString_in_helper(obj0);
18923 if (arg1 == NULL) SWIG_fail;
18924 temp1 = true;
18925 }
18926 {
18927 PyThreadState* __tstate = wxPyBeginAllowThreads();
18928 result = wxExpandEnvVars((wxString const &)*arg1);
18929
18930 wxPyEndAllowThreads(__tstate);
18931 if (PyErr_Occurred()) SWIG_fail;
18932 }
18933 {
18934 #if wxUSE_UNICODE
18935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18936 #else
18937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18938 #endif
18939 }
18940 {
18941 if (temp1)
18942 delete arg1;
18943 }
18944 return resultobj;
18945 fail:
18946 {
18947 if (temp1)
18948 delete arg1;
18949 }
18950 return NULL;
18951 }
18952
18953
18954 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18955 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18956 return 1;
18957 }
18958
18959
18960 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18961 PyObject *pyobj;
18962
18963 {
18964 #if wxUSE_UNICODE
18965 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18966 #else
18967 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18968 #endif
18969 }
18970 return pyobj;
18971 }
18972
18973
18974 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18975 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18976 return 1;
18977 }
18978
18979
18980 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18981 PyObject *pyobj;
18982
18983 {
18984 #if wxUSE_UNICODE
18985 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18986 #else
18987 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18988 #endif
18989 }
18990 return pyobj;
18991 }
18992
18993
18994 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18995 PyObject *resultobj;
18996 wxDateTime::Country arg1 ;
18997 PyObject * obj0 = 0 ;
18998 char *kwnames[] = {
18999 (char *) "country", NULL
19000 };
19001
19002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19003 {
19004 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19005 if (SWIG_arg_fail(1)) SWIG_fail;
19006 }
19007 {
19008 PyThreadState* __tstate = wxPyBeginAllowThreads();
19009 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19010
19011 wxPyEndAllowThreads(__tstate);
19012 if (PyErr_Occurred()) SWIG_fail;
19013 }
19014 Py_INCREF(Py_None); resultobj = Py_None;
19015 return resultobj;
19016 fail:
19017 return NULL;
19018 }
19019
19020
19021 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19022 PyObject *resultobj;
19023 wxDateTime::Country result;
19024 char *kwnames[] = {
19025 NULL
19026 };
19027
19028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19029 {
19030 PyThreadState* __tstate = wxPyBeginAllowThreads();
19031 result = (wxDateTime::Country)wxDateTime::GetCountry();
19032
19033 wxPyEndAllowThreads(__tstate);
19034 if (PyErr_Occurred()) SWIG_fail;
19035 }
19036 resultobj = SWIG_From_int((result));
19037 return resultobj;
19038 fail:
19039 return NULL;
19040 }
19041
19042
19043 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19044 PyObject *resultobj;
19045 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19046 bool result;
19047 PyObject * obj0 = 0 ;
19048 char *kwnames[] = {
19049 (char *) "country", NULL
19050 };
19051
19052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19053 if (obj0) {
19054 {
19055 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19056 if (SWIG_arg_fail(1)) SWIG_fail;
19057 }
19058 }
19059 {
19060 PyThreadState* __tstate = wxPyBeginAllowThreads();
19061 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19062
19063 wxPyEndAllowThreads(__tstate);
19064 if (PyErr_Occurred()) SWIG_fail;
19065 }
19066 {
19067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19068 }
19069 return resultobj;
19070 fail:
19071 return NULL;
19072 }
19073
19074
19075 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19076 PyObject *resultobj;
19077 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19078 int result;
19079 PyObject * obj0 = 0 ;
19080 char *kwnames[] = {
19081 (char *) "cal", NULL
19082 };
19083
19084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19085 if (obj0) {
19086 {
19087 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19088 if (SWIG_arg_fail(1)) SWIG_fail;
19089 }
19090 }
19091 {
19092 PyThreadState* __tstate = wxPyBeginAllowThreads();
19093 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19094
19095 wxPyEndAllowThreads(__tstate);
19096 if (PyErr_Occurred()) SWIG_fail;
19097 }
19098 {
19099 resultobj = SWIG_From_int((int)(result));
19100 }
19101 return resultobj;
19102 fail:
19103 return NULL;
19104 }
19105
19106
19107 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19108 PyObject *resultobj;
19109 int arg1 ;
19110 int result;
19111 PyObject * obj0 = 0 ;
19112 char *kwnames[] = {
19113 (char *) "year", NULL
19114 };
19115
19116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19117 {
19118 arg1 = (int)(SWIG_As_int(obj0));
19119 if (SWIG_arg_fail(1)) SWIG_fail;
19120 }
19121 {
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 result = (int)wxDateTime::ConvertYearToBC(arg1);
19124
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 {
19129 resultobj = SWIG_From_int((int)(result));
19130 }
19131 return resultobj;
19132 fail:
19133 return NULL;
19134 }
19135
19136
19137 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19138 PyObject *resultobj;
19139 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19140 wxDateTime::Month result;
19141 PyObject * obj0 = 0 ;
19142 char *kwnames[] = {
19143 (char *) "cal", NULL
19144 };
19145
19146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19147 if (obj0) {
19148 {
19149 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19150 if (SWIG_arg_fail(1)) SWIG_fail;
19151 }
19152 }
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19156
19157 wxPyEndAllowThreads(__tstate);
19158 if (PyErr_Occurred()) SWIG_fail;
19159 }
19160 resultobj = SWIG_From_int((result));
19161 return resultobj;
19162 fail:
19163 return NULL;
19164 }
19165
19166
19167 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19168 PyObject *resultobj;
19169 int arg1 = (int) wxDateTime::Inv_Year ;
19170 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19171 bool result;
19172 PyObject * obj0 = 0 ;
19173 PyObject * obj1 = 0 ;
19174 char *kwnames[] = {
19175 (char *) "year",(char *) "cal", NULL
19176 };
19177
19178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19179 if (obj0) {
19180 {
19181 arg1 = (int)(SWIG_As_int(obj0));
19182 if (SWIG_arg_fail(1)) SWIG_fail;
19183 }
19184 }
19185 if (obj1) {
19186 {
19187 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19188 if (SWIG_arg_fail(2)) SWIG_fail;
19189 }
19190 }
19191 {
19192 PyThreadState* __tstate = wxPyBeginAllowThreads();
19193 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19194
19195 wxPyEndAllowThreads(__tstate);
19196 if (PyErr_Occurred()) SWIG_fail;
19197 }
19198 {
19199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19200 }
19201 return resultobj;
19202 fail:
19203 return NULL;
19204 }
19205
19206
19207 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19208 PyObject *resultobj;
19209 int arg1 = (int) wxDateTime::Inv_Year ;
19210 int result;
19211 PyObject * obj0 = 0 ;
19212 char *kwnames[] = {
19213 (char *) "year", NULL
19214 };
19215
19216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19217 if (obj0) {
19218 {
19219 arg1 = (int)(SWIG_As_int(obj0));
19220 if (SWIG_arg_fail(1)) SWIG_fail;
19221 }
19222 }
19223 {
19224 PyThreadState* __tstate = wxPyBeginAllowThreads();
19225 result = (int)wxDateTime::GetCentury(arg1);
19226
19227 wxPyEndAllowThreads(__tstate);
19228 if (PyErr_Occurred()) SWIG_fail;
19229 }
19230 {
19231 resultobj = SWIG_From_int((int)(result));
19232 }
19233 return resultobj;
19234 fail:
19235 return NULL;
19236 }
19237
19238
19239 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19240 PyObject *resultobj;
19241 int arg1 ;
19242 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19243 int result;
19244 PyObject * obj0 = 0 ;
19245 PyObject * obj1 = 0 ;
19246 char *kwnames[] = {
19247 (char *) "year",(char *) "cal", NULL
19248 };
19249
19250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19251 {
19252 arg1 = (int)(SWIG_As_int(obj0));
19253 if (SWIG_arg_fail(1)) SWIG_fail;
19254 }
19255 if (obj1) {
19256 {
19257 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19258 if (SWIG_arg_fail(2)) SWIG_fail;
19259 }
19260 }
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19264
19265 wxPyEndAllowThreads(__tstate);
19266 if (PyErr_Occurred()) SWIG_fail;
19267 }
19268 {
19269 resultobj = SWIG_From_int((int)(result));
19270 }
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19278 PyObject *resultobj;
19279 wxDateTime::Month arg1 ;
19280 int arg2 = (int) wxDateTime::Inv_Year ;
19281 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19282 int result;
19283 PyObject * obj0 = 0 ;
19284 PyObject * obj1 = 0 ;
19285 PyObject * obj2 = 0 ;
19286 char *kwnames[] = {
19287 (char *) "month",(char *) "year",(char *) "cal", NULL
19288 };
19289
19290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19291 {
19292 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19293 if (SWIG_arg_fail(1)) SWIG_fail;
19294 }
19295 if (obj1) {
19296 {
19297 arg2 = (int)(SWIG_As_int(obj1));
19298 if (SWIG_arg_fail(2)) SWIG_fail;
19299 }
19300 }
19301 if (obj2) {
19302 {
19303 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19304 if (SWIG_arg_fail(3)) SWIG_fail;
19305 }
19306 }
19307 {
19308 PyThreadState* __tstate = wxPyBeginAllowThreads();
19309 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19310
19311 wxPyEndAllowThreads(__tstate);
19312 if (PyErr_Occurred()) SWIG_fail;
19313 }
19314 {
19315 resultobj = SWIG_From_int((int)(result));
19316 }
19317 return resultobj;
19318 fail:
19319 return NULL;
19320 }
19321
19322
19323 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19324 PyObject *resultobj;
19325 wxDateTime::Month arg1 ;
19326 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19327 wxString result;
19328 PyObject * obj0 = 0 ;
19329 PyObject * obj1 = 0 ;
19330 char *kwnames[] = {
19331 (char *) "month",(char *) "flags", NULL
19332 };
19333
19334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19335 {
19336 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19337 if (SWIG_arg_fail(1)) SWIG_fail;
19338 }
19339 if (obj1) {
19340 {
19341 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19342 if (SWIG_arg_fail(2)) SWIG_fail;
19343 }
19344 }
19345 {
19346 PyThreadState* __tstate = wxPyBeginAllowThreads();
19347 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19348
19349 wxPyEndAllowThreads(__tstate);
19350 if (PyErr_Occurred()) SWIG_fail;
19351 }
19352 {
19353 #if wxUSE_UNICODE
19354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19355 #else
19356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19357 #endif
19358 }
19359 return resultobj;
19360 fail:
19361 return NULL;
19362 }
19363
19364
19365 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19366 PyObject *resultobj;
19367 wxDateTime::WeekDay arg1 ;
19368 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19369 wxString result;
19370 PyObject * obj0 = 0 ;
19371 PyObject * obj1 = 0 ;
19372 char *kwnames[] = {
19373 (char *) "weekday",(char *) "flags", NULL
19374 };
19375
19376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19377 {
19378 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19379 if (SWIG_arg_fail(1)) SWIG_fail;
19380 }
19381 if (obj1) {
19382 {
19383 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19384 if (SWIG_arg_fail(2)) SWIG_fail;
19385 }
19386 }
19387 {
19388 PyThreadState* __tstate = wxPyBeginAllowThreads();
19389 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19390
19391 wxPyEndAllowThreads(__tstate);
19392 if (PyErr_Occurred()) SWIG_fail;
19393 }
19394 {
19395 #if wxUSE_UNICODE
19396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19397 #else
19398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19399 #endif
19400 }
19401 return resultobj;
19402 fail:
19403 return NULL;
19404 }
19405
19406
19407 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19408 PyObject *resultobj;
19409 PyObject *result;
19410 char *kwnames[] = {
19411 NULL
19412 };
19413
19414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19415 {
19416 PyThreadState* __tstate = wxPyBeginAllowThreads();
19417 result = (PyObject *)DateTime_GetAmPmStrings();
19418
19419 wxPyEndAllowThreads(__tstate);
19420 if (PyErr_Occurred()) SWIG_fail;
19421 }
19422 resultobj = result;
19423 return resultobj;
19424 fail:
19425 return NULL;
19426 }
19427
19428
19429 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19430 PyObject *resultobj;
19431 int arg1 = (int) wxDateTime::Inv_Year ;
19432 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19433 bool result;
19434 PyObject * obj0 = 0 ;
19435 PyObject * obj1 = 0 ;
19436 char *kwnames[] = {
19437 (char *) "year",(char *) "country", NULL
19438 };
19439
19440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19441 if (obj0) {
19442 {
19443 arg1 = (int)(SWIG_As_int(obj0));
19444 if (SWIG_arg_fail(1)) SWIG_fail;
19445 }
19446 }
19447 if (obj1) {
19448 {
19449 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19450 if (SWIG_arg_fail(2)) SWIG_fail;
19451 }
19452 }
19453 {
19454 PyThreadState* __tstate = wxPyBeginAllowThreads();
19455 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19456
19457 wxPyEndAllowThreads(__tstate);
19458 if (PyErr_Occurred()) SWIG_fail;
19459 }
19460 {
19461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19462 }
19463 return resultobj;
19464 fail:
19465 return NULL;
19466 }
19467
19468
19469 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19470 PyObject *resultobj;
19471 int arg1 = (int) wxDateTime::Inv_Year ;
19472 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19473 wxDateTime result;
19474 PyObject * obj0 = 0 ;
19475 PyObject * obj1 = 0 ;
19476 char *kwnames[] = {
19477 (char *) "year",(char *) "country", NULL
19478 };
19479
19480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19481 if (obj0) {
19482 {
19483 arg1 = (int)(SWIG_As_int(obj0));
19484 if (SWIG_arg_fail(1)) SWIG_fail;
19485 }
19486 }
19487 if (obj1) {
19488 {
19489 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19490 if (SWIG_arg_fail(2)) SWIG_fail;
19491 }
19492 }
19493 {
19494 PyThreadState* __tstate = wxPyBeginAllowThreads();
19495 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19496
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 {
19501 wxDateTime * resultptr;
19502 resultptr = new wxDateTime((wxDateTime &)(result));
19503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19504 }
19505 return resultobj;
19506 fail:
19507 return NULL;
19508 }
19509
19510
19511 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19512 PyObject *resultobj;
19513 int arg1 = (int) wxDateTime::Inv_Year ;
19514 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19515 wxDateTime result;
19516 PyObject * obj0 = 0 ;
19517 PyObject * obj1 = 0 ;
19518 char *kwnames[] = {
19519 (char *) "year",(char *) "country", NULL
19520 };
19521
19522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19523 if (obj0) {
19524 {
19525 arg1 = (int)(SWIG_As_int(obj0));
19526 if (SWIG_arg_fail(1)) SWIG_fail;
19527 }
19528 }
19529 if (obj1) {
19530 {
19531 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19532 if (SWIG_arg_fail(2)) SWIG_fail;
19533 }
19534 }
19535 {
19536 PyThreadState* __tstate = wxPyBeginAllowThreads();
19537 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19538
19539 wxPyEndAllowThreads(__tstate);
19540 if (PyErr_Occurred()) SWIG_fail;
19541 }
19542 {
19543 wxDateTime * resultptr;
19544 resultptr = new wxDateTime((wxDateTime &)(result));
19545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19546 }
19547 return resultobj;
19548 fail:
19549 return NULL;
19550 }
19551
19552
19553 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19554 PyObject *resultobj;
19555 wxDateTime result;
19556 char *kwnames[] = {
19557 NULL
19558 };
19559
19560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19561 {
19562 PyThreadState* __tstate = wxPyBeginAllowThreads();
19563 result = wxDateTime::Now();
19564
19565 wxPyEndAllowThreads(__tstate);
19566 if (PyErr_Occurred()) SWIG_fail;
19567 }
19568 {
19569 wxDateTime * resultptr;
19570 resultptr = new wxDateTime((wxDateTime &)(result));
19571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19572 }
19573 return resultobj;
19574 fail:
19575 return NULL;
19576 }
19577
19578
19579 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19580 PyObject *resultobj;
19581 wxDateTime result;
19582 char *kwnames[] = {
19583 NULL
19584 };
19585
19586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19587 {
19588 PyThreadState* __tstate = wxPyBeginAllowThreads();
19589 result = wxDateTime::UNow();
19590
19591 wxPyEndAllowThreads(__tstate);
19592 if (PyErr_Occurred()) SWIG_fail;
19593 }
19594 {
19595 wxDateTime * resultptr;
19596 resultptr = new wxDateTime((wxDateTime &)(result));
19597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19598 }
19599 return resultobj;
19600 fail:
19601 return NULL;
19602 }
19603
19604
19605 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19606 PyObject *resultobj;
19607 wxDateTime result;
19608 char *kwnames[] = {
19609 NULL
19610 };
19611
19612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19613 {
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 result = wxDateTime::Today();
19616
19617 wxPyEndAllowThreads(__tstate);
19618 if (PyErr_Occurred()) SWIG_fail;
19619 }
19620 {
19621 wxDateTime * resultptr;
19622 resultptr = new wxDateTime((wxDateTime &)(result));
19623 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19624 }
19625 return resultobj;
19626 fail:
19627 return NULL;
19628 }
19629
19630
19631 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19632 PyObject *resultobj;
19633 wxDateTime *result;
19634 char *kwnames[] = {
19635 NULL
19636 };
19637
19638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19639 {
19640 PyThreadState* __tstate = wxPyBeginAllowThreads();
19641 result = (wxDateTime *)new wxDateTime();
19642
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj;
19655 time_t arg1 ;
19656 wxDateTime *result;
19657 PyObject * obj0 = 0 ;
19658 char *kwnames[] = {
19659 (char *) "timet", NULL
19660 };
19661
19662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19663 {
19664 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19665 if (SWIG_arg_fail(1)) SWIG_fail;
19666 }
19667 {
19668 PyThreadState* __tstate = wxPyBeginAllowThreads();
19669 result = (wxDateTime *)new wxDateTime(arg1);
19670
19671 wxPyEndAllowThreads(__tstate);
19672 if (PyErr_Occurred()) SWIG_fail;
19673 }
19674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19675 return resultobj;
19676 fail:
19677 return NULL;
19678 }
19679
19680
19681 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19682 PyObject *resultobj;
19683 double arg1 ;
19684 wxDateTime *result;
19685 PyObject * obj0 = 0 ;
19686 char *kwnames[] = {
19687 (char *) "jdn", NULL
19688 };
19689
19690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19691 {
19692 arg1 = (double)(SWIG_As_double(obj0));
19693 if (SWIG_arg_fail(1)) SWIG_fail;
19694 }
19695 {
19696 PyThreadState* __tstate = wxPyBeginAllowThreads();
19697 result = (wxDateTime *)new wxDateTime(arg1);
19698
19699 wxPyEndAllowThreads(__tstate);
19700 if (PyErr_Occurred()) SWIG_fail;
19701 }
19702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19703 return resultobj;
19704 fail:
19705 return NULL;
19706 }
19707
19708
19709 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19710 PyObject *resultobj;
19711 int arg1 ;
19712 int arg2 = (int) 0 ;
19713 int arg3 = (int) 0 ;
19714 int arg4 = (int) 0 ;
19715 wxDateTime *result;
19716 PyObject * obj0 = 0 ;
19717 PyObject * obj1 = 0 ;
19718 PyObject * obj2 = 0 ;
19719 PyObject * obj3 = 0 ;
19720 char *kwnames[] = {
19721 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19722 };
19723
19724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19725 {
19726 arg1 = (int)(SWIG_As_int(obj0));
19727 if (SWIG_arg_fail(1)) SWIG_fail;
19728 }
19729 if (obj1) {
19730 {
19731 arg2 = (int)(SWIG_As_int(obj1));
19732 if (SWIG_arg_fail(2)) SWIG_fail;
19733 }
19734 }
19735 if (obj2) {
19736 {
19737 arg3 = (int)(SWIG_As_int(obj2));
19738 if (SWIG_arg_fail(3)) SWIG_fail;
19739 }
19740 }
19741 if (obj3) {
19742 {
19743 arg4 = (int)(SWIG_As_int(obj3));
19744 if (SWIG_arg_fail(4)) SWIG_fail;
19745 }
19746 }
19747 {
19748 PyThreadState* __tstate = wxPyBeginAllowThreads();
19749 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19750
19751 wxPyEndAllowThreads(__tstate);
19752 if (PyErr_Occurred()) SWIG_fail;
19753 }
19754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 int arg1 ;
19764 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19765 int arg3 = (int) wxDateTime::Inv_Year ;
19766 int arg4 = (int) 0 ;
19767 int arg5 = (int) 0 ;
19768 int arg6 = (int) 0 ;
19769 int arg7 = (int) 0 ;
19770 wxDateTime *result;
19771 PyObject * obj0 = 0 ;
19772 PyObject * obj1 = 0 ;
19773 PyObject * obj2 = 0 ;
19774 PyObject * obj3 = 0 ;
19775 PyObject * obj4 = 0 ;
19776 PyObject * obj5 = 0 ;
19777 PyObject * obj6 = 0 ;
19778 char *kwnames[] = {
19779 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19780 };
19781
19782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19783 {
19784 arg1 = (int)(SWIG_As_int(obj0));
19785 if (SWIG_arg_fail(1)) SWIG_fail;
19786 }
19787 if (obj1) {
19788 {
19789 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19790 if (SWIG_arg_fail(2)) SWIG_fail;
19791 }
19792 }
19793 if (obj2) {
19794 {
19795 arg3 = (int)(SWIG_As_int(obj2));
19796 if (SWIG_arg_fail(3)) SWIG_fail;
19797 }
19798 }
19799 if (obj3) {
19800 {
19801 arg4 = (int)(SWIG_As_int(obj3));
19802 if (SWIG_arg_fail(4)) SWIG_fail;
19803 }
19804 }
19805 if (obj4) {
19806 {
19807 arg5 = (int)(SWIG_As_int(obj4));
19808 if (SWIG_arg_fail(5)) SWIG_fail;
19809 }
19810 }
19811 if (obj5) {
19812 {
19813 arg6 = (int)(SWIG_As_int(obj5));
19814 if (SWIG_arg_fail(6)) SWIG_fail;
19815 }
19816 }
19817 if (obj6) {
19818 {
19819 arg7 = (int)(SWIG_As_int(obj6));
19820 if (SWIG_arg_fail(7)) SWIG_fail;
19821 }
19822 }
19823 {
19824 PyThreadState* __tstate = wxPyBeginAllowThreads();
19825 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19826
19827 wxPyEndAllowThreads(__tstate);
19828 if (PyErr_Occurred()) SWIG_fail;
19829 }
19830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19831 return resultobj;
19832 fail:
19833 return NULL;
19834 }
19835
19836
19837 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19838 PyObject *resultobj;
19839 wxDateTime *arg1 = (wxDateTime *) 0 ;
19840 PyObject * obj0 = 0 ;
19841 char *kwnames[] = {
19842 (char *) "self", NULL
19843 };
19844
19845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19847 if (SWIG_arg_fail(1)) SWIG_fail;
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 delete arg1;
19851
19852 wxPyEndAllowThreads(__tstate);
19853 if (PyErr_Occurred()) SWIG_fail;
19854 }
19855 Py_INCREF(Py_None); resultobj = Py_None;
19856 return resultobj;
19857 fail:
19858 return NULL;
19859 }
19860
19861
19862 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19863 PyObject *resultobj;
19864 wxDateTime *arg1 = (wxDateTime *) 0 ;
19865 wxDateTime *result;
19866 PyObject * obj0 = 0 ;
19867 char *kwnames[] = {
19868 (char *) "self", NULL
19869 };
19870
19871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19873 if (SWIG_arg_fail(1)) SWIG_fail;
19874 {
19875 PyThreadState* __tstate = wxPyBeginAllowThreads();
19876 {
19877 wxDateTime &_result_ref = (arg1)->SetToCurrent();
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_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19892 PyObject *resultobj;
19893 wxDateTime *arg1 = (wxDateTime *) 0 ;
19894 time_t arg2 ;
19895 wxDateTime *result;
19896 PyObject * obj0 = 0 ;
19897 PyObject * obj1 = 0 ;
19898 char *kwnames[] = {
19899 (char *) "self",(char *) "timet", NULL
19900 };
19901
19902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19904 if (SWIG_arg_fail(1)) SWIG_fail;
19905 {
19906 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19907 if (SWIG_arg_fail(2)) SWIG_fail;
19908 }
19909 {
19910 PyThreadState* __tstate = wxPyBeginAllowThreads();
19911 {
19912 wxDateTime &_result_ref = (arg1)->Set(arg2);
19913 result = (wxDateTime *) &_result_ref;
19914 }
19915
19916 wxPyEndAllowThreads(__tstate);
19917 if (PyErr_Occurred()) SWIG_fail;
19918 }
19919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19927 PyObject *resultobj;
19928 wxDateTime *arg1 = (wxDateTime *) 0 ;
19929 double arg2 ;
19930 wxDateTime *result;
19931 PyObject * obj0 = 0 ;
19932 PyObject * obj1 = 0 ;
19933 char *kwnames[] = {
19934 (char *) "self",(char *) "jdn", NULL
19935 };
19936
19937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19939 if (SWIG_arg_fail(1)) SWIG_fail;
19940 {
19941 arg2 = (double)(SWIG_As_double(obj1));
19942 if (SWIG_arg_fail(2)) SWIG_fail;
19943 }
19944 {
19945 PyThreadState* __tstate = wxPyBeginAllowThreads();
19946 {
19947 wxDateTime &_result_ref = (arg1)->Set(arg2);
19948 result = (wxDateTime *) &_result_ref;
19949 }
19950
19951 wxPyEndAllowThreads(__tstate);
19952 if (PyErr_Occurred()) SWIG_fail;
19953 }
19954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19955 return resultobj;
19956 fail:
19957 return NULL;
19958 }
19959
19960
19961 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19962 PyObject *resultobj;
19963 wxDateTime *arg1 = (wxDateTime *) 0 ;
19964 int arg2 ;
19965 int arg3 = (int) 0 ;
19966 int arg4 = (int) 0 ;
19967 int arg5 = (int) 0 ;
19968 wxDateTime *result;
19969 PyObject * obj0 = 0 ;
19970 PyObject * obj1 = 0 ;
19971 PyObject * obj2 = 0 ;
19972 PyObject * obj3 = 0 ;
19973 PyObject * obj4 = 0 ;
19974 char *kwnames[] = {
19975 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19976 };
19977
19978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19980 if (SWIG_arg_fail(1)) SWIG_fail;
19981 {
19982 arg2 = (int)(SWIG_As_int(obj1));
19983 if (SWIG_arg_fail(2)) SWIG_fail;
19984 }
19985 if (obj2) {
19986 {
19987 arg3 = (int)(SWIG_As_int(obj2));
19988 if (SWIG_arg_fail(3)) SWIG_fail;
19989 }
19990 }
19991 if (obj3) {
19992 {
19993 arg4 = (int)(SWIG_As_int(obj3));
19994 if (SWIG_arg_fail(4)) SWIG_fail;
19995 }
19996 }
19997 if (obj4) {
19998 {
19999 arg5 = (int)(SWIG_As_int(obj4));
20000 if (SWIG_arg_fail(5)) SWIG_fail;
20001 }
20002 }
20003 {
20004 PyThreadState* __tstate = wxPyBeginAllowThreads();
20005 {
20006 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20007 result = (wxDateTime *) &_result_ref;
20008 }
20009
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20014 return resultobj;
20015 fail:
20016 return NULL;
20017 }
20018
20019
20020 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20021 PyObject *resultobj;
20022 wxDateTime *arg1 = (wxDateTime *) 0 ;
20023 int arg2 ;
20024 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20025 int arg4 = (int) wxDateTime::Inv_Year ;
20026 int arg5 = (int) 0 ;
20027 int arg6 = (int) 0 ;
20028 int arg7 = (int) 0 ;
20029 int arg8 = (int) 0 ;
20030 wxDateTime *result;
20031 PyObject * obj0 = 0 ;
20032 PyObject * obj1 = 0 ;
20033 PyObject * obj2 = 0 ;
20034 PyObject * obj3 = 0 ;
20035 PyObject * obj4 = 0 ;
20036 PyObject * obj5 = 0 ;
20037 PyObject * obj6 = 0 ;
20038 PyObject * obj7 = 0 ;
20039 char *kwnames[] = {
20040 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20041 };
20042
20043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20045 if (SWIG_arg_fail(1)) SWIG_fail;
20046 {
20047 arg2 = (int)(SWIG_As_int(obj1));
20048 if (SWIG_arg_fail(2)) SWIG_fail;
20049 }
20050 if (obj2) {
20051 {
20052 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20053 if (SWIG_arg_fail(3)) SWIG_fail;
20054 }
20055 }
20056 if (obj3) {
20057 {
20058 arg4 = (int)(SWIG_As_int(obj3));
20059 if (SWIG_arg_fail(4)) SWIG_fail;
20060 }
20061 }
20062 if (obj4) {
20063 {
20064 arg5 = (int)(SWIG_As_int(obj4));
20065 if (SWIG_arg_fail(5)) SWIG_fail;
20066 }
20067 }
20068 if (obj5) {
20069 {
20070 arg6 = (int)(SWIG_As_int(obj5));
20071 if (SWIG_arg_fail(6)) SWIG_fail;
20072 }
20073 }
20074 if (obj6) {
20075 {
20076 arg7 = (int)(SWIG_As_int(obj6));
20077 if (SWIG_arg_fail(7)) SWIG_fail;
20078 }
20079 }
20080 if (obj7) {
20081 {
20082 arg8 = (int)(SWIG_As_int(obj7));
20083 if (SWIG_arg_fail(8)) SWIG_fail;
20084 }
20085 }
20086 {
20087 PyThreadState* __tstate = wxPyBeginAllowThreads();
20088 {
20089 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20090 result = (wxDateTime *) &_result_ref;
20091 }
20092
20093 wxPyEndAllowThreads(__tstate);
20094 if (PyErr_Occurred()) SWIG_fail;
20095 }
20096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20097 return resultobj;
20098 fail:
20099 return NULL;
20100 }
20101
20102
20103 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20104 PyObject *resultobj;
20105 wxDateTime *arg1 = (wxDateTime *) 0 ;
20106 wxDateTime *result;
20107 PyObject * obj0 = 0 ;
20108 char *kwnames[] = {
20109 (char *) "self", NULL
20110 };
20111
20112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20114 if (SWIG_arg_fail(1)) SWIG_fail;
20115 {
20116 PyThreadState* __tstate = wxPyBeginAllowThreads();
20117 {
20118 wxDateTime &_result_ref = (arg1)->ResetTime();
20119 result = (wxDateTime *) &_result_ref;
20120 }
20121
20122 wxPyEndAllowThreads(__tstate);
20123 if (PyErr_Occurred()) SWIG_fail;
20124 }
20125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj;
20134 wxDateTime *arg1 = (wxDateTime *) 0 ;
20135 int arg2 ;
20136 wxDateTime *result;
20137 PyObject * obj0 = 0 ;
20138 PyObject * obj1 = 0 ;
20139 char *kwnames[] = {
20140 (char *) "self",(char *) "year", NULL
20141 };
20142
20143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20145 if (SWIG_arg_fail(1)) SWIG_fail;
20146 {
20147 arg2 = (int)(SWIG_As_int(obj1));
20148 if (SWIG_arg_fail(2)) SWIG_fail;
20149 }
20150 {
20151 PyThreadState* __tstate = wxPyBeginAllowThreads();
20152 {
20153 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20154 result = (wxDateTime *) &_result_ref;
20155 }
20156
20157 wxPyEndAllowThreads(__tstate);
20158 if (PyErr_Occurred()) SWIG_fail;
20159 }
20160 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20161 return resultobj;
20162 fail:
20163 return NULL;
20164 }
20165
20166
20167 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20168 PyObject *resultobj;
20169 wxDateTime *arg1 = (wxDateTime *) 0 ;
20170 wxDateTime::Month arg2 ;
20171 wxDateTime *result;
20172 PyObject * obj0 = 0 ;
20173 PyObject * obj1 = 0 ;
20174 char *kwnames[] = {
20175 (char *) "self",(char *) "month", NULL
20176 };
20177
20178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) 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::Month)(SWIG_As_int(obj1));
20183 if (SWIG_arg_fail(2)) SWIG_fail;
20184 }
20185 {
20186 PyThreadState* __tstate = wxPyBeginAllowThreads();
20187 {
20188 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20189 result = (wxDateTime *) &_result_ref;
20190 }
20191
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20196 return resultobj;
20197 fail:
20198 return NULL;
20199 }
20200
20201
20202 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20203 PyObject *resultobj;
20204 wxDateTime *arg1 = (wxDateTime *) 0 ;
20205 int arg2 ;
20206 wxDateTime *result;
20207 PyObject * obj0 = 0 ;
20208 PyObject * obj1 = 0 ;
20209 char *kwnames[] = {
20210 (char *) "self",(char *) "day", NULL
20211 };
20212
20213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20215 if (SWIG_arg_fail(1)) SWIG_fail;
20216 {
20217 arg2 = (int)(SWIG_As_int(obj1));
20218 if (SWIG_arg_fail(2)) SWIG_fail;
20219 }
20220 {
20221 PyThreadState* __tstate = wxPyBeginAllowThreads();
20222 {
20223 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20224 result = (wxDateTime *) &_result_ref;
20225 }
20226
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20231 return resultobj;
20232 fail:
20233 return NULL;
20234 }
20235
20236
20237 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20238 PyObject *resultobj;
20239 wxDateTime *arg1 = (wxDateTime *) 0 ;
20240 int arg2 ;
20241 wxDateTime *result;
20242 PyObject * obj0 = 0 ;
20243 PyObject * obj1 = 0 ;
20244 char *kwnames[] = {
20245 (char *) "self",(char *) "hour", NULL
20246 };
20247
20248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20250 if (SWIG_arg_fail(1)) SWIG_fail;
20251 {
20252 arg2 = (int)(SWIG_As_int(obj1));
20253 if (SWIG_arg_fail(2)) SWIG_fail;
20254 }
20255 {
20256 PyThreadState* __tstate = wxPyBeginAllowThreads();
20257 {
20258 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20259 result = (wxDateTime *) &_result_ref;
20260 }
20261
20262 wxPyEndAllowThreads(__tstate);
20263 if (PyErr_Occurred()) SWIG_fail;
20264 }
20265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20266 return resultobj;
20267 fail:
20268 return NULL;
20269 }
20270
20271
20272 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20273 PyObject *resultobj;
20274 wxDateTime *arg1 = (wxDateTime *) 0 ;
20275 int arg2 ;
20276 wxDateTime *result;
20277 PyObject * obj0 = 0 ;
20278 PyObject * obj1 = 0 ;
20279 char *kwnames[] = {
20280 (char *) "self",(char *) "minute", NULL
20281 };
20282
20283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20285 if (SWIG_arg_fail(1)) SWIG_fail;
20286 {
20287 arg2 = (int)(SWIG_As_int(obj1));
20288 if (SWIG_arg_fail(2)) SWIG_fail;
20289 }
20290 {
20291 PyThreadState* __tstate = wxPyBeginAllowThreads();
20292 {
20293 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20294 result = (wxDateTime *) &_result_ref;
20295 }
20296
20297 wxPyEndAllowThreads(__tstate);
20298 if (PyErr_Occurred()) SWIG_fail;
20299 }
20300 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20301 return resultobj;
20302 fail:
20303 return NULL;
20304 }
20305
20306
20307 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20308 PyObject *resultobj;
20309 wxDateTime *arg1 = (wxDateTime *) 0 ;
20310 int arg2 ;
20311 wxDateTime *result;
20312 PyObject * obj0 = 0 ;
20313 PyObject * obj1 = 0 ;
20314 char *kwnames[] = {
20315 (char *) "self",(char *) "second", NULL
20316 };
20317
20318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20320 if (SWIG_arg_fail(1)) SWIG_fail;
20321 {
20322 arg2 = (int)(SWIG_As_int(obj1));
20323 if (SWIG_arg_fail(2)) SWIG_fail;
20324 }
20325 {
20326 PyThreadState* __tstate = wxPyBeginAllowThreads();
20327 {
20328 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20329 result = (wxDateTime *) &_result_ref;
20330 }
20331
20332 wxPyEndAllowThreads(__tstate);
20333 if (PyErr_Occurred()) SWIG_fail;
20334 }
20335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20336 return resultobj;
20337 fail:
20338 return NULL;
20339 }
20340
20341
20342 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20343 PyObject *resultobj;
20344 wxDateTime *arg1 = (wxDateTime *) 0 ;
20345 int arg2 ;
20346 wxDateTime *result;
20347 PyObject * obj0 = 0 ;
20348 PyObject * obj1 = 0 ;
20349 char *kwnames[] = {
20350 (char *) "self",(char *) "millisecond", NULL
20351 };
20352
20353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20355 if (SWIG_arg_fail(1)) SWIG_fail;
20356 {
20357 arg2 = (int)(SWIG_As_int(obj1));
20358 if (SWIG_arg_fail(2)) SWIG_fail;
20359 }
20360 {
20361 PyThreadState* __tstate = wxPyBeginAllowThreads();
20362 {
20363 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20364 result = (wxDateTime *) &_result_ref;
20365 }
20366
20367 wxPyEndAllowThreads(__tstate);
20368 if (PyErr_Occurred()) SWIG_fail;
20369 }
20370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20371 return resultobj;
20372 fail:
20373 return NULL;
20374 }
20375
20376
20377 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20378 PyObject *resultobj;
20379 wxDateTime *arg1 = (wxDateTime *) 0 ;
20380 wxDateTime::WeekDay arg2 ;
20381 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20382 wxDateTime *result;
20383 PyObject * obj0 = 0 ;
20384 PyObject * obj1 = 0 ;
20385 PyObject * obj2 = 0 ;
20386 char *kwnames[] = {
20387 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20388 };
20389
20390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20392 if (SWIG_arg_fail(1)) SWIG_fail;
20393 {
20394 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20395 if (SWIG_arg_fail(2)) SWIG_fail;
20396 }
20397 if (obj2) {
20398 {
20399 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20400 if (SWIG_arg_fail(3)) SWIG_fail;
20401 }
20402 }
20403 {
20404 PyThreadState* __tstate = wxPyBeginAllowThreads();
20405 {
20406 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20407 result = (wxDateTime *) &_result_ref;
20408 }
20409
20410 wxPyEndAllowThreads(__tstate);
20411 if (PyErr_Occurred()) SWIG_fail;
20412 }
20413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20414 return resultobj;
20415 fail:
20416 return NULL;
20417 }
20418
20419
20420 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20421 PyObject *resultobj;
20422 wxDateTime *arg1 = (wxDateTime *) 0 ;
20423 wxDateTime::WeekDay arg2 ;
20424 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20425 wxDateTime result;
20426 PyObject * obj0 = 0 ;
20427 PyObject * obj1 = 0 ;
20428 PyObject * obj2 = 0 ;
20429 char *kwnames[] = {
20430 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20431 };
20432
20433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20435 if (SWIG_arg_fail(1)) SWIG_fail;
20436 {
20437 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20438 if (SWIG_arg_fail(2)) SWIG_fail;
20439 }
20440 if (obj2) {
20441 {
20442 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20443 if (SWIG_arg_fail(3)) SWIG_fail;
20444 }
20445 }
20446 {
20447 PyThreadState* __tstate = wxPyBeginAllowThreads();
20448 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20449
20450 wxPyEndAllowThreads(__tstate);
20451 if (PyErr_Occurred()) SWIG_fail;
20452 }
20453 {
20454 wxDateTime * resultptr;
20455 resultptr = new wxDateTime((wxDateTime &)(result));
20456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20457 }
20458 return resultobj;
20459 fail:
20460 return NULL;
20461 }
20462
20463
20464 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20465 PyObject *resultobj;
20466 wxDateTime *arg1 = (wxDateTime *) 0 ;
20467 wxDateTime::WeekDay arg2 ;
20468 wxDateTime *result;
20469 PyObject * obj0 = 0 ;
20470 PyObject * obj1 = 0 ;
20471 char *kwnames[] = {
20472 (char *) "self",(char *) "weekday", NULL
20473 };
20474
20475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20477 if (SWIG_arg_fail(1)) SWIG_fail;
20478 {
20479 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20480 if (SWIG_arg_fail(2)) SWIG_fail;
20481 }
20482 {
20483 PyThreadState* __tstate = wxPyBeginAllowThreads();
20484 {
20485 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20486 result = (wxDateTime *) &_result_ref;
20487 }
20488
20489 wxPyEndAllowThreads(__tstate);
20490 if (PyErr_Occurred()) SWIG_fail;
20491 }
20492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20493 return resultobj;
20494 fail:
20495 return NULL;
20496 }
20497
20498
20499 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20500 PyObject *resultobj;
20501 wxDateTime *arg1 = (wxDateTime *) 0 ;
20502 wxDateTime::WeekDay arg2 ;
20503 wxDateTime result;
20504 PyObject * obj0 = 0 ;
20505 PyObject * obj1 = 0 ;
20506 char *kwnames[] = {
20507 (char *) "self",(char *) "weekday", NULL
20508 };
20509
20510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20512 if (SWIG_arg_fail(1)) SWIG_fail;
20513 {
20514 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20515 if (SWIG_arg_fail(2)) SWIG_fail;
20516 }
20517 {
20518 PyThreadState* __tstate = wxPyBeginAllowThreads();
20519 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20520
20521 wxPyEndAllowThreads(__tstate);
20522 if (PyErr_Occurred()) SWIG_fail;
20523 }
20524 {
20525 wxDateTime * resultptr;
20526 resultptr = new wxDateTime((wxDateTime &)(result));
20527 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20528 }
20529 return resultobj;
20530 fail:
20531 return NULL;
20532 }
20533
20534
20535 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20536 PyObject *resultobj;
20537 wxDateTime *arg1 = (wxDateTime *) 0 ;
20538 wxDateTime::WeekDay arg2 ;
20539 wxDateTime *result;
20540 PyObject * obj0 = 0 ;
20541 PyObject * obj1 = 0 ;
20542 char *kwnames[] = {
20543 (char *) "self",(char *) "weekday", NULL
20544 };
20545
20546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20548 if (SWIG_arg_fail(1)) SWIG_fail;
20549 {
20550 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20551 if (SWIG_arg_fail(2)) SWIG_fail;
20552 }
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 {
20556 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20557 result = (wxDateTime *) &_result_ref;
20558 }
20559
20560 wxPyEndAllowThreads(__tstate);
20561 if (PyErr_Occurred()) SWIG_fail;
20562 }
20563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20564 return resultobj;
20565 fail:
20566 return NULL;
20567 }
20568
20569
20570 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20571 PyObject *resultobj;
20572 wxDateTime *arg1 = (wxDateTime *) 0 ;
20573 wxDateTime::WeekDay arg2 ;
20574 wxDateTime result;
20575 PyObject * obj0 = 0 ;
20576 PyObject * obj1 = 0 ;
20577 char *kwnames[] = {
20578 (char *) "self",(char *) "weekday", NULL
20579 };
20580
20581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20583 if (SWIG_arg_fail(1)) SWIG_fail;
20584 {
20585 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20586 if (SWIG_arg_fail(2)) SWIG_fail;
20587 }
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20591
20592 wxPyEndAllowThreads(__tstate);
20593 if (PyErr_Occurred()) SWIG_fail;
20594 }
20595 {
20596 wxDateTime * resultptr;
20597 resultptr = new wxDateTime((wxDateTime &)(result));
20598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20599 }
20600 return resultobj;
20601 fail:
20602 return NULL;
20603 }
20604
20605
20606 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20607 PyObject *resultobj;
20608 wxDateTime *arg1 = (wxDateTime *) 0 ;
20609 wxDateTime::WeekDay arg2 ;
20610 int arg3 = (int) 1 ;
20611 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20612 int arg5 = (int) wxDateTime::Inv_Year ;
20613 bool result;
20614 PyObject * obj0 = 0 ;
20615 PyObject * obj1 = 0 ;
20616 PyObject * obj2 = 0 ;
20617 PyObject * obj3 = 0 ;
20618 PyObject * obj4 = 0 ;
20619 char *kwnames[] = {
20620 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20621 };
20622
20623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20625 if (SWIG_arg_fail(1)) SWIG_fail;
20626 {
20627 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20628 if (SWIG_arg_fail(2)) SWIG_fail;
20629 }
20630 if (obj2) {
20631 {
20632 arg3 = (int)(SWIG_As_int(obj2));
20633 if (SWIG_arg_fail(3)) SWIG_fail;
20634 }
20635 }
20636 if (obj3) {
20637 {
20638 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20639 if (SWIG_arg_fail(4)) SWIG_fail;
20640 }
20641 }
20642 if (obj4) {
20643 {
20644 arg5 = (int)(SWIG_As_int(obj4));
20645 if (SWIG_arg_fail(5)) SWIG_fail;
20646 }
20647 }
20648 {
20649 PyThreadState* __tstate = wxPyBeginAllowThreads();
20650 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20651
20652 wxPyEndAllowThreads(__tstate);
20653 if (PyErr_Occurred()) SWIG_fail;
20654 }
20655 {
20656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20657 }
20658 return resultobj;
20659 fail:
20660 return NULL;
20661 }
20662
20663
20664 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20665 PyObject *resultobj;
20666 wxDateTime *arg1 = (wxDateTime *) 0 ;
20667 wxDateTime::WeekDay arg2 ;
20668 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20669 int arg4 = (int) wxDateTime::Inv_Year ;
20670 bool result;
20671 PyObject * obj0 = 0 ;
20672 PyObject * obj1 = 0 ;
20673 PyObject * obj2 = 0 ;
20674 PyObject * obj3 = 0 ;
20675 char *kwnames[] = {
20676 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20677 };
20678
20679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20681 if (SWIG_arg_fail(1)) SWIG_fail;
20682 {
20683 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20684 if (SWIG_arg_fail(2)) SWIG_fail;
20685 }
20686 if (obj2) {
20687 {
20688 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20689 if (SWIG_arg_fail(3)) SWIG_fail;
20690 }
20691 }
20692 if (obj3) {
20693 {
20694 arg4 = (int)(SWIG_As_int(obj3));
20695 if (SWIG_arg_fail(4)) SWIG_fail;
20696 }
20697 }
20698 {
20699 PyThreadState* __tstate = wxPyBeginAllowThreads();
20700 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20701
20702 wxPyEndAllowThreads(__tstate);
20703 if (PyErr_Occurred()) SWIG_fail;
20704 }
20705 {
20706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20707 }
20708 return resultobj;
20709 fail:
20710 return NULL;
20711 }
20712
20713
20714 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20715 PyObject *resultobj;
20716 wxDateTime *arg1 = (wxDateTime *) 0 ;
20717 wxDateTime::WeekDay arg2 ;
20718 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20719 int arg4 = (int) wxDateTime::Inv_Year ;
20720 wxDateTime result;
20721 PyObject * obj0 = 0 ;
20722 PyObject * obj1 = 0 ;
20723 PyObject * obj2 = 0 ;
20724 PyObject * obj3 = 0 ;
20725 char *kwnames[] = {
20726 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20727 };
20728
20729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20731 if (SWIG_arg_fail(1)) SWIG_fail;
20732 {
20733 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20734 if (SWIG_arg_fail(2)) SWIG_fail;
20735 }
20736 if (obj2) {
20737 {
20738 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20739 if (SWIG_arg_fail(3)) SWIG_fail;
20740 }
20741 }
20742 if (obj3) {
20743 {
20744 arg4 = (int)(SWIG_As_int(obj3));
20745 if (SWIG_arg_fail(4)) SWIG_fail;
20746 }
20747 }
20748 {
20749 PyThreadState* __tstate = wxPyBeginAllowThreads();
20750 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20751
20752 wxPyEndAllowThreads(__tstate);
20753 if (PyErr_Occurred()) SWIG_fail;
20754 }
20755 {
20756 wxDateTime * resultptr;
20757 resultptr = new wxDateTime((wxDateTime &)(result));
20758 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20759 }
20760 return resultobj;
20761 fail:
20762 return NULL;
20763 }
20764
20765
20766 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20767 PyObject *resultobj;
20768 wxDateTime *arg1 = (wxDateTime *) 0 ;
20769 int arg2 ;
20770 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20771 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20772 bool result;
20773 PyObject * obj0 = 0 ;
20774 PyObject * obj1 = 0 ;
20775 PyObject * obj2 = 0 ;
20776 PyObject * obj3 = 0 ;
20777 char *kwnames[] = {
20778 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20779 };
20780
20781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20783 if (SWIG_arg_fail(1)) SWIG_fail;
20784 {
20785 arg2 = (int)(SWIG_As_int(obj1));
20786 if (SWIG_arg_fail(2)) SWIG_fail;
20787 }
20788 if (obj2) {
20789 {
20790 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20791 if (SWIG_arg_fail(3)) SWIG_fail;
20792 }
20793 }
20794 if (obj3) {
20795 {
20796 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20797 if (SWIG_arg_fail(4)) SWIG_fail;
20798 }
20799 }
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20803
20804 wxPyEndAllowThreads(__tstate);
20805 if (PyErr_Occurred()) SWIG_fail;
20806 }
20807 {
20808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20809 }
20810 return resultobj;
20811 fail:
20812 return NULL;
20813 }
20814
20815
20816 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20817 PyObject *resultobj;
20818 wxDateTime *arg1 = (wxDateTime *) 0 ;
20819 int arg2 ;
20820 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20821 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20822 wxDateTime result;
20823 PyObject * obj0 = 0 ;
20824 PyObject * obj1 = 0 ;
20825 PyObject * obj2 = 0 ;
20826 PyObject * obj3 = 0 ;
20827 char *kwnames[] = {
20828 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20829 };
20830
20831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20833 if (SWIG_arg_fail(1)) SWIG_fail;
20834 {
20835 arg2 = (int)(SWIG_As_int(obj1));
20836 if (SWIG_arg_fail(2)) SWIG_fail;
20837 }
20838 if (obj2) {
20839 {
20840 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20841 if (SWIG_arg_fail(3)) SWIG_fail;
20842 }
20843 }
20844 if (obj3) {
20845 {
20846 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20847 if (SWIG_arg_fail(4)) SWIG_fail;
20848 }
20849 }
20850 {
20851 PyThreadState* __tstate = wxPyBeginAllowThreads();
20852 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20853
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 {
20858 wxDateTime * resultptr;
20859 resultptr = new wxDateTime((wxDateTime &)(result));
20860 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20861 }
20862 return resultobj;
20863 fail:
20864 return NULL;
20865 }
20866
20867
20868 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20869 PyObject *resultobj;
20870 int arg1 ;
20871 int arg2 ;
20872 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20873 wxDateTime result;
20874 PyObject * obj0 = 0 ;
20875 PyObject * obj1 = 0 ;
20876 PyObject * obj2 = 0 ;
20877 char *kwnames[] = {
20878 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20879 };
20880
20881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20882 {
20883 arg1 = (int)(SWIG_As_int(obj0));
20884 if (SWIG_arg_fail(1)) SWIG_fail;
20885 }
20886 {
20887 arg2 = (int)(SWIG_As_int(obj1));
20888 if (SWIG_arg_fail(2)) SWIG_fail;
20889 }
20890 if (obj2) {
20891 {
20892 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20893 if (SWIG_arg_fail(3)) SWIG_fail;
20894 }
20895 }
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20899
20900 wxPyEndAllowThreads(__tstate);
20901 if (PyErr_Occurred()) SWIG_fail;
20902 }
20903 {
20904 wxDateTime * resultptr;
20905 resultptr = new wxDateTime((wxDateTime &)(result));
20906 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20907 }
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20915 PyObject *resultobj;
20916 wxDateTime *arg1 = (wxDateTime *) 0 ;
20917 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20918 int arg3 = (int) wxDateTime::Inv_Year ;
20919 wxDateTime *result;
20920 PyObject * obj0 = 0 ;
20921 PyObject * obj1 = 0 ;
20922 PyObject * obj2 = 0 ;
20923 char *kwnames[] = {
20924 (char *) "self",(char *) "month",(char *) "year", NULL
20925 };
20926
20927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20929 if (SWIG_arg_fail(1)) SWIG_fail;
20930 if (obj1) {
20931 {
20932 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20933 if (SWIG_arg_fail(2)) SWIG_fail;
20934 }
20935 }
20936 if (obj2) {
20937 {
20938 arg3 = (int)(SWIG_As_int(obj2));
20939 if (SWIG_arg_fail(3)) SWIG_fail;
20940 }
20941 }
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 {
20945 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20946 result = (wxDateTime *) &_result_ref;
20947 }
20948
20949 wxPyEndAllowThreads(__tstate);
20950 if (PyErr_Occurred()) SWIG_fail;
20951 }
20952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20953 return resultobj;
20954 fail:
20955 return NULL;
20956 }
20957
20958
20959 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20960 PyObject *resultobj;
20961 wxDateTime *arg1 = (wxDateTime *) 0 ;
20962 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20963 int arg3 = (int) wxDateTime::Inv_Year ;
20964 wxDateTime result;
20965 PyObject * obj0 = 0 ;
20966 PyObject * obj1 = 0 ;
20967 PyObject * obj2 = 0 ;
20968 char *kwnames[] = {
20969 (char *) "self",(char *) "month",(char *) "year", NULL
20970 };
20971
20972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20974 if (SWIG_arg_fail(1)) SWIG_fail;
20975 if (obj1) {
20976 {
20977 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20978 if (SWIG_arg_fail(2)) SWIG_fail;
20979 }
20980 }
20981 if (obj2) {
20982 {
20983 arg3 = (int)(SWIG_As_int(obj2));
20984 if (SWIG_arg_fail(3)) SWIG_fail;
20985 }
20986 }
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20990
20991 wxPyEndAllowThreads(__tstate);
20992 if (PyErr_Occurred()) SWIG_fail;
20993 }
20994 {
20995 wxDateTime * resultptr;
20996 resultptr = new wxDateTime((wxDateTime &)(result));
20997 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20998 }
20999 return resultobj;
21000 fail:
21001 return NULL;
21002 }
21003
21004
21005 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21006 PyObject *resultobj;
21007 wxDateTime *arg1 = (wxDateTime *) 0 ;
21008 int arg2 ;
21009 wxDateTime *result;
21010 PyObject * obj0 = 0 ;
21011 PyObject * obj1 = 0 ;
21012 char *kwnames[] = {
21013 (char *) "self",(char *) "yday", NULL
21014 };
21015
21016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21018 if (SWIG_arg_fail(1)) SWIG_fail;
21019 {
21020 arg2 = (int)(SWIG_As_int(obj1));
21021 if (SWIG_arg_fail(2)) SWIG_fail;
21022 }
21023 {
21024 PyThreadState* __tstate = wxPyBeginAllowThreads();
21025 {
21026 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21027 result = (wxDateTime *) &_result_ref;
21028 }
21029
21030 wxPyEndAllowThreads(__tstate);
21031 if (PyErr_Occurred()) SWIG_fail;
21032 }
21033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21034 return resultobj;
21035 fail:
21036 return NULL;
21037 }
21038
21039
21040 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21041 PyObject *resultobj;
21042 wxDateTime *arg1 = (wxDateTime *) 0 ;
21043 int arg2 ;
21044 wxDateTime result;
21045 PyObject * obj0 = 0 ;
21046 PyObject * obj1 = 0 ;
21047 char *kwnames[] = {
21048 (char *) "self",(char *) "yday", NULL
21049 };
21050
21051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21053 if (SWIG_arg_fail(1)) SWIG_fail;
21054 {
21055 arg2 = (int)(SWIG_As_int(obj1));
21056 if (SWIG_arg_fail(2)) SWIG_fail;
21057 }
21058 {
21059 PyThreadState* __tstate = wxPyBeginAllowThreads();
21060 result = (arg1)->GetYearDay(arg2);
21061
21062 wxPyEndAllowThreads(__tstate);
21063 if (PyErr_Occurred()) SWIG_fail;
21064 }
21065 {
21066 wxDateTime * resultptr;
21067 resultptr = new wxDateTime((wxDateTime &)(result));
21068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21069 }
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21077 PyObject *resultobj;
21078 wxDateTime *arg1 = (wxDateTime *) 0 ;
21079 double result;
21080 PyObject * obj0 = 0 ;
21081 char *kwnames[] = {
21082 (char *) "self", NULL
21083 };
21084
21085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21087 if (SWIG_arg_fail(1)) SWIG_fail;
21088 {
21089 PyThreadState* __tstate = wxPyBeginAllowThreads();
21090 result = (double)(arg1)->GetJulianDayNumber();
21091
21092 wxPyEndAllowThreads(__tstate);
21093 if (PyErr_Occurred()) SWIG_fail;
21094 }
21095 {
21096 resultobj = SWIG_From_double((double)(result));
21097 }
21098 return resultobj;
21099 fail:
21100 return NULL;
21101 }
21102
21103
21104 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21105 PyObject *resultobj;
21106 wxDateTime *arg1 = (wxDateTime *) 0 ;
21107 double result;
21108 PyObject * obj0 = 0 ;
21109 char *kwnames[] = {
21110 (char *) "self", NULL
21111 };
21112
21113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21115 if (SWIG_arg_fail(1)) SWIG_fail;
21116 {
21117 PyThreadState* __tstate = wxPyBeginAllowThreads();
21118 result = (double)(arg1)->GetJDN();
21119
21120 wxPyEndAllowThreads(__tstate);
21121 if (PyErr_Occurred()) SWIG_fail;
21122 }
21123 {
21124 resultobj = SWIG_From_double((double)(result));
21125 }
21126 return resultobj;
21127 fail:
21128 return NULL;
21129 }
21130
21131
21132 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21133 PyObject *resultobj;
21134 wxDateTime *arg1 = (wxDateTime *) 0 ;
21135 double result;
21136 PyObject * obj0 = 0 ;
21137 char *kwnames[] = {
21138 (char *) "self", NULL
21139 };
21140
21141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21143 if (SWIG_arg_fail(1)) SWIG_fail;
21144 {
21145 PyThreadState* __tstate = wxPyBeginAllowThreads();
21146 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21147
21148 wxPyEndAllowThreads(__tstate);
21149 if (PyErr_Occurred()) SWIG_fail;
21150 }
21151 {
21152 resultobj = SWIG_From_double((double)(result));
21153 }
21154 return resultobj;
21155 fail:
21156 return NULL;
21157 }
21158
21159
21160 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21161 PyObject *resultobj;
21162 wxDateTime *arg1 = (wxDateTime *) 0 ;
21163 double result;
21164 PyObject * obj0 = 0 ;
21165 char *kwnames[] = {
21166 (char *) "self", NULL
21167 };
21168
21169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21171 if (SWIG_arg_fail(1)) SWIG_fail;
21172 {
21173 PyThreadState* __tstate = wxPyBeginAllowThreads();
21174 result = (double)(arg1)->GetMJD();
21175
21176 wxPyEndAllowThreads(__tstate);
21177 if (PyErr_Occurred()) SWIG_fail;
21178 }
21179 {
21180 resultobj = SWIG_From_double((double)(result));
21181 }
21182 return resultobj;
21183 fail:
21184 return NULL;
21185 }
21186
21187
21188 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21189 PyObject *resultobj;
21190 wxDateTime *arg1 = (wxDateTime *) 0 ;
21191 double result;
21192 PyObject * obj0 = 0 ;
21193 char *kwnames[] = {
21194 (char *) "self", NULL
21195 };
21196
21197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21199 if (SWIG_arg_fail(1)) SWIG_fail;
21200 {
21201 PyThreadState* __tstate = wxPyBeginAllowThreads();
21202 result = (double)(arg1)->GetRataDie();
21203
21204 wxPyEndAllowThreads(__tstate);
21205 if (PyErr_Occurred()) SWIG_fail;
21206 }
21207 {
21208 resultobj = SWIG_From_double((double)(result));
21209 }
21210 return resultobj;
21211 fail:
21212 return NULL;
21213 }
21214
21215
21216 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21217 PyObject *resultobj;
21218 wxDateTime *arg1 = (wxDateTime *) 0 ;
21219 wxDateTime::TimeZone *arg2 = 0 ;
21220 bool arg3 = (bool) false ;
21221 wxDateTime result;
21222 bool temp2 = false ;
21223 PyObject * obj0 = 0 ;
21224 PyObject * obj1 = 0 ;
21225 PyObject * obj2 = 0 ;
21226 char *kwnames[] = {
21227 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21228 };
21229
21230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21232 if (SWIG_arg_fail(1)) SWIG_fail;
21233 {
21234 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21235 temp2 = true;
21236 }
21237 if (obj2) {
21238 {
21239 arg3 = (bool)(SWIG_As_bool(obj2));
21240 if (SWIG_arg_fail(3)) SWIG_fail;
21241 }
21242 }
21243 {
21244 PyThreadState* __tstate = wxPyBeginAllowThreads();
21245 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21246
21247 wxPyEndAllowThreads(__tstate);
21248 if (PyErr_Occurred()) SWIG_fail;
21249 }
21250 {
21251 wxDateTime * resultptr;
21252 resultptr = new wxDateTime((wxDateTime &)(result));
21253 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21254 }
21255 {
21256 if (temp2) delete arg2;
21257 }
21258 return resultobj;
21259 fail:
21260 {
21261 if (temp2) delete arg2;
21262 }
21263 return NULL;
21264 }
21265
21266
21267 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21268 PyObject *resultobj;
21269 wxDateTime *arg1 = (wxDateTime *) 0 ;
21270 wxDateTime::TimeZone *arg2 = 0 ;
21271 bool arg3 = (bool) false ;
21272 wxDateTime *result;
21273 bool temp2 = false ;
21274 PyObject * obj0 = 0 ;
21275 PyObject * obj1 = 0 ;
21276 PyObject * obj2 = 0 ;
21277 char *kwnames[] = {
21278 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21279 };
21280
21281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21283 if (SWIG_arg_fail(1)) SWIG_fail;
21284 {
21285 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21286 temp2 = true;
21287 }
21288 if (obj2) {
21289 {
21290 arg3 = (bool)(SWIG_As_bool(obj2));
21291 if (SWIG_arg_fail(3)) SWIG_fail;
21292 }
21293 }
21294 {
21295 PyThreadState* __tstate = wxPyBeginAllowThreads();
21296 {
21297 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21298 result = (wxDateTime *) &_result_ref;
21299 }
21300
21301 wxPyEndAllowThreads(__tstate);
21302 if (PyErr_Occurred()) SWIG_fail;
21303 }
21304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21305 {
21306 if (temp2) delete arg2;
21307 }
21308 return resultobj;
21309 fail:
21310 {
21311 if (temp2) delete arg2;
21312 }
21313 return NULL;
21314 }
21315
21316
21317 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21318 PyObject *resultobj;
21319 wxDateTime *arg1 = (wxDateTime *) 0 ;
21320 bool arg2 = (bool) false ;
21321 wxDateTime result;
21322 PyObject * obj0 = 0 ;
21323 PyObject * obj1 = 0 ;
21324 char *kwnames[] = {
21325 (char *) "self",(char *) "noDST", NULL
21326 };
21327
21328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21330 if (SWIG_arg_fail(1)) SWIG_fail;
21331 if (obj1) {
21332 {
21333 arg2 = (bool)(SWIG_As_bool(obj1));
21334 if (SWIG_arg_fail(2)) SWIG_fail;
21335 }
21336 }
21337 {
21338 PyThreadState* __tstate = wxPyBeginAllowThreads();
21339 result = (arg1)->ToGMT(arg2);
21340
21341 wxPyEndAllowThreads(__tstate);
21342 if (PyErr_Occurred()) SWIG_fail;
21343 }
21344 {
21345 wxDateTime * resultptr;
21346 resultptr = new wxDateTime((wxDateTime &)(result));
21347 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21348 }
21349 return resultobj;
21350 fail:
21351 return NULL;
21352 }
21353
21354
21355 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21356 PyObject *resultobj;
21357 wxDateTime *arg1 = (wxDateTime *) 0 ;
21358 bool arg2 = (bool) false ;
21359 wxDateTime *result;
21360 PyObject * obj0 = 0 ;
21361 PyObject * obj1 = 0 ;
21362 char *kwnames[] = {
21363 (char *) "self",(char *) "noDST", NULL
21364 };
21365
21366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21368 if (SWIG_arg_fail(1)) SWIG_fail;
21369 if (obj1) {
21370 {
21371 arg2 = (bool)(SWIG_As_bool(obj1));
21372 if (SWIG_arg_fail(2)) SWIG_fail;
21373 }
21374 }
21375 {
21376 PyThreadState* __tstate = wxPyBeginAllowThreads();
21377 {
21378 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21379 result = (wxDateTime *) &_result_ref;
21380 }
21381
21382 wxPyEndAllowThreads(__tstate);
21383 if (PyErr_Occurred()) SWIG_fail;
21384 }
21385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21386 return resultobj;
21387 fail:
21388 return NULL;
21389 }
21390
21391
21392 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21393 PyObject *resultobj;
21394 wxDateTime *arg1 = (wxDateTime *) 0 ;
21395 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21396 int result;
21397 PyObject * obj0 = 0 ;
21398 PyObject * obj1 = 0 ;
21399 char *kwnames[] = {
21400 (char *) "self",(char *) "country", NULL
21401 };
21402
21403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21405 if (SWIG_arg_fail(1)) SWIG_fail;
21406 if (obj1) {
21407 {
21408 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21409 if (SWIG_arg_fail(2)) SWIG_fail;
21410 }
21411 }
21412 {
21413 PyThreadState* __tstate = wxPyBeginAllowThreads();
21414 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21415
21416 wxPyEndAllowThreads(__tstate);
21417 if (PyErr_Occurred()) SWIG_fail;
21418 }
21419 {
21420 resultobj = SWIG_From_int((int)(result));
21421 }
21422 return resultobj;
21423 fail:
21424 return NULL;
21425 }
21426
21427
21428 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21429 PyObject *resultobj;
21430 wxDateTime *arg1 = (wxDateTime *) 0 ;
21431 bool result;
21432 PyObject * obj0 = 0 ;
21433 char *kwnames[] = {
21434 (char *) "self", NULL
21435 };
21436
21437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21439 if (SWIG_arg_fail(1)) SWIG_fail;
21440 {
21441 PyThreadState* __tstate = wxPyBeginAllowThreads();
21442 result = (bool)((wxDateTime const *)arg1)->IsValid();
21443
21444 wxPyEndAllowThreads(__tstate);
21445 if (PyErr_Occurred()) SWIG_fail;
21446 }
21447 {
21448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21449 }
21450 return resultobj;
21451 fail:
21452 return NULL;
21453 }
21454
21455
21456 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21457 PyObject *resultobj;
21458 wxDateTime *arg1 = (wxDateTime *) 0 ;
21459 time_t result;
21460 PyObject * obj0 = 0 ;
21461 char *kwnames[] = {
21462 (char *) "self", NULL
21463 };
21464
21465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21467 if (SWIG_arg_fail(1)) SWIG_fail;
21468 {
21469 PyThreadState* __tstate = wxPyBeginAllowThreads();
21470 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21471
21472 wxPyEndAllowThreads(__tstate);
21473 if (PyErr_Occurred()) SWIG_fail;
21474 }
21475 {
21476 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21477 }
21478 return resultobj;
21479 fail:
21480 return NULL;
21481 }
21482
21483
21484 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21485 PyObject *resultobj;
21486 wxDateTime *arg1 = (wxDateTime *) 0 ;
21487 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21488 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21489 int result;
21490 bool temp2 = false ;
21491 PyObject * obj0 = 0 ;
21492 PyObject * obj1 = 0 ;
21493 char *kwnames[] = {
21494 (char *) "self",(char *) "tz", NULL
21495 };
21496
21497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21499 if (SWIG_arg_fail(1)) SWIG_fail;
21500 if (obj1) {
21501 {
21502 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21503 temp2 = true;
21504 }
21505 }
21506 {
21507 PyThreadState* __tstate = wxPyBeginAllowThreads();
21508 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21509
21510 wxPyEndAllowThreads(__tstate);
21511 if (PyErr_Occurred()) SWIG_fail;
21512 }
21513 {
21514 resultobj = SWIG_From_int((int)(result));
21515 }
21516 {
21517 if (temp2) delete arg2;
21518 }
21519 return resultobj;
21520 fail:
21521 {
21522 if (temp2) delete arg2;
21523 }
21524 return NULL;
21525 }
21526
21527
21528 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21529 PyObject *resultobj;
21530 wxDateTime *arg1 = (wxDateTime *) 0 ;
21531 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21532 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21533 wxDateTime::Month result;
21534 bool temp2 = false ;
21535 PyObject * obj0 = 0 ;
21536 PyObject * obj1 = 0 ;
21537 char *kwnames[] = {
21538 (char *) "self",(char *) "tz", NULL
21539 };
21540
21541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21543 if (SWIG_arg_fail(1)) SWIG_fail;
21544 if (obj1) {
21545 {
21546 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21547 temp2 = true;
21548 }
21549 }
21550 {
21551 PyThreadState* __tstate = wxPyBeginAllowThreads();
21552 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21553
21554 wxPyEndAllowThreads(__tstate);
21555 if (PyErr_Occurred()) SWIG_fail;
21556 }
21557 resultobj = SWIG_From_int((result));
21558 {
21559 if (temp2) delete arg2;
21560 }
21561 return resultobj;
21562 fail:
21563 {
21564 if (temp2) delete arg2;
21565 }
21566 return NULL;
21567 }
21568
21569
21570 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21571 PyObject *resultobj;
21572 wxDateTime *arg1 = (wxDateTime *) 0 ;
21573 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21574 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21575 int result;
21576 bool temp2 = false ;
21577 PyObject * obj0 = 0 ;
21578 PyObject * obj1 = 0 ;
21579 char *kwnames[] = {
21580 (char *) "self",(char *) "tz", NULL
21581 };
21582
21583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21585 if (SWIG_arg_fail(1)) SWIG_fail;
21586 if (obj1) {
21587 {
21588 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21589 temp2 = true;
21590 }
21591 }
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 {
21600 resultobj = SWIG_From_int((int)(result));
21601 }
21602 {
21603 if (temp2) delete arg2;
21604 }
21605 return resultobj;
21606 fail:
21607 {
21608 if (temp2) delete arg2;
21609 }
21610 return NULL;
21611 }
21612
21613
21614 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21615 PyObject *resultobj;
21616 wxDateTime *arg1 = (wxDateTime *) 0 ;
21617 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21618 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21619 wxDateTime::WeekDay result;
21620 bool temp2 = false ;
21621 PyObject * obj0 = 0 ;
21622 PyObject * obj1 = 0 ;
21623 char *kwnames[] = {
21624 (char *) "self",(char *) "tz", NULL
21625 };
21626
21627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21629 if (SWIG_arg_fail(1)) SWIG_fail;
21630 if (obj1) {
21631 {
21632 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21633 temp2 = true;
21634 }
21635 }
21636 {
21637 PyThreadState* __tstate = wxPyBeginAllowThreads();
21638 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21639
21640 wxPyEndAllowThreads(__tstate);
21641 if (PyErr_Occurred()) SWIG_fail;
21642 }
21643 resultobj = SWIG_From_int((result));
21644 {
21645 if (temp2) delete arg2;
21646 }
21647 return resultobj;
21648 fail:
21649 {
21650 if (temp2) delete arg2;
21651 }
21652 return NULL;
21653 }
21654
21655
21656 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21657 PyObject *resultobj;
21658 wxDateTime *arg1 = (wxDateTime *) 0 ;
21659 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21660 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21661 int result;
21662 bool temp2 = false ;
21663 PyObject * obj0 = 0 ;
21664 PyObject * obj1 = 0 ;
21665 char *kwnames[] = {
21666 (char *) "self",(char *) "tz", NULL
21667 };
21668
21669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21671 if (SWIG_arg_fail(1)) SWIG_fail;
21672 if (obj1) {
21673 {
21674 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21675 temp2 = true;
21676 }
21677 }
21678 {
21679 PyThreadState* __tstate = wxPyBeginAllowThreads();
21680 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21681
21682 wxPyEndAllowThreads(__tstate);
21683 if (PyErr_Occurred()) SWIG_fail;
21684 }
21685 {
21686 resultobj = SWIG_From_int((int)(result));
21687 }
21688 {
21689 if (temp2) delete arg2;
21690 }
21691 return resultobj;
21692 fail:
21693 {
21694 if (temp2) delete arg2;
21695 }
21696 return NULL;
21697 }
21698
21699
21700 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21701 PyObject *resultobj;
21702 wxDateTime *arg1 = (wxDateTime *) 0 ;
21703 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21704 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21705 int result;
21706 bool temp2 = false ;
21707 PyObject * obj0 = 0 ;
21708 PyObject * obj1 = 0 ;
21709 char *kwnames[] = {
21710 (char *) "self",(char *) "tz", NULL
21711 };
21712
21713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21715 if (SWIG_arg_fail(1)) SWIG_fail;
21716 if (obj1) {
21717 {
21718 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21719 temp2 = true;
21720 }
21721 }
21722 {
21723 PyThreadState* __tstate = wxPyBeginAllowThreads();
21724 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21725
21726 wxPyEndAllowThreads(__tstate);
21727 if (PyErr_Occurred()) SWIG_fail;
21728 }
21729 {
21730 resultobj = SWIG_From_int((int)(result));
21731 }
21732 {
21733 if (temp2) delete arg2;
21734 }
21735 return resultobj;
21736 fail:
21737 {
21738 if (temp2) delete arg2;
21739 }
21740 return NULL;
21741 }
21742
21743
21744 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj;
21746 wxDateTime *arg1 = (wxDateTime *) 0 ;
21747 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21748 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21749 int result;
21750 bool temp2 = false ;
21751 PyObject * obj0 = 0 ;
21752 PyObject * obj1 = 0 ;
21753 char *kwnames[] = {
21754 (char *) "self",(char *) "tz", NULL
21755 };
21756
21757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21759 if (SWIG_arg_fail(1)) SWIG_fail;
21760 if (obj1) {
21761 {
21762 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21763 temp2 = true;
21764 }
21765 }
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21769
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 {
21774 resultobj = SWIG_From_int((int)(result));
21775 }
21776 {
21777 if (temp2) delete arg2;
21778 }
21779 return resultobj;
21780 fail:
21781 {
21782 if (temp2) delete arg2;
21783 }
21784 return NULL;
21785 }
21786
21787
21788 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21789 PyObject *resultobj;
21790 wxDateTime *arg1 = (wxDateTime *) 0 ;
21791 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21792 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21793 int result;
21794 bool temp2 = false ;
21795 PyObject * obj0 = 0 ;
21796 PyObject * obj1 = 0 ;
21797 char *kwnames[] = {
21798 (char *) "self",(char *) "tz", NULL
21799 };
21800
21801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21803 if (SWIG_arg_fail(1)) SWIG_fail;
21804 if (obj1) {
21805 {
21806 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21807 temp2 = true;
21808 }
21809 }
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21813
21814 wxPyEndAllowThreads(__tstate);
21815 if (PyErr_Occurred()) SWIG_fail;
21816 }
21817 {
21818 resultobj = SWIG_From_int((int)(result));
21819 }
21820 {
21821 if (temp2) delete arg2;
21822 }
21823 return resultobj;
21824 fail:
21825 {
21826 if (temp2) delete arg2;
21827 }
21828 return NULL;
21829 }
21830
21831
21832 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21833 PyObject *resultobj;
21834 wxDateTime *arg1 = (wxDateTime *) 0 ;
21835 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21836 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21837 int result;
21838 bool temp2 = false ;
21839 PyObject * obj0 = 0 ;
21840 PyObject * obj1 = 0 ;
21841 char *kwnames[] = {
21842 (char *) "self",(char *) "tz", NULL
21843 };
21844
21845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21847 if (SWIG_arg_fail(1)) SWIG_fail;
21848 if (obj1) {
21849 {
21850 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21851 temp2 = true;
21852 }
21853 }
21854 {
21855 PyThreadState* __tstate = wxPyBeginAllowThreads();
21856 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21857
21858 wxPyEndAllowThreads(__tstate);
21859 if (PyErr_Occurred()) SWIG_fail;
21860 }
21861 {
21862 resultobj = SWIG_From_int((int)(result));
21863 }
21864 {
21865 if (temp2) delete arg2;
21866 }
21867 return resultobj;
21868 fail:
21869 {
21870 if (temp2) delete arg2;
21871 }
21872 return NULL;
21873 }
21874
21875
21876 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21877 PyObject *resultobj;
21878 wxDateTime *arg1 = (wxDateTime *) 0 ;
21879 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21880 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21881 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21882 int result;
21883 bool temp3 = false ;
21884 PyObject * obj0 = 0 ;
21885 PyObject * obj1 = 0 ;
21886 PyObject * obj2 = 0 ;
21887 char *kwnames[] = {
21888 (char *) "self",(char *) "flags",(char *) "tz", NULL
21889 };
21890
21891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) 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 if (obj1) {
21895 {
21896 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21897 if (SWIG_arg_fail(2)) SWIG_fail;
21898 }
21899 }
21900 if (obj2) {
21901 {
21902 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21903 temp3 = true;
21904 }
21905 }
21906 {
21907 PyThreadState* __tstate = wxPyBeginAllowThreads();
21908 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21909
21910 wxPyEndAllowThreads(__tstate);
21911 if (PyErr_Occurred()) SWIG_fail;
21912 }
21913 {
21914 resultobj = SWIG_From_int((int)(result));
21915 }
21916 {
21917 if (temp3) delete arg3;
21918 }
21919 return resultobj;
21920 fail:
21921 {
21922 if (temp3) delete arg3;
21923 }
21924 return NULL;
21925 }
21926
21927
21928 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21929 PyObject *resultobj;
21930 wxDateTime *arg1 = (wxDateTime *) 0 ;
21931 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21932 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21933 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21934 int result;
21935 bool temp3 = false ;
21936 PyObject * obj0 = 0 ;
21937 PyObject * obj1 = 0 ;
21938 PyObject * obj2 = 0 ;
21939 char *kwnames[] = {
21940 (char *) "self",(char *) "flags",(char *) "tz", NULL
21941 };
21942
21943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21945 if (SWIG_arg_fail(1)) SWIG_fail;
21946 if (obj1) {
21947 {
21948 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21949 if (SWIG_arg_fail(2)) SWIG_fail;
21950 }
21951 }
21952 if (obj2) {
21953 {
21954 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21955 temp3 = true;
21956 }
21957 }
21958 {
21959 PyThreadState* __tstate = wxPyBeginAllowThreads();
21960 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21961
21962 wxPyEndAllowThreads(__tstate);
21963 if (PyErr_Occurred()) SWIG_fail;
21964 }
21965 {
21966 resultobj = SWIG_From_int((int)(result));
21967 }
21968 {
21969 if (temp3) delete arg3;
21970 }
21971 return resultobj;
21972 fail:
21973 {
21974 if (temp3) delete arg3;
21975 }
21976 return NULL;
21977 }
21978
21979
21980 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21981 PyObject *resultobj;
21982 wxDateTime *arg1 = (wxDateTime *) 0 ;
21983 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21984 bool result;
21985 PyObject * obj0 = 0 ;
21986 PyObject * obj1 = 0 ;
21987 char *kwnames[] = {
21988 (char *) "self",(char *) "country", NULL
21989 };
21990
21991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21993 if (SWIG_arg_fail(1)) SWIG_fail;
21994 if (obj1) {
21995 {
21996 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21997 if (SWIG_arg_fail(2)) SWIG_fail;
21998 }
21999 }
22000 {
22001 PyThreadState* __tstate = wxPyBeginAllowThreads();
22002 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22003
22004 wxPyEndAllowThreads(__tstate);
22005 if (PyErr_Occurred()) SWIG_fail;
22006 }
22007 {
22008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22009 }
22010 return resultobj;
22011 fail:
22012 return NULL;
22013 }
22014
22015
22016 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22017 PyObject *resultobj;
22018 wxDateTime *arg1 = (wxDateTime *) 0 ;
22019 wxDateTime *arg2 = 0 ;
22020 bool result;
22021 PyObject * obj0 = 0 ;
22022 PyObject * obj1 = 0 ;
22023 char *kwnames[] = {
22024 (char *) "self",(char *) "datetime", NULL
22025 };
22026
22027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22029 if (SWIG_arg_fail(1)) SWIG_fail;
22030 {
22031 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22032 if (SWIG_arg_fail(2)) SWIG_fail;
22033 if (arg2 == NULL) {
22034 SWIG_null_ref("wxDateTime");
22035 }
22036 if (SWIG_arg_fail(2)) SWIG_fail;
22037 }
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22041
22042 wxPyEndAllowThreads(__tstate);
22043 if (PyErr_Occurred()) SWIG_fail;
22044 }
22045 {
22046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22047 }
22048 return resultobj;
22049 fail:
22050 return NULL;
22051 }
22052
22053
22054 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22055 PyObject *resultobj;
22056 wxDateTime *arg1 = (wxDateTime *) 0 ;
22057 wxDateTime *arg2 = 0 ;
22058 bool result;
22059 PyObject * obj0 = 0 ;
22060 PyObject * obj1 = 0 ;
22061 char *kwnames[] = {
22062 (char *) "self",(char *) "datetime", NULL
22063 };
22064
22065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22067 if (SWIG_arg_fail(1)) SWIG_fail;
22068 {
22069 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22070 if (SWIG_arg_fail(2)) SWIG_fail;
22071 if (arg2 == NULL) {
22072 SWIG_null_ref("wxDateTime");
22073 }
22074 if (SWIG_arg_fail(2)) SWIG_fail;
22075 }
22076 {
22077 PyThreadState* __tstate = wxPyBeginAllowThreads();
22078 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22079
22080 wxPyEndAllowThreads(__tstate);
22081 if (PyErr_Occurred()) SWIG_fail;
22082 }
22083 {
22084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22085 }
22086 return resultobj;
22087 fail:
22088 return NULL;
22089 }
22090
22091
22092 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22093 PyObject *resultobj;
22094 wxDateTime *arg1 = (wxDateTime *) 0 ;
22095 wxDateTime *arg2 = 0 ;
22096 bool result;
22097 PyObject * obj0 = 0 ;
22098 PyObject * obj1 = 0 ;
22099 char *kwnames[] = {
22100 (char *) "self",(char *) "datetime", NULL
22101 };
22102
22103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22117
22118 wxPyEndAllowThreads(__tstate);
22119 if (PyErr_Occurred()) SWIG_fail;
22120 }
22121 {
22122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22123 }
22124 return resultobj;
22125 fail:
22126 return NULL;
22127 }
22128
22129
22130 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22131 PyObject *resultobj;
22132 wxDateTime *arg1 = (wxDateTime *) 0 ;
22133 wxDateTime *arg2 = 0 ;
22134 wxDateTime *arg3 = 0 ;
22135 bool result;
22136 PyObject * obj0 = 0 ;
22137 PyObject * obj1 = 0 ;
22138 PyObject * obj2 = 0 ;
22139 char *kwnames[] = {
22140 (char *) "self",(char *) "t1",(char *) "t2", NULL
22141 };
22142
22143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22145 if (SWIG_arg_fail(1)) SWIG_fail;
22146 {
22147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22148 if (SWIG_arg_fail(2)) SWIG_fail;
22149 if (arg2 == NULL) {
22150 SWIG_null_ref("wxDateTime");
22151 }
22152 if (SWIG_arg_fail(2)) SWIG_fail;
22153 }
22154 {
22155 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22156 if (SWIG_arg_fail(3)) SWIG_fail;
22157 if (arg3 == NULL) {
22158 SWIG_null_ref("wxDateTime");
22159 }
22160 if (SWIG_arg_fail(3)) SWIG_fail;
22161 }
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22165
22166 wxPyEndAllowThreads(__tstate);
22167 if (PyErr_Occurred()) SWIG_fail;
22168 }
22169 {
22170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22171 }
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22179 PyObject *resultobj;
22180 wxDateTime *arg1 = (wxDateTime *) 0 ;
22181 wxDateTime *arg2 = 0 ;
22182 wxDateTime *arg3 = 0 ;
22183 bool result;
22184 PyObject * obj0 = 0 ;
22185 PyObject * obj1 = 0 ;
22186 PyObject * obj2 = 0 ;
22187 char *kwnames[] = {
22188 (char *) "self",(char *) "t1",(char *) "t2", NULL
22189 };
22190
22191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22193 if (SWIG_arg_fail(1)) SWIG_fail;
22194 {
22195 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22196 if (SWIG_arg_fail(2)) SWIG_fail;
22197 if (arg2 == NULL) {
22198 SWIG_null_ref("wxDateTime");
22199 }
22200 if (SWIG_arg_fail(2)) SWIG_fail;
22201 }
22202 {
22203 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22204 if (SWIG_arg_fail(3)) SWIG_fail;
22205 if (arg3 == NULL) {
22206 SWIG_null_ref("wxDateTime");
22207 }
22208 if (SWIG_arg_fail(3)) SWIG_fail;
22209 }
22210 {
22211 PyThreadState* __tstate = wxPyBeginAllowThreads();
22212 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22213
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 {
22218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22219 }
22220 return resultobj;
22221 fail:
22222 return NULL;
22223 }
22224
22225
22226 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22227 PyObject *resultobj;
22228 wxDateTime *arg1 = (wxDateTime *) 0 ;
22229 wxDateTime *arg2 = 0 ;
22230 bool result;
22231 PyObject * obj0 = 0 ;
22232 PyObject * obj1 = 0 ;
22233 char *kwnames[] = {
22234 (char *) "self",(char *) "dt", NULL
22235 };
22236
22237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22239 if (SWIG_arg_fail(1)) SWIG_fail;
22240 {
22241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22242 if (SWIG_arg_fail(2)) SWIG_fail;
22243 if (arg2 == NULL) {
22244 SWIG_null_ref("wxDateTime");
22245 }
22246 if (SWIG_arg_fail(2)) SWIG_fail;
22247 }
22248 {
22249 PyThreadState* __tstate = wxPyBeginAllowThreads();
22250 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22251
22252 wxPyEndAllowThreads(__tstate);
22253 if (PyErr_Occurred()) SWIG_fail;
22254 }
22255 {
22256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22257 }
22258 return resultobj;
22259 fail:
22260 return NULL;
22261 }
22262
22263
22264 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22265 PyObject *resultobj;
22266 wxDateTime *arg1 = (wxDateTime *) 0 ;
22267 wxDateTime *arg2 = 0 ;
22268 bool result;
22269 PyObject * obj0 = 0 ;
22270 PyObject * obj1 = 0 ;
22271 char *kwnames[] = {
22272 (char *) "self",(char *) "dt", NULL
22273 };
22274
22275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22277 if (SWIG_arg_fail(1)) SWIG_fail;
22278 {
22279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22280 if (SWIG_arg_fail(2)) SWIG_fail;
22281 if (arg2 == NULL) {
22282 SWIG_null_ref("wxDateTime");
22283 }
22284 if (SWIG_arg_fail(2)) SWIG_fail;
22285 }
22286 {
22287 PyThreadState* __tstate = wxPyBeginAllowThreads();
22288 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22289
22290 wxPyEndAllowThreads(__tstate);
22291 if (PyErr_Occurred()) SWIG_fail;
22292 }
22293 {
22294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22295 }
22296 return resultobj;
22297 fail:
22298 return NULL;
22299 }
22300
22301
22302 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22303 PyObject *resultobj;
22304 wxDateTime *arg1 = (wxDateTime *) 0 ;
22305 wxDateTime *arg2 = 0 ;
22306 wxTimeSpan *arg3 = 0 ;
22307 bool result;
22308 PyObject * obj0 = 0 ;
22309 PyObject * obj1 = 0 ;
22310 PyObject * obj2 = 0 ;
22311 char *kwnames[] = {
22312 (char *) "self",(char *) "dt",(char *) "ts", NULL
22313 };
22314
22315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22317 if (SWIG_arg_fail(1)) SWIG_fail;
22318 {
22319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22320 if (SWIG_arg_fail(2)) SWIG_fail;
22321 if (arg2 == NULL) {
22322 SWIG_null_ref("wxDateTime");
22323 }
22324 if (SWIG_arg_fail(2)) SWIG_fail;
22325 }
22326 {
22327 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22328 if (SWIG_arg_fail(3)) SWIG_fail;
22329 if (arg3 == NULL) {
22330 SWIG_null_ref("wxTimeSpan");
22331 }
22332 if (SWIG_arg_fail(3)) SWIG_fail;
22333 }
22334 {
22335 PyThreadState* __tstate = wxPyBeginAllowThreads();
22336 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22337
22338 wxPyEndAllowThreads(__tstate);
22339 if (PyErr_Occurred()) SWIG_fail;
22340 }
22341 {
22342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22343 }
22344 return resultobj;
22345 fail:
22346 return NULL;
22347 }
22348
22349
22350 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22351 PyObject *resultobj;
22352 wxDateTime *arg1 = (wxDateTime *) 0 ;
22353 wxTimeSpan *arg2 = 0 ;
22354 wxDateTime *result;
22355 PyObject * obj0 = 0 ;
22356 PyObject * obj1 = 0 ;
22357 char *kwnames[] = {
22358 (char *) "self",(char *) "diff", NULL
22359 };
22360
22361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22363 if (SWIG_arg_fail(1)) SWIG_fail;
22364 {
22365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22366 if (SWIG_arg_fail(2)) SWIG_fail;
22367 if (arg2 == NULL) {
22368 SWIG_null_ref("wxTimeSpan");
22369 }
22370 if (SWIG_arg_fail(2)) SWIG_fail;
22371 }
22372 {
22373 PyThreadState* __tstate = wxPyBeginAllowThreads();
22374 {
22375 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22376 result = (wxDateTime *) &_result_ref;
22377 }
22378
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22383 return resultobj;
22384 fail:
22385 return NULL;
22386 }
22387
22388
22389 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22390 PyObject *resultobj;
22391 wxDateTime *arg1 = (wxDateTime *) 0 ;
22392 wxDateSpan *arg2 = 0 ;
22393 wxDateTime *result;
22394 PyObject * obj0 = 0 ;
22395 PyObject * obj1 = 0 ;
22396 char *kwnames[] = {
22397 (char *) "self",(char *) "diff", NULL
22398 };
22399
22400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22402 if (SWIG_arg_fail(1)) SWIG_fail;
22403 {
22404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22405 if (SWIG_arg_fail(2)) SWIG_fail;
22406 if (arg2 == NULL) {
22407 SWIG_null_ref("wxDateSpan");
22408 }
22409 if (SWIG_arg_fail(2)) SWIG_fail;
22410 }
22411 {
22412 PyThreadState* __tstate = wxPyBeginAllowThreads();
22413 {
22414 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22415 result = (wxDateTime *) &_result_ref;
22416 }
22417
22418 wxPyEndAllowThreads(__tstate);
22419 if (PyErr_Occurred()) SWIG_fail;
22420 }
22421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22429 PyObject *resultobj;
22430 wxDateTime *arg1 = (wxDateTime *) 0 ;
22431 wxTimeSpan *arg2 = 0 ;
22432 wxDateTime *result;
22433 PyObject * obj0 = 0 ;
22434 PyObject * obj1 = 0 ;
22435 char *kwnames[] = {
22436 (char *) "self",(char *) "diff", NULL
22437 };
22438
22439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22441 if (SWIG_arg_fail(1)) SWIG_fail;
22442 {
22443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22444 if (SWIG_arg_fail(2)) SWIG_fail;
22445 if (arg2 == NULL) {
22446 SWIG_null_ref("wxTimeSpan");
22447 }
22448 if (SWIG_arg_fail(2)) SWIG_fail;
22449 }
22450 {
22451 PyThreadState* __tstate = wxPyBeginAllowThreads();
22452 {
22453 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22454 result = (wxDateTime *) &_result_ref;
22455 }
22456
22457 wxPyEndAllowThreads(__tstate);
22458 if (PyErr_Occurred()) SWIG_fail;
22459 }
22460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22461 return resultobj;
22462 fail:
22463 return NULL;
22464 }
22465
22466
22467 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22468 PyObject *resultobj;
22469 wxDateTime *arg1 = (wxDateTime *) 0 ;
22470 wxDateSpan *arg2 = 0 ;
22471 wxDateTime *result;
22472 PyObject * obj0 = 0 ;
22473 PyObject * obj1 = 0 ;
22474 char *kwnames[] = {
22475 (char *) "self",(char *) "diff", NULL
22476 };
22477
22478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22480 if (SWIG_arg_fail(1)) SWIG_fail;
22481 {
22482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22483 if (SWIG_arg_fail(2)) SWIG_fail;
22484 if (arg2 == NULL) {
22485 SWIG_null_ref("wxDateSpan");
22486 }
22487 if (SWIG_arg_fail(2)) SWIG_fail;
22488 }
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 {
22492 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22493 result = (wxDateTime *) &_result_ref;
22494 }
22495
22496 wxPyEndAllowThreads(__tstate);
22497 if (PyErr_Occurred()) SWIG_fail;
22498 }
22499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22500 return resultobj;
22501 fail:
22502 return NULL;
22503 }
22504
22505
22506 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22507 PyObject *resultobj;
22508 wxDateTime *arg1 = (wxDateTime *) 0 ;
22509 wxDateTime *arg2 = 0 ;
22510 wxTimeSpan result;
22511 PyObject * obj0 = 0 ;
22512 PyObject * obj1 = 0 ;
22513 char *kwnames[] = {
22514 (char *) "self",(char *) "dt", NULL
22515 };
22516
22517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22519 if (SWIG_arg_fail(1)) SWIG_fail;
22520 {
22521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22522 if (SWIG_arg_fail(2)) SWIG_fail;
22523 if (arg2 == NULL) {
22524 SWIG_null_ref("wxDateTime");
22525 }
22526 if (SWIG_arg_fail(2)) SWIG_fail;
22527 }
22528 {
22529 PyThreadState* __tstate = wxPyBeginAllowThreads();
22530 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22531
22532 wxPyEndAllowThreads(__tstate);
22533 if (PyErr_Occurred()) SWIG_fail;
22534 }
22535 {
22536 wxTimeSpan * resultptr;
22537 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22538 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22539 }
22540 return resultobj;
22541 fail:
22542 return NULL;
22543 }
22544
22545
22546 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22547 PyObject *resultobj;
22548 wxDateTime *arg1 = (wxDateTime *) 0 ;
22549 wxTimeSpan *arg2 = 0 ;
22550 wxDateTime *result;
22551 PyObject * obj0 = 0 ;
22552 PyObject * obj1 = 0 ;
22553
22554 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22556 if (SWIG_arg_fail(1)) SWIG_fail;
22557 {
22558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22559 if (SWIG_arg_fail(2)) SWIG_fail;
22560 if (arg2 == NULL) {
22561 SWIG_null_ref("wxTimeSpan");
22562 }
22563 if (SWIG_arg_fail(2)) SWIG_fail;
22564 }
22565 {
22566 PyThreadState* __tstate = wxPyBeginAllowThreads();
22567 {
22568 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22569 result = (wxDateTime *) &_result_ref;
22570 }
22571
22572 wxPyEndAllowThreads(__tstate);
22573 if (PyErr_Occurred()) SWIG_fail;
22574 }
22575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22583 PyObject *resultobj;
22584 wxDateTime *arg1 = (wxDateTime *) 0 ;
22585 wxDateSpan *arg2 = 0 ;
22586 wxDateTime *result;
22587 PyObject * obj0 = 0 ;
22588 PyObject * obj1 = 0 ;
22589
22590 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22592 if (SWIG_arg_fail(1)) SWIG_fail;
22593 {
22594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22595 if (SWIG_arg_fail(2)) SWIG_fail;
22596 if (arg2 == NULL) {
22597 SWIG_null_ref("wxDateSpan");
22598 }
22599 if (SWIG_arg_fail(2)) SWIG_fail;
22600 }
22601 {
22602 PyThreadState* __tstate = wxPyBeginAllowThreads();
22603 {
22604 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22605 result = (wxDateTime *) &_result_ref;
22606 }
22607
22608 wxPyEndAllowThreads(__tstate);
22609 if (PyErr_Occurred()) SWIG_fail;
22610 }
22611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22612 return resultobj;
22613 fail:
22614 return NULL;
22615 }
22616
22617
22618 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22619 int argc;
22620 PyObject *argv[3];
22621 int ii;
22622
22623 argc = PyObject_Length(args);
22624 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22625 argv[ii] = PyTuple_GetItem(args,ii);
22626 }
22627 if (argc == 2) {
22628 int _v;
22629 {
22630 void *ptr;
22631 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22632 _v = 0;
22633 PyErr_Clear();
22634 } else {
22635 _v = 1;
22636 }
22637 }
22638 if (_v) {
22639 {
22640 void *ptr = 0;
22641 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22642 _v = 0;
22643 PyErr_Clear();
22644 } else {
22645 _v = (ptr != 0);
22646 }
22647 }
22648 if (_v) {
22649 return _wrap_DateTime___iadd____SWIG_0(self,args);
22650 }
22651 }
22652 }
22653 if (argc == 2) {
22654 int _v;
22655 {
22656 void *ptr;
22657 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22658 _v = 0;
22659 PyErr_Clear();
22660 } else {
22661 _v = 1;
22662 }
22663 }
22664 if (_v) {
22665 {
22666 void *ptr = 0;
22667 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22668 _v = 0;
22669 PyErr_Clear();
22670 } else {
22671 _v = (ptr != 0);
22672 }
22673 }
22674 if (_v) {
22675 return _wrap_DateTime___iadd____SWIG_1(self,args);
22676 }
22677 }
22678 }
22679
22680 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22681 return NULL;
22682 }
22683
22684
22685 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22686 PyObject *resultobj;
22687 wxDateTime *arg1 = (wxDateTime *) 0 ;
22688 wxTimeSpan *arg2 = 0 ;
22689 wxDateTime *result;
22690 PyObject * obj0 = 0 ;
22691 PyObject * obj1 = 0 ;
22692
22693 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22695 if (SWIG_arg_fail(1)) SWIG_fail;
22696 {
22697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22698 if (SWIG_arg_fail(2)) SWIG_fail;
22699 if (arg2 == NULL) {
22700 SWIG_null_ref("wxTimeSpan");
22701 }
22702 if (SWIG_arg_fail(2)) SWIG_fail;
22703 }
22704 {
22705 PyThreadState* __tstate = wxPyBeginAllowThreads();
22706 {
22707 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22708 result = (wxDateTime *) &_result_ref;
22709 }
22710
22711 wxPyEndAllowThreads(__tstate);
22712 if (PyErr_Occurred()) SWIG_fail;
22713 }
22714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22715 return resultobj;
22716 fail:
22717 return NULL;
22718 }
22719
22720
22721 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22722 PyObject *resultobj;
22723 wxDateTime *arg1 = (wxDateTime *) 0 ;
22724 wxDateSpan *arg2 = 0 ;
22725 wxDateTime *result;
22726 PyObject * obj0 = 0 ;
22727 PyObject * obj1 = 0 ;
22728
22729 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22731 if (SWIG_arg_fail(1)) SWIG_fail;
22732 {
22733 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22734 if (SWIG_arg_fail(2)) SWIG_fail;
22735 if (arg2 == NULL) {
22736 SWIG_null_ref("wxDateSpan");
22737 }
22738 if (SWIG_arg_fail(2)) SWIG_fail;
22739 }
22740 {
22741 PyThreadState* __tstate = wxPyBeginAllowThreads();
22742 {
22743 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22744 result = (wxDateTime *) &_result_ref;
22745 }
22746
22747 wxPyEndAllowThreads(__tstate);
22748 if (PyErr_Occurred()) SWIG_fail;
22749 }
22750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22751 return resultobj;
22752 fail:
22753 return NULL;
22754 }
22755
22756
22757 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22758 int argc;
22759 PyObject *argv[3];
22760 int ii;
22761
22762 argc = PyObject_Length(args);
22763 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22764 argv[ii] = PyTuple_GetItem(args,ii);
22765 }
22766 if (argc == 2) {
22767 int _v;
22768 {
22769 void *ptr;
22770 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22771 _v = 0;
22772 PyErr_Clear();
22773 } else {
22774 _v = 1;
22775 }
22776 }
22777 if (_v) {
22778 {
22779 void *ptr = 0;
22780 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22781 _v = 0;
22782 PyErr_Clear();
22783 } else {
22784 _v = (ptr != 0);
22785 }
22786 }
22787 if (_v) {
22788 return _wrap_DateTime___isub____SWIG_0(self,args);
22789 }
22790 }
22791 }
22792 if (argc == 2) {
22793 int _v;
22794 {
22795 void *ptr;
22796 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22797 _v = 0;
22798 PyErr_Clear();
22799 } else {
22800 _v = 1;
22801 }
22802 }
22803 if (_v) {
22804 {
22805 void *ptr = 0;
22806 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22807 _v = 0;
22808 PyErr_Clear();
22809 } else {
22810 _v = (ptr != 0);
22811 }
22812 }
22813 if (_v) {
22814 return _wrap_DateTime___isub____SWIG_1(self,args);
22815 }
22816 }
22817 }
22818
22819 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22820 return NULL;
22821 }
22822
22823
22824 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22825 PyObject *resultobj;
22826 wxDateTime *arg1 = (wxDateTime *) 0 ;
22827 wxTimeSpan *arg2 = 0 ;
22828 wxDateTime result;
22829 PyObject * obj0 = 0 ;
22830 PyObject * obj1 = 0 ;
22831
22832 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22834 if (SWIG_arg_fail(1)) SWIG_fail;
22835 {
22836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22837 if (SWIG_arg_fail(2)) SWIG_fail;
22838 if (arg2 == NULL) {
22839 SWIG_null_ref("wxTimeSpan");
22840 }
22841 if (SWIG_arg_fail(2)) SWIG_fail;
22842 }
22843 {
22844 PyThreadState* __tstate = wxPyBeginAllowThreads();
22845 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22846
22847 wxPyEndAllowThreads(__tstate);
22848 if (PyErr_Occurred()) SWIG_fail;
22849 }
22850 {
22851 wxDateTime * resultptr;
22852 resultptr = new wxDateTime((wxDateTime &)(result));
22853 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22854 }
22855 return resultobj;
22856 fail:
22857 return NULL;
22858 }
22859
22860
22861 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22862 PyObject *resultobj;
22863 wxDateTime *arg1 = (wxDateTime *) 0 ;
22864 wxDateSpan *arg2 = 0 ;
22865 wxDateTime result;
22866 PyObject * obj0 = 0 ;
22867 PyObject * obj1 = 0 ;
22868
22869 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22871 if (SWIG_arg_fail(1)) SWIG_fail;
22872 {
22873 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22874 if (SWIG_arg_fail(2)) SWIG_fail;
22875 if (arg2 == NULL) {
22876 SWIG_null_ref("wxDateSpan");
22877 }
22878 if (SWIG_arg_fail(2)) SWIG_fail;
22879 }
22880 {
22881 PyThreadState* __tstate = wxPyBeginAllowThreads();
22882 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22883
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 {
22888 wxDateTime * resultptr;
22889 resultptr = new wxDateTime((wxDateTime &)(result));
22890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22891 }
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22899 int argc;
22900 PyObject *argv[3];
22901 int ii;
22902
22903 argc = PyObject_Length(args);
22904 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22905 argv[ii] = PyTuple_GetItem(args,ii);
22906 }
22907 if (argc == 2) {
22908 int _v;
22909 {
22910 void *ptr;
22911 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22912 _v = 0;
22913 PyErr_Clear();
22914 } else {
22915 _v = 1;
22916 }
22917 }
22918 if (_v) {
22919 {
22920 void *ptr = 0;
22921 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22922 _v = 0;
22923 PyErr_Clear();
22924 } else {
22925 _v = (ptr != 0);
22926 }
22927 }
22928 if (_v) {
22929 return _wrap_DateTime___add____SWIG_0(self,args);
22930 }
22931 }
22932 }
22933 if (argc == 2) {
22934 int _v;
22935 {
22936 void *ptr;
22937 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22938 _v = 0;
22939 PyErr_Clear();
22940 } else {
22941 _v = 1;
22942 }
22943 }
22944 if (_v) {
22945 {
22946 void *ptr = 0;
22947 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22948 _v = 0;
22949 PyErr_Clear();
22950 } else {
22951 _v = (ptr != 0);
22952 }
22953 }
22954 if (_v) {
22955 return _wrap_DateTime___add____SWIG_1(self,args);
22956 }
22957 }
22958 }
22959
22960 Py_INCREF(Py_NotImplemented);
22961 return Py_NotImplemented;
22962 }
22963
22964
22965 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22966 PyObject *resultobj;
22967 wxDateTime *arg1 = (wxDateTime *) 0 ;
22968 wxDateTime *arg2 = 0 ;
22969 wxTimeSpan result;
22970 PyObject * obj0 = 0 ;
22971 PyObject * obj1 = 0 ;
22972
22973 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22975 if (SWIG_arg_fail(1)) SWIG_fail;
22976 {
22977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22978 if (SWIG_arg_fail(2)) SWIG_fail;
22979 if (arg2 == NULL) {
22980 SWIG_null_ref("wxDateTime");
22981 }
22982 if (SWIG_arg_fail(2)) SWIG_fail;
22983 }
22984 {
22985 PyThreadState* __tstate = wxPyBeginAllowThreads();
22986 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22987
22988 wxPyEndAllowThreads(__tstate);
22989 if (PyErr_Occurred()) SWIG_fail;
22990 }
22991 {
22992 wxTimeSpan * resultptr;
22993 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22994 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22995 }
22996 return resultobj;
22997 fail:
22998 return NULL;
22999 }
23000
23001
23002 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23003 PyObject *resultobj;
23004 wxDateTime *arg1 = (wxDateTime *) 0 ;
23005 wxTimeSpan *arg2 = 0 ;
23006 wxDateTime result;
23007 PyObject * obj0 = 0 ;
23008 PyObject * obj1 = 0 ;
23009
23010 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23012 if (SWIG_arg_fail(1)) SWIG_fail;
23013 {
23014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23015 if (SWIG_arg_fail(2)) SWIG_fail;
23016 if (arg2 == NULL) {
23017 SWIG_null_ref("wxTimeSpan");
23018 }
23019 if (SWIG_arg_fail(2)) SWIG_fail;
23020 }
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23024
23025 wxPyEndAllowThreads(__tstate);
23026 if (PyErr_Occurred()) SWIG_fail;
23027 }
23028 {
23029 wxDateTime * resultptr;
23030 resultptr = new wxDateTime((wxDateTime &)(result));
23031 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23032 }
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23040 PyObject *resultobj;
23041 wxDateTime *arg1 = (wxDateTime *) 0 ;
23042 wxDateSpan *arg2 = 0 ;
23043 wxDateTime result;
23044 PyObject * obj0 = 0 ;
23045 PyObject * obj1 = 0 ;
23046
23047 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23049 if (SWIG_arg_fail(1)) SWIG_fail;
23050 {
23051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23052 if (SWIG_arg_fail(2)) SWIG_fail;
23053 if (arg2 == NULL) {
23054 SWIG_null_ref("wxDateSpan");
23055 }
23056 if (SWIG_arg_fail(2)) SWIG_fail;
23057 }
23058 {
23059 PyThreadState* __tstate = wxPyBeginAllowThreads();
23060 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23061
23062 wxPyEndAllowThreads(__tstate);
23063 if (PyErr_Occurred()) SWIG_fail;
23064 }
23065 {
23066 wxDateTime * resultptr;
23067 resultptr = new wxDateTime((wxDateTime &)(result));
23068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23069 }
23070 return resultobj;
23071 fail:
23072 return NULL;
23073 }
23074
23075
23076 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23077 int argc;
23078 PyObject *argv[3];
23079 int ii;
23080
23081 argc = PyObject_Length(args);
23082 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23083 argv[ii] = PyTuple_GetItem(args,ii);
23084 }
23085 if (argc == 2) {
23086 int _v;
23087 {
23088 void *ptr;
23089 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23090 _v = 0;
23091 PyErr_Clear();
23092 } else {
23093 _v = 1;
23094 }
23095 }
23096 if (_v) {
23097 {
23098 void *ptr = 0;
23099 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23100 _v = 0;
23101 PyErr_Clear();
23102 } else {
23103 _v = (ptr != 0);
23104 }
23105 }
23106 if (_v) {
23107 return _wrap_DateTime___sub____SWIG_0(self,args);
23108 }
23109 }
23110 }
23111 if (argc == 2) {
23112 int _v;
23113 {
23114 void *ptr;
23115 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23116 _v = 0;
23117 PyErr_Clear();
23118 } else {
23119 _v = 1;
23120 }
23121 }
23122 if (_v) {
23123 {
23124 void *ptr = 0;
23125 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23126 _v = 0;
23127 PyErr_Clear();
23128 } else {
23129 _v = (ptr != 0);
23130 }
23131 }
23132 if (_v) {
23133 return _wrap_DateTime___sub____SWIG_1(self,args);
23134 }
23135 }
23136 }
23137 if (argc == 2) {
23138 int _v;
23139 {
23140 void *ptr;
23141 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23142 _v = 0;
23143 PyErr_Clear();
23144 } else {
23145 _v = 1;
23146 }
23147 }
23148 if (_v) {
23149 {
23150 void *ptr = 0;
23151 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23152 _v = 0;
23153 PyErr_Clear();
23154 } else {
23155 _v = (ptr != 0);
23156 }
23157 }
23158 if (_v) {
23159 return _wrap_DateTime___sub____SWIG_2(self,args);
23160 }
23161 }
23162 }
23163
23164 Py_INCREF(Py_NotImplemented);
23165 return Py_NotImplemented;
23166 }
23167
23168
23169 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23170 PyObject *resultobj;
23171 wxDateTime *arg1 = (wxDateTime *) 0 ;
23172 wxDateTime *arg2 = (wxDateTime *) 0 ;
23173 bool result;
23174 PyObject * obj0 = 0 ;
23175 PyObject * obj1 = 0 ;
23176 char *kwnames[] = {
23177 (char *) "self",(char *) "other", NULL
23178 };
23179
23180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23182 if (SWIG_arg_fail(1)) SWIG_fail;
23183 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23184 if (SWIG_arg_fail(2)) SWIG_fail;
23185 {
23186 PyThreadState* __tstate = wxPyBeginAllowThreads();
23187 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23188
23189 wxPyEndAllowThreads(__tstate);
23190 if (PyErr_Occurred()) SWIG_fail;
23191 }
23192 {
23193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23194 }
23195 return resultobj;
23196 fail:
23197 return NULL;
23198 }
23199
23200
23201 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23202 PyObject *resultobj;
23203 wxDateTime *arg1 = (wxDateTime *) 0 ;
23204 wxDateTime *arg2 = (wxDateTime *) 0 ;
23205 bool result;
23206 PyObject * obj0 = 0 ;
23207 PyObject * obj1 = 0 ;
23208 char *kwnames[] = {
23209 (char *) "self",(char *) "other", NULL
23210 };
23211
23212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23214 if (SWIG_arg_fail(1)) SWIG_fail;
23215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23216 if (SWIG_arg_fail(2)) SWIG_fail;
23217 {
23218 PyThreadState* __tstate = wxPyBeginAllowThreads();
23219 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23220
23221 wxPyEndAllowThreads(__tstate);
23222 if (PyErr_Occurred()) SWIG_fail;
23223 }
23224 {
23225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23226 }
23227 return resultobj;
23228 fail:
23229 return NULL;
23230 }
23231
23232
23233 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23234 PyObject *resultobj;
23235 wxDateTime *arg1 = (wxDateTime *) 0 ;
23236 wxDateTime *arg2 = (wxDateTime *) 0 ;
23237 bool result;
23238 PyObject * obj0 = 0 ;
23239 PyObject * obj1 = 0 ;
23240 char *kwnames[] = {
23241 (char *) "self",(char *) "other", NULL
23242 };
23243
23244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23246 if (SWIG_arg_fail(1)) SWIG_fail;
23247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23248 if (SWIG_arg_fail(2)) SWIG_fail;
23249 {
23250 PyThreadState* __tstate = wxPyBeginAllowThreads();
23251 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23252
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 {
23257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23258 }
23259 return resultobj;
23260 fail:
23261 return NULL;
23262 }
23263
23264
23265 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23266 PyObject *resultobj;
23267 wxDateTime *arg1 = (wxDateTime *) 0 ;
23268 wxDateTime *arg2 = (wxDateTime *) 0 ;
23269 bool result;
23270 PyObject * obj0 = 0 ;
23271 PyObject * obj1 = 0 ;
23272 char *kwnames[] = {
23273 (char *) "self",(char *) "other", NULL
23274 };
23275
23276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23278 if (SWIG_arg_fail(1)) SWIG_fail;
23279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23280 if (SWIG_arg_fail(2)) SWIG_fail;
23281 {
23282 PyThreadState* __tstate = wxPyBeginAllowThreads();
23283 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23284
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 {
23289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23290 }
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23298 PyObject *resultobj;
23299 wxDateTime *arg1 = (wxDateTime *) 0 ;
23300 wxDateTime *arg2 = (wxDateTime *) 0 ;
23301 bool result;
23302 PyObject * obj0 = 0 ;
23303 PyObject * obj1 = 0 ;
23304 char *kwnames[] = {
23305 (char *) "self",(char *) "other", NULL
23306 };
23307
23308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23310 if (SWIG_arg_fail(1)) SWIG_fail;
23311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23312 if (SWIG_arg_fail(2)) SWIG_fail;
23313 {
23314 PyThreadState* __tstate = wxPyBeginAllowThreads();
23315 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23316
23317 wxPyEndAllowThreads(__tstate);
23318 if (PyErr_Occurred()) SWIG_fail;
23319 }
23320 {
23321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23322 }
23323 return resultobj;
23324 fail:
23325 return NULL;
23326 }
23327
23328
23329 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23330 PyObject *resultobj;
23331 wxDateTime *arg1 = (wxDateTime *) 0 ;
23332 wxDateTime *arg2 = (wxDateTime *) 0 ;
23333 bool result;
23334 PyObject * obj0 = 0 ;
23335 PyObject * obj1 = 0 ;
23336 char *kwnames[] = {
23337 (char *) "self",(char *) "other", NULL
23338 };
23339
23340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23342 if (SWIG_arg_fail(1)) SWIG_fail;
23343 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23344 if (SWIG_arg_fail(2)) SWIG_fail;
23345 {
23346 PyThreadState* __tstate = wxPyBeginAllowThreads();
23347 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23348
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 {
23353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23354 }
23355 return resultobj;
23356 fail:
23357 return NULL;
23358 }
23359
23360
23361 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23362 PyObject *resultobj;
23363 wxDateTime *arg1 = (wxDateTime *) 0 ;
23364 wxString *arg2 = 0 ;
23365 int result;
23366 bool temp2 = false ;
23367 PyObject * obj0 = 0 ;
23368 PyObject * obj1 = 0 ;
23369 char *kwnames[] = {
23370 (char *) "self",(char *) "date", NULL
23371 };
23372
23373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23375 if (SWIG_arg_fail(1)) SWIG_fail;
23376 {
23377 arg2 = wxString_in_helper(obj1);
23378 if (arg2 == NULL) SWIG_fail;
23379 temp2 = true;
23380 }
23381 {
23382 PyThreadState* __tstate = wxPyBeginAllowThreads();
23383 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23384
23385 wxPyEndAllowThreads(__tstate);
23386 if (PyErr_Occurred()) SWIG_fail;
23387 }
23388 {
23389 resultobj = SWIG_From_int((int)(result));
23390 }
23391 {
23392 if (temp2)
23393 delete arg2;
23394 }
23395 return resultobj;
23396 fail:
23397 {
23398 if (temp2)
23399 delete arg2;
23400 }
23401 return NULL;
23402 }
23403
23404
23405 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23406 PyObject *resultobj;
23407 wxDateTime *arg1 = (wxDateTime *) 0 ;
23408 wxString *arg2 = 0 ;
23409 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23410 wxString *arg3 = (wxString *) &arg3_defvalue ;
23411 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23412 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23413 int result;
23414 bool temp2 = false ;
23415 bool temp3 = false ;
23416 PyObject * obj0 = 0 ;
23417 PyObject * obj1 = 0 ;
23418 PyObject * obj2 = 0 ;
23419 PyObject * obj3 = 0 ;
23420 char *kwnames[] = {
23421 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23422 };
23423
23424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23426 if (SWIG_arg_fail(1)) SWIG_fail;
23427 {
23428 arg2 = wxString_in_helper(obj1);
23429 if (arg2 == NULL) SWIG_fail;
23430 temp2 = true;
23431 }
23432 if (obj2) {
23433 {
23434 arg3 = wxString_in_helper(obj2);
23435 if (arg3 == NULL) SWIG_fail;
23436 temp3 = true;
23437 }
23438 }
23439 if (obj3) {
23440 {
23441 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23442 if (SWIG_arg_fail(4)) SWIG_fail;
23443 if (arg4 == NULL) {
23444 SWIG_null_ref("wxDateTime");
23445 }
23446 if (SWIG_arg_fail(4)) SWIG_fail;
23447 }
23448 }
23449 {
23450 PyThreadState* __tstate = wxPyBeginAllowThreads();
23451 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23452
23453 wxPyEndAllowThreads(__tstate);
23454 if (PyErr_Occurred()) SWIG_fail;
23455 }
23456 {
23457 resultobj = SWIG_From_int((int)(result));
23458 }
23459 {
23460 if (temp2)
23461 delete arg2;
23462 }
23463 {
23464 if (temp3)
23465 delete arg3;
23466 }
23467 return resultobj;
23468 fail:
23469 {
23470 if (temp2)
23471 delete arg2;
23472 }
23473 {
23474 if (temp3)
23475 delete arg3;
23476 }
23477 return NULL;
23478 }
23479
23480
23481 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23482 PyObject *resultobj;
23483 wxDateTime *arg1 = (wxDateTime *) 0 ;
23484 wxString *arg2 = 0 ;
23485 int result;
23486 bool temp2 = false ;
23487 PyObject * obj0 = 0 ;
23488 PyObject * obj1 = 0 ;
23489 char *kwnames[] = {
23490 (char *) "self",(char *) "datetime", NULL
23491 };
23492
23493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23495 if (SWIG_arg_fail(1)) SWIG_fail;
23496 {
23497 arg2 = wxString_in_helper(obj1);
23498 if (arg2 == NULL) SWIG_fail;
23499 temp2 = true;
23500 }
23501 {
23502 PyThreadState* __tstate = wxPyBeginAllowThreads();
23503 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23504
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 {
23509 resultobj = SWIG_From_int((int)(result));
23510 }
23511 {
23512 if (temp2)
23513 delete arg2;
23514 }
23515 return resultobj;
23516 fail:
23517 {
23518 if (temp2)
23519 delete arg2;
23520 }
23521 return NULL;
23522 }
23523
23524
23525 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23526 PyObject *resultobj;
23527 wxDateTime *arg1 = (wxDateTime *) 0 ;
23528 wxString *arg2 = 0 ;
23529 int result;
23530 bool temp2 = false ;
23531 PyObject * obj0 = 0 ;
23532 PyObject * obj1 = 0 ;
23533 char *kwnames[] = {
23534 (char *) "self",(char *) "date", NULL
23535 };
23536
23537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23539 if (SWIG_arg_fail(1)) SWIG_fail;
23540 {
23541 arg2 = wxString_in_helper(obj1);
23542 if (arg2 == NULL) SWIG_fail;
23543 temp2 = true;
23544 }
23545 {
23546 PyThreadState* __tstate = wxPyBeginAllowThreads();
23547 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23548
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 {
23553 resultobj = SWIG_From_int((int)(result));
23554 }
23555 {
23556 if (temp2)
23557 delete arg2;
23558 }
23559 return resultobj;
23560 fail:
23561 {
23562 if (temp2)
23563 delete arg2;
23564 }
23565 return NULL;
23566 }
23567
23568
23569 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23570 PyObject *resultobj;
23571 wxDateTime *arg1 = (wxDateTime *) 0 ;
23572 wxString *arg2 = 0 ;
23573 int result;
23574 bool temp2 = false ;
23575 PyObject * obj0 = 0 ;
23576 PyObject * obj1 = 0 ;
23577 char *kwnames[] = {
23578 (char *) "self",(char *) "time", NULL
23579 };
23580
23581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23583 if (SWIG_arg_fail(1)) SWIG_fail;
23584 {
23585 arg2 = wxString_in_helper(obj1);
23586 if (arg2 == NULL) SWIG_fail;
23587 temp2 = true;
23588 }
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23592
23593 wxPyEndAllowThreads(__tstate);
23594 if (PyErr_Occurred()) SWIG_fail;
23595 }
23596 {
23597 resultobj = SWIG_From_int((int)(result));
23598 }
23599 {
23600 if (temp2)
23601 delete arg2;
23602 }
23603 return resultobj;
23604 fail:
23605 {
23606 if (temp2)
23607 delete arg2;
23608 }
23609 return NULL;
23610 }
23611
23612
23613 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23614 PyObject *resultobj;
23615 wxDateTime *arg1 = (wxDateTime *) 0 ;
23616 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23617 wxString *arg2 = (wxString *) &arg2_defvalue ;
23618 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23619 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23620 wxString result;
23621 bool temp2 = false ;
23622 bool temp3 = false ;
23623 PyObject * obj0 = 0 ;
23624 PyObject * obj1 = 0 ;
23625 PyObject * obj2 = 0 ;
23626 char *kwnames[] = {
23627 (char *) "self",(char *) "format",(char *) "tz", NULL
23628 };
23629
23630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23632 if (SWIG_arg_fail(1)) SWIG_fail;
23633 if (obj1) {
23634 {
23635 arg2 = wxString_in_helper(obj1);
23636 if (arg2 == NULL) SWIG_fail;
23637 temp2 = true;
23638 }
23639 }
23640 if (obj2) {
23641 {
23642 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23643 temp3 = true;
23644 }
23645 }
23646 {
23647 PyThreadState* __tstate = wxPyBeginAllowThreads();
23648 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23649
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 {
23654 #if wxUSE_UNICODE
23655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23656 #else
23657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23658 #endif
23659 }
23660 {
23661 if (temp2)
23662 delete arg2;
23663 }
23664 {
23665 if (temp3) delete arg3;
23666 }
23667 return resultobj;
23668 fail:
23669 {
23670 if (temp2)
23671 delete arg2;
23672 }
23673 {
23674 if (temp3) delete arg3;
23675 }
23676 return NULL;
23677 }
23678
23679
23680 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23681 PyObject *resultobj;
23682 wxDateTime *arg1 = (wxDateTime *) 0 ;
23683 wxString result;
23684 PyObject * obj0 = 0 ;
23685 char *kwnames[] = {
23686 (char *) "self", NULL
23687 };
23688
23689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23691 if (SWIG_arg_fail(1)) SWIG_fail;
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = ((wxDateTime const *)arg1)->FormatDate();
23695
23696 wxPyEndAllowThreads(__tstate);
23697 if (PyErr_Occurred()) SWIG_fail;
23698 }
23699 {
23700 #if wxUSE_UNICODE
23701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23702 #else
23703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23704 #endif
23705 }
23706 return resultobj;
23707 fail:
23708 return NULL;
23709 }
23710
23711
23712 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23713 PyObject *resultobj;
23714 wxDateTime *arg1 = (wxDateTime *) 0 ;
23715 wxString result;
23716 PyObject * obj0 = 0 ;
23717 char *kwnames[] = {
23718 (char *) "self", NULL
23719 };
23720
23721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23723 if (SWIG_arg_fail(1)) SWIG_fail;
23724 {
23725 PyThreadState* __tstate = wxPyBeginAllowThreads();
23726 result = ((wxDateTime const *)arg1)->FormatTime();
23727
23728 wxPyEndAllowThreads(__tstate);
23729 if (PyErr_Occurred()) SWIG_fail;
23730 }
23731 {
23732 #if wxUSE_UNICODE
23733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23734 #else
23735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23736 #endif
23737 }
23738 return resultobj;
23739 fail:
23740 return NULL;
23741 }
23742
23743
23744 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23745 PyObject *resultobj;
23746 wxDateTime *arg1 = (wxDateTime *) 0 ;
23747 wxString result;
23748 PyObject * obj0 = 0 ;
23749 char *kwnames[] = {
23750 (char *) "self", NULL
23751 };
23752
23753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23755 if (SWIG_arg_fail(1)) SWIG_fail;
23756 {
23757 PyThreadState* __tstate = wxPyBeginAllowThreads();
23758 result = ((wxDateTime const *)arg1)->FormatISODate();
23759
23760 wxPyEndAllowThreads(__tstate);
23761 if (PyErr_Occurred()) SWIG_fail;
23762 }
23763 {
23764 #if wxUSE_UNICODE
23765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23766 #else
23767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23768 #endif
23769 }
23770 return resultobj;
23771 fail:
23772 return NULL;
23773 }
23774
23775
23776 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23777 PyObject *resultobj;
23778 wxDateTime *arg1 = (wxDateTime *) 0 ;
23779 wxString result;
23780 PyObject * obj0 = 0 ;
23781 char *kwnames[] = {
23782 (char *) "self", NULL
23783 };
23784
23785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23787 if (SWIG_arg_fail(1)) SWIG_fail;
23788 {
23789 PyThreadState* __tstate = wxPyBeginAllowThreads();
23790 result = ((wxDateTime const *)arg1)->FormatISOTime();
23791
23792 wxPyEndAllowThreads(__tstate);
23793 if (PyErr_Occurred()) SWIG_fail;
23794 }
23795 {
23796 #if wxUSE_UNICODE
23797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23798 #else
23799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23800 #endif
23801 }
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23809 PyObject *obj;
23810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23811 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23812 Py_INCREF(obj);
23813 return Py_BuildValue((char *)"");
23814 }
23815 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23816 PyObject *resultobj;
23817 long arg1 ;
23818 wxTimeSpan result;
23819 PyObject * obj0 = 0 ;
23820 char *kwnames[] = {
23821 (char *) "sec", NULL
23822 };
23823
23824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23825 {
23826 arg1 = (long)(SWIG_As_long(obj0));
23827 if (SWIG_arg_fail(1)) SWIG_fail;
23828 }
23829 {
23830 PyThreadState* __tstate = wxPyBeginAllowThreads();
23831 result = wxTimeSpan::Seconds(arg1);
23832
23833 wxPyEndAllowThreads(__tstate);
23834 if (PyErr_Occurred()) SWIG_fail;
23835 }
23836 {
23837 wxTimeSpan * resultptr;
23838 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23839 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23840 }
23841 return resultobj;
23842 fail:
23843 return NULL;
23844 }
23845
23846
23847 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23848 PyObject *resultobj;
23849 wxTimeSpan result;
23850 char *kwnames[] = {
23851 NULL
23852 };
23853
23854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = wxTimeSpan::Second();
23858
23859 wxPyEndAllowThreads(__tstate);
23860 if (PyErr_Occurred()) SWIG_fail;
23861 }
23862 {
23863 wxTimeSpan * resultptr;
23864 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23865 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23866 }
23867 return resultobj;
23868 fail:
23869 return NULL;
23870 }
23871
23872
23873 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23874 PyObject *resultobj;
23875 long arg1 ;
23876 wxTimeSpan result;
23877 PyObject * obj0 = 0 ;
23878 char *kwnames[] = {
23879 (char *) "min", NULL
23880 };
23881
23882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23883 {
23884 arg1 = (long)(SWIG_As_long(obj0));
23885 if (SWIG_arg_fail(1)) SWIG_fail;
23886 }
23887 {
23888 PyThreadState* __tstate = wxPyBeginAllowThreads();
23889 result = wxTimeSpan::Minutes(arg1);
23890
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 {
23895 wxTimeSpan * resultptr;
23896 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23897 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23898 }
23899 return resultobj;
23900 fail:
23901 return NULL;
23902 }
23903
23904
23905 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23906 PyObject *resultobj;
23907 wxTimeSpan result;
23908 char *kwnames[] = {
23909 NULL
23910 };
23911
23912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23913 {
23914 PyThreadState* __tstate = wxPyBeginAllowThreads();
23915 result = wxTimeSpan::Minute();
23916
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 wxTimeSpan * resultptr;
23922 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23923 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23924 }
23925 return resultobj;
23926 fail:
23927 return NULL;
23928 }
23929
23930
23931 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23932 PyObject *resultobj;
23933 long arg1 ;
23934 wxTimeSpan result;
23935 PyObject * obj0 = 0 ;
23936 char *kwnames[] = {
23937 (char *) "hours", NULL
23938 };
23939
23940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23941 {
23942 arg1 = (long)(SWIG_As_long(obj0));
23943 if (SWIG_arg_fail(1)) SWIG_fail;
23944 }
23945 {
23946 PyThreadState* __tstate = wxPyBeginAllowThreads();
23947 result = wxTimeSpan::Hours(arg1);
23948
23949 wxPyEndAllowThreads(__tstate);
23950 if (PyErr_Occurred()) SWIG_fail;
23951 }
23952 {
23953 wxTimeSpan * resultptr;
23954 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23955 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23956 }
23957 return resultobj;
23958 fail:
23959 return NULL;
23960 }
23961
23962
23963 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23964 PyObject *resultobj;
23965 wxTimeSpan result;
23966 char *kwnames[] = {
23967 NULL
23968 };
23969
23970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23971 {
23972 PyThreadState* __tstate = wxPyBeginAllowThreads();
23973 result = wxTimeSpan::Hour();
23974
23975 wxPyEndAllowThreads(__tstate);
23976 if (PyErr_Occurred()) SWIG_fail;
23977 }
23978 {
23979 wxTimeSpan * resultptr;
23980 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23981 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23982 }
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23990 PyObject *resultobj;
23991 long arg1 ;
23992 wxTimeSpan result;
23993 PyObject * obj0 = 0 ;
23994 char *kwnames[] = {
23995 (char *) "days", NULL
23996 };
23997
23998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23999 {
24000 arg1 = (long)(SWIG_As_long(obj0));
24001 if (SWIG_arg_fail(1)) SWIG_fail;
24002 }
24003 {
24004 PyThreadState* __tstate = wxPyBeginAllowThreads();
24005 result = wxTimeSpan::Days(arg1);
24006
24007 wxPyEndAllowThreads(__tstate);
24008 if (PyErr_Occurred()) SWIG_fail;
24009 }
24010 {
24011 wxTimeSpan * resultptr;
24012 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24013 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24014 }
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24022 PyObject *resultobj;
24023 wxTimeSpan result;
24024 char *kwnames[] = {
24025 NULL
24026 };
24027
24028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24029 {
24030 PyThreadState* __tstate = wxPyBeginAllowThreads();
24031 result = wxTimeSpan::Day();
24032
24033 wxPyEndAllowThreads(__tstate);
24034 if (PyErr_Occurred()) SWIG_fail;
24035 }
24036 {
24037 wxTimeSpan * resultptr;
24038 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24040 }
24041 return resultobj;
24042 fail:
24043 return NULL;
24044 }
24045
24046
24047 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24048 PyObject *resultobj;
24049 long arg1 ;
24050 wxTimeSpan result;
24051 PyObject * obj0 = 0 ;
24052 char *kwnames[] = {
24053 (char *) "days", NULL
24054 };
24055
24056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24057 {
24058 arg1 = (long)(SWIG_As_long(obj0));
24059 if (SWIG_arg_fail(1)) SWIG_fail;
24060 }
24061 {
24062 PyThreadState* __tstate = wxPyBeginAllowThreads();
24063 result = wxTimeSpan::Weeks(arg1);
24064
24065 wxPyEndAllowThreads(__tstate);
24066 if (PyErr_Occurred()) SWIG_fail;
24067 }
24068 {
24069 wxTimeSpan * resultptr;
24070 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24071 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24072 }
24073 return resultobj;
24074 fail:
24075 return NULL;
24076 }
24077
24078
24079 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24080 PyObject *resultobj;
24081 wxTimeSpan result;
24082 char *kwnames[] = {
24083 NULL
24084 };
24085
24086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24087 {
24088 PyThreadState* __tstate = wxPyBeginAllowThreads();
24089 result = wxTimeSpan::Week();
24090
24091 wxPyEndAllowThreads(__tstate);
24092 if (PyErr_Occurred()) SWIG_fail;
24093 }
24094 {
24095 wxTimeSpan * resultptr;
24096 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24098 }
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24106 PyObject *resultobj;
24107 long arg1 = (long) 0 ;
24108 long arg2 = (long) 0 ;
24109 long arg3 = (long) 0 ;
24110 long arg4 = (long) 0 ;
24111 wxTimeSpan *result;
24112 PyObject * obj0 = 0 ;
24113 PyObject * obj1 = 0 ;
24114 PyObject * obj2 = 0 ;
24115 PyObject * obj3 = 0 ;
24116 char *kwnames[] = {
24117 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24118 };
24119
24120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24121 if (obj0) {
24122 {
24123 arg1 = (long)(SWIG_As_long(obj0));
24124 if (SWIG_arg_fail(1)) SWIG_fail;
24125 }
24126 }
24127 if (obj1) {
24128 {
24129 arg2 = (long)(SWIG_As_long(obj1));
24130 if (SWIG_arg_fail(2)) SWIG_fail;
24131 }
24132 }
24133 if (obj2) {
24134 {
24135 arg3 = (long)(SWIG_As_long(obj2));
24136 if (SWIG_arg_fail(3)) SWIG_fail;
24137 }
24138 }
24139 if (obj3) {
24140 {
24141 arg4 = (long)(SWIG_As_long(obj3));
24142 if (SWIG_arg_fail(4)) SWIG_fail;
24143 }
24144 }
24145 {
24146 PyThreadState* __tstate = wxPyBeginAllowThreads();
24147 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24148
24149 wxPyEndAllowThreads(__tstate);
24150 if (PyErr_Occurred()) SWIG_fail;
24151 }
24152 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24160 PyObject *resultobj;
24161 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24162 PyObject * obj0 = 0 ;
24163 char *kwnames[] = {
24164 (char *) "self", NULL
24165 };
24166
24167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24169 if (SWIG_arg_fail(1)) SWIG_fail;
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 delete arg1;
24173
24174 wxPyEndAllowThreads(__tstate);
24175 if (PyErr_Occurred()) SWIG_fail;
24176 }
24177 Py_INCREF(Py_None); resultobj = Py_None;
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24185 PyObject *resultobj;
24186 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24187 wxTimeSpan *arg2 = 0 ;
24188 wxTimeSpan *result;
24189 PyObject * obj0 = 0 ;
24190 PyObject * obj1 = 0 ;
24191 char *kwnames[] = {
24192 (char *) "self",(char *) "diff", NULL
24193 };
24194
24195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24197 if (SWIG_arg_fail(1)) SWIG_fail;
24198 {
24199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24200 if (SWIG_arg_fail(2)) SWIG_fail;
24201 if (arg2 == NULL) {
24202 SWIG_null_ref("wxTimeSpan");
24203 }
24204 if (SWIG_arg_fail(2)) SWIG_fail;
24205 }
24206 {
24207 PyThreadState* __tstate = wxPyBeginAllowThreads();
24208 {
24209 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24210 result = (wxTimeSpan *) &_result_ref;
24211 }
24212
24213 wxPyEndAllowThreads(__tstate);
24214 if (PyErr_Occurred()) SWIG_fail;
24215 }
24216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24217 return resultobj;
24218 fail:
24219 return NULL;
24220 }
24221
24222
24223 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24224 PyObject *resultobj;
24225 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24226 wxTimeSpan *arg2 = 0 ;
24227 wxTimeSpan *result;
24228 PyObject * obj0 = 0 ;
24229 PyObject * obj1 = 0 ;
24230 char *kwnames[] = {
24231 (char *) "self",(char *) "diff", NULL
24232 };
24233
24234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24236 if (SWIG_arg_fail(1)) SWIG_fail;
24237 {
24238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24239 if (SWIG_arg_fail(2)) SWIG_fail;
24240 if (arg2 == NULL) {
24241 SWIG_null_ref("wxTimeSpan");
24242 }
24243 if (SWIG_arg_fail(2)) SWIG_fail;
24244 }
24245 {
24246 PyThreadState* __tstate = wxPyBeginAllowThreads();
24247 {
24248 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24249 result = (wxTimeSpan *) &_result_ref;
24250 }
24251
24252 wxPyEndAllowThreads(__tstate);
24253 if (PyErr_Occurred()) SWIG_fail;
24254 }
24255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24256 return resultobj;
24257 fail:
24258 return NULL;
24259 }
24260
24261
24262 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24263 PyObject *resultobj;
24264 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24265 int arg2 ;
24266 wxTimeSpan *result;
24267 PyObject * obj0 = 0 ;
24268 PyObject * obj1 = 0 ;
24269 char *kwnames[] = {
24270 (char *) "self",(char *) "n", NULL
24271 };
24272
24273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24275 if (SWIG_arg_fail(1)) SWIG_fail;
24276 {
24277 arg2 = (int)(SWIG_As_int(obj1));
24278 if (SWIG_arg_fail(2)) SWIG_fail;
24279 }
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 {
24283 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24284 result = (wxTimeSpan *) &_result_ref;
24285 }
24286
24287 wxPyEndAllowThreads(__tstate);
24288 if (PyErr_Occurred()) SWIG_fail;
24289 }
24290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24291 return resultobj;
24292 fail:
24293 return NULL;
24294 }
24295
24296
24297 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24298 PyObject *resultobj;
24299 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24300 wxTimeSpan *result;
24301 PyObject * obj0 = 0 ;
24302 char *kwnames[] = {
24303 (char *) "self", NULL
24304 };
24305
24306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24308 if (SWIG_arg_fail(1)) SWIG_fail;
24309 {
24310 PyThreadState* __tstate = wxPyBeginAllowThreads();
24311 {
24312 wxTimeSpan &_result_ref = (arg1)->Neg();
24313 result = (wxTimeSpan *) &_result_ref;
24314 }
24315
24316 wxPyEndAllowThreads(__tstate);
24317 if (PyErr_Occurred()) SWIG_fail;
24318 }
24319 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24320 return resultobj;
24321 fail:
24322 return NULL;
24323 }
24324
24325
24326 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24327 PyObject *resultobj;
24328 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24329 wxTimeSpan result;
24330 PyObject * obj0 = 0 ;
24331 char *kwnames[] = {
24332 (char *) "self", NULL
24333 };
24334
24335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24337 if (SWIG_arg_fail(1)) SWIG_fail;
24338 {
24339 PyThreadState* __tstate = wxPyBeginAllowThreads();
24340 result = ((wxTimeSpan const *)arg1)->Abs();
24341
24342 wxPyEndAllowThreads(__tstate);
24343 if (PyErr_Occurred()) SWIG_fail;
24344 }
24345 {
24346 wxTimeSpan * resultptr;
24347 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24349 }
24350 return resultobj;
24351 fail:
24352 return NULL;
24353 }
24354
24355
24356 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24357 PyObject *resultobj;
24358 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24359 wxTimeSpan *arg2 = 0 ;
24360 wxTimeSpan *result;
24361 PyObject * obj0 = 0 ;
24362 PyObject * obj1 = 0 ;
24363 char *kwnames[] = {
24364 (char *) "self",(char *) "diff", NULL
24365 };
24366
24367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24369 if (SWIG_arg_fail(1)) SWIG_fail;
24370 {
24371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24372 if (SWIG_arg_fail(2)) SWIG_fail;
24373 if (arg2 == NULL) {
24374 SWIG_null_ref("wxTimeSpan");
24375 }
24376 if (SWIG_arg_fail(2)) SWIG_fail;
24377 }
24378 {
24379 PyThreadState* __tstate = wxPyBeginAllowThreads();
24380 {
24381 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24382 result = (wxTimeSpan *) &_result_ref;
24383 }
24384
24385 wxPyEndAllowThreads(__tstate);
24386 if (PyErr_Occurred()) SWIG_fail;
24387 }
24388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24389 return resultobj;
24390 fail:
24391 return NULL;
24392 }
24393
24394
24395 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24396 PyObject *resultobj;
24397 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24398 wxTimeSpan *arg2 = 0 ;
24399 wxTimeSpan *result;
24400 PyObject * obj0 = 0 ;
24401 PyObject * obj1 = 0 ;
24402 char *kwnames[] = {
24403 (char *) "self",(char *) "diff", NULL
24404 };
24405
24406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24408 if (SWIG_arg_fail(1)) SWIG_fail;
24409 {
24410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24411 if (SWIG_arg_fail(2)) SWIG_fail;
24412 if (arg2 == NULL) {
24413 SWIG_null_ref("wxTimeSpan");
24414 }
24415 if (SWIG_arg_fail(2)) SWIG_fail;
24416 }
24417 {
24418 PyThreadState* __tstate = wxPyBeginAllowThreads();
24419 {
24420 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24421 result = (wxTimeSpan *) &_result_ref;
24422 }
24423
24424 wxPyEndAllowThreads(__tstate);
24425 if (PyErr_Occurred()) SWIG_fail;
24426 }
24427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24428 return resultobj;
24429 fail:
24430 return NULL;
24431 }
24432
24433
24434 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24435 PyObject *resultobj;
24436 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24437 int arg2 ;
24438 wxTimeSpan *result;
24439 PyObject * obj0 = 0 ;
24440 PyObject * obj1 = 0 ;
24441 char *kwnames[] = {
24442 (char *) "self",(char *) "n", NULL
24443 };
24444
24445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24447 if (SWIG_arg_fail(1)) SWIG_fail;
24448 {
24449 arg2 = (int)(SWIG_As_int(obj1));
24450 if (SWIG_arg_fail(2)) SWIG_fail;
24451 }
24452 {
24453 PyThreadState* __tstate = wxPyBeginAllowThreads();
24454 {
24455 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24456 result = (wxTimeSpan *) &_result_ref;
24457 }
24458
24459 wxPyEndAllowThreads(__tstate);
24460 if (PyErr_Occurred()) SWIG_fail;
24461 }
24462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24470 PyObject *resultobj;
24471 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24472 wxTimeSpan *result;
24473 PyObject * obj0 = 0 ;
24474 char *kwnames[] = {
24475 (char *) "self", NULL
24476 };
24477
24478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24480 if (SWIG_arg_fail(1)) SWIG_fail;
24481 {
24482 PyThreadState* __tstate = wxPyBeginAllowThreads();
24483 {
24484 wxTimeSpan &_result_ref = (arg1)->operator -();
24485 result = (wxTimeSpan *) &_result_ref;
24486 }
24487
24488 wxPyEndAllowThreads(__tstate);
24489 if (PyErr_Occurred()) SWIG_fail;
24490 }
24491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24492 return resultobj;
24493 fail:
24494 return NULL;
24495 }
24496
24497
24498 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24499 PyObject *resultobj;
24500 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24501 wxTimeSpan *arg2 = 0 ;
24502 wxTimeSpan result;
24503 PyObject * obj0 = 0 ;
24504 PyObject * obj1 = 0 ;
24505 char *kwnames[] = {
24506 (char *) "self",(char *) "other", NULL
24507 };
24508
24509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24511 if (SWIG_arg_fail(1)) SWIG_fail;
24512 {
24513 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24514 if (SWIG_arg_fail(2)) SWIG_fail;
24515 if (arg2 == NULL) {
24516 SWIG_null_ref("wxTimeSpan");
24517 }
24518 if (SWIG_arg_fail(2)) SWIG_fail;
24519 }
24520 {
24521 PyThreadState* __tstate = wxPyBeginAllowThreads();
24522 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24523
24524 wxPyEndAllowThreads(__tstate);
24525 if (PyErr_Occurred()) SWIG_fail;
24526 }
24527 {
24528 wxTimeSpan * resultptr;
24529 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24531 }
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj;
24540 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24541 wxTimeSpan *arg2 = 0 ;
24542 wxTimeSpan result;
24543 PyObject * obj0 = 0 ;
24544 PyObject * obj1 = 0 ;
24545 char *kwnames[] = {
24546 (char *) "self",(char *) "other", NULL
24547 };
24548
24549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24551 if (SWIG_arg_fail(1)) SWIG_fail;
24552 {
24553 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24554 if (SWIG_arg_fail(2)) SWIG_fail;
24555 if (arg2 == NULL) {
24556 SWIG_null_ref("wxTimeSpan");
24557 }
24558 if (SWIG_arg_fail(2)) SWIG_fail;
24559 }
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24563
24564 wxPyEndAllowThreads(__tstate);
24565 if (PyErr_Occurred()) SWIG_fail;
24566 }
24567 {
24568 wxTimeSpan * resultptr;
24569 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24571 }
24572 return resultobj;
24573 fail:
24574 return NULL;
24575 }
24576
24577
24578 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24579 PyObject *resultobj;
24580 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24581 int arg2 ;
24582 wxTimeSpan result;
24583 PyObject * obj0 = 0 ;
24584 PyObject * obj1 = 0 ;
24585 char *kwnames[] = {
24586 (char *) "self",(char *) "n", NULL
24587 };
24588
24589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24591 if (SWIG_arg_fail(1)) SWIG_fail;
24592 {
24593 arg2 = (int)(SWIG_As_int(obj1));
24594 if (SWIG_arg_fail(2)) SWIG_fail;
24595 }
24596 {
24597 PyThreadState* __tstate = wxPyBeginAllowThreads();
24598 result = wxTimeSpan___mul__(arg1,arg2);
24599
24600 wxPyEndAllowThreads(__tstate);
24601 if (PyErr_Occurred()) SWIG_fail;
24602 }
24603 {
24604 wxTimeSpan * resultptr;
24605 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24606 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24607 }
24608 return resultobj;
24609 fail:
24610 return NULL;
24611 }
24612
24613
24614 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24615 PyObject *resultobj;
24616 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24617 int arg2 ;
24618 wxTimeSpan result;
24619 PyObject * obj0 = 0 ;
24620 PyObject * obj1 = 0 ;
24621 char *kwnames[] = {
24622 (char *) "self",(char *) "n", NULL
24623 };
24624
24625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24627 if (SWIG_arg_fail(1)) SWIG_fail;
24628 {
24629 arg2 = (int)(SWIG_As_int(obj1));
24630 if (SWIG_arg_fail(2)) SWIG_fail;
24631 }
24632 {
24633 PyThreadState* __tstate = wxPyBeginAllowThreads();
24634 result = wxTimeSpan___rmul__(arg1,arg2);
24635
24636 wxPyEndAllowThreads(__tstate);
24637 if (PyErr_Occurred()) SWIG_fail;
24638 }
24639 {
24640 wxTimeSpan * resultptr;
24641 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24643 }
24644 return resultobj;
24645 fail:
24646 return NULL;
24647 }
24648
24649
24650 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24651 PyObject *resultobj;
24652 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24653 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24654 bool result;
24655 PyObject * obj0 = 0 ;
24656 PyObject * obj1 = 0 ;
24657 char *kwnames[] = {
24658 (char *) "self",(char *) "other", NULL
24659 };
24660
24661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24663 if (SWIG_arg_fail(1)) SWIG_fail;
24664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24665 if (SWIG_arg_fail(2)) SWIG_fail;
24666 {
24667 PyThreadState* __tstate = wxPyBeginAllowThreads();
24668 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24669
24670 wxPyEndAllowThreads(__tstate);
24671 if (PyErr_Occurred()) SWIG_fail;
24672 }
24673 {
24674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24675 }
24676 return resultobj;
24677 fail:
24678 return NULL;
24679 }
24680
24681
24682 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24683 PyObject *resultobj;
24684 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24685 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24686 bool result;
24687 PyObject * obj0 = 0 ;
24688 PyObject * obj1 = 0 ;
24689 char *kwnames[] = {
24690 (char *) "self",(char *) "other", NULL
24691 };
24692
24693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24695 if (SWIG_arg_fail(1)) SWIG_fail;
24696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24697 if (SWIG_arg_fail(2)) SWIG_fail;
24698 {
24699 PyThreadState* __tstate = wxPyBeginAllowThreads();
24700 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24701
24702 wxPyEndAllowThreads(__tstate);
24703 if (PyErr_Occurred()) SWIG_fail;
24704 }
24705 {
24706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24707 }
24708 return resultobj;
24709 fail:
24710 return NULL;
24711 }
24712
24713
24714 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj;
24716 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24717 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24718 bool result;
24719 PyObject * obj0 = 0 ;
24720 PyObject * obj1 = 0 ;
24721 char *kwnames[] = {
24722 (char *) "self",(char *) "other", NULL
24723 };
24724
24725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24727 if (SWIG_arg_fail(1)) SWIG_fail;
24728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24729 if (SWIG_arg_fail(2)) SWIG_fail;
24730 {
24731 PyThreadState* __tstate = wxPyBeginAllowThreads();
24732 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24733
24734 wxPyEndAllowThreads(__tstate);
24735 if (PyErr_Occurred()) SWIG_fail;
24736 }
24737 {
24738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24739 }
24740 return resultobj;
24741 fail:
24742 return NULL;
24743 }
24744
24745
24746 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24747 PyObject *resultobj;
24748 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24749 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24750 bool result;
24751 PyObject * obj0 = 0 ;
24752 PyObject * obj1 = 0 ;
24753 char *kwnames[] = {
24754 (char *) "self",(char *) "other", NULL
24755 };
24756
24757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24759 if (SWIG_arg_fail(1)) SWIG_fail;
24760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24761 if (SWIG_arg_fail(2)) SWIG_fail;
24762 {
24763 PyThreadState* __tstate = wxPyBeginAllowThreads();
24764 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24765
24766 wxPyEndAllowThreads(__tstate);
24767 if (PyErr_Occurred()) SWIG_fail;
24768 }
24769 {
24770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24771 }
24772 return resultobj;
24773 fail:
24774 return NULL;
24775 }
24776
24777
24778 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24779 PyObject *resultobj;
24780 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24781 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24782 bool result;
24783 PyObject * obj0 = 0 ;
24784 PyObject * obj1 = 0 ;
24785 char *kwnames[] = {
24786 (char *) "self",(char *) "other", NULL
24787 };
24788
24789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24791 if (SWIG_arg_fail(1)) SWIG_fail;
24792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24793 if (SWIG_arg_fail(2)) SWIG_fail;
24794 {
24795 PyThreadState* __tstate = wxPyBeginAllowThreads();
24796 result = (bool)wxTimeSpan___eq__(arg1,(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___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24811 PyObject *resultobj;
24812 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24813 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24814 bool result;
24815 PyObject * obj0 = 0 ;
24816 PyObject * obj1 = 0 ;
24817 char *kwnames[] = {
24818 (char *) "self",(char *) "other", NULL
24819 };
24820
24821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24823 if (SWIG_arg_fail(1)) SWIG_fail;
24824 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24825 if (SWIG_arg_fail(2)) SWIG_fail;
24826 {
24827 PyThreadState* __tstate = wxPyBeginAllowThreads();
24828 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24829
24830 wxPyEndAllowThreads(__tstate);
24831 if (PyErr_Occurred()) SWIG_fail;
24832 }
24833 {
24834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24835 }
24836 return resultobj;
24837 fail:
24838 return NULL;
24839 }
24840
24841
24842 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24843 PyObject *resultobj;
24844 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24845 bool result;
24846 PyObject * obj0 = 0 ;
24847 char *kwnames[] = {
24848 (char *) "self", NULL
24849 };
24850
24851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24853 if (SWIG_arg_fail(1)) SWIG_fail;
24854 {
24855 PyThreadState* __tstate = wxPyBeginAllowThreads();
24856 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24857
24858 wxPyEndAllowThreads(__tstate);
24859 if (PyErr_Occurred()) SWIG_fail;
24860 }
24861 {
24862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24863 }
24864 return resultobj;
24865 fail:
24866 return NULL;
24867 }
24868
24869
24870 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24871 PyObject *resultobj;
24872 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24873 bool result;
24874 PyObject * obj0 = 0 ;
24875 char *kwnames[] = {
24876 (char *) "self", NULL
24877 };
24878
24879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24881 if (SWIG_arg_fail(1)) SWIG_fail;
24882 {
24883 PyThreadState* __tstate = wxPyBeginAllowThreads();
24884 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24885
24886 wxPyEndAllowThreads(__tstate);
24887 if (PyErr_Occurred()) SWIG_fail;
24888 }
24889 {
24890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24891 }
24892 return resultobj;
24893 fail:
24894 return NULL;
24895 }
24896
24897
24898 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24899 PyObject *resultobj;
24900 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24901 bool result;
24902 PyObject * obj0 = 0 ;
24903 char *kwnames[] = {
24904 (char *) "self", NULL
24905 };
24906
24907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24909 if (SWIG_arg_fail(1)) SWIG_fail;
24910 {
24911 PyThreadState* __tstate = wxPyBeginAllowThreads();
24912 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24913
24914 wxPyEndAllowThreads(__tstate);
24915 if (PyErr_Occurred()) SWIG_fail;
24916 }
24917 {
24918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24919 }
24920 return resultobj;
24921 fail:
24922 return NULL;
24923 }
24924
24925
24926 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24927 PyObject *resultobj;
24928 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24929 wxTimeSpan *arg2 = 0 ;
24930 bool result;
24931 PyObject * obj0 = 0 ;
24932 PyObject * obj1 = 0 ;
24933 char *kwnames[] = {
24934 (char *) "self",(char *) "ts", NULL
24935 };
24936
24937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24939 if (SWIG_arg_fail(1)) SWIG_fail;
24940 {
24941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24942 if (SWIG_arg_fail(2)) SWIG_fail;
24943 if (arg2 == NULL) {
24944 SWIG_null_ref("wxTimeSpan");
24945 }
24946 if (SWIG_arg_fail(2)) SWIG_fail;
24947 }
24948 {
24949 PyThreadState* __tstate = wxPyBeginAllowThreads();
24950 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24951
24952 wxPyEndAllowThreads(__tstate);
24953 if (PyErr_Occurred()) SWIG_fail;
24954 }
24955 {
24956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24957 }
24958 return resultobj;
24959 fail:
24960 return NULL;
24961 }
24962
24963
24964 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24965 PyObject *resultobj;
24966 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24967 wxTimeSpan *arg2 = 0 ;
24968 bool result;
24969 PyObject * obj0 = 0 ;
24970 PyObject * obj1 = 0 ;
24971 char *kwnames[] = {
24972 (char *) "self",(char *) "ts", NULL
24973 };
24974
24975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24977 if (SWIG_arg_fail(1)) SWIG_fail;
24978 {
24979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24980 if (SWIG_arg_fail(2)) SWIG_fail;
24981 if (arg2 == NULL) {
24982 SWIG_null_ref("wxTimeSpan");
24983 }
24984 if (SWIG_arg_fail(2)) SWIG_fail;
24985 }
24986 {
24987 PyThreadState* __tstate = wxPyBeginAllowThreads();
24988 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24989
24990 wxPyEndAllowThreads(__tstate);
24991 if (PyErr_Occurred()) SWIG_fail;
24992 }
24993 {
24994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24995 }
24996 return resultobj;
24997 fail:
24998 return NULL;
24999 }
25000
25001
25002 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25003 PyObject *resultobj;
25004 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25005 wxTimeSpan *arg2 = 0 ;
25006 bool result;
25007 PyObject * obj0 = 0 ;
25008 PyObject * obj1 = 0 ;
25009 char *kwnames[] = {
25010 (char *) "self",(char *) "t", NULL
25011 };
25012
25013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25015 if (SWIG_arg_fail(1)) SWIG_fail;
25016 {
25017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25018 if (SWIG_arg_fail(2)) SWIG_fail;
25019 if (arg2 == NULL) {
25020 SWIG_null_ref("wxTimeSpan");
25021 }
25022 if (SWIG_arg_fail(2)) SWIG_fail;
25023 }
25024 {
25025 PyThreadState* __tstate = wxPyBeginAllowThreads();
25026 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25027
25028 wxPyEndAllowThreads(__tstate);
25029 if (PyErr_Occurred()) SWIG_fail;
25030 }
25031 {
25032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25033 }
25034 return resultobj;
25035 fail:
25036 return NULL;
25037 }
25038
25039
25040 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25041 PyObject *resultobj;
25042 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25043 int result;
25044 PyObject * obj0 = 0 ;
25045 char *kwnames[] = {
25046 (char *) "self", NULL
25047 };
25048
25049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25051 if (SWIG_arg_fail(1)) SWIG_fail;
25052 {
25053 PyThreadState* __tstate = wxPyBeginAllowThreads();
25054 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25055
25056 wxPyEndAllowThreads(__tstate);
25057 if (PyErr_Occurred()) SWIG_fail;
25058 }
25059 {
25060 resultobj = SWIG_From_int((int)(result));
25061 }
25062 return resultobj;
25063 fail:
25064 return NULL;
25065 }
25066
25067
25068 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25069 PyObject *resultobj;
25070 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25071 int result;
25072 PyObject * obj0 = 0 ;
25073 char *kwnames[] = {
25074 (char *) "self", NULL
25075 };
25076
25077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25079 if (SWIG_arg_fail(1)) SWIG_fail;
25080 {
25081 PyThreadState* __tstate = wxPyBeginAllowThreads();
25082 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25083
25084 wxPyEndAllowThreads(__tstate);
25085 if (PyErr_Occurred()) SWIG_fail;
25086 }
25087 {
25088 resultobj = SWIG_From_int((int)(result));
25089 }
25090 return resultobj;
25091 fail:
25092 return NULL;
25093 }
25094
25095
25096 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25097 PyObject *resultobj;
25098 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25099 int result;
25100 PyObject * obj0 = 0 ;
25101 char *kwnames[] = {
25102 (char *) "self", NULL
25103 };
25104
25105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25107 if (SWIG_arg_fail(1)) SWIG_fail;
25108 {
25109 PyThreadState* __tstate = wxPyBeginAllowThreads();
25110 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25111
25112 wxPyEndAllowThreads(__tstate);
25113 if (PyErr_Occurred()) SWIG_fail;
25114 }
25115 {
25116 resultobj = SWIG_From_int((int)(result));
25117 }
25118 return resultobj;
25119 fail:
25120 return NULL;
25121 }
25122
25123
25124 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25125 PyObject *resultobj;
25126 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25127 int result;
25128 PyObject * obj0 = 0 ;
25129 char *kwnames[] = {
25130 (char *) "self", NULL
25131 };
25132
25133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25135 if (SWIG_arg_fail(1)) SWIG_fail;
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25139
25140 wxPyEndAllowThreads(__tstate);
25141 if (PyErr_Occurred()) SWIG_fail;
25142 }
25143 {
25144 resultobj = SWIG_From_int((int)(result));
25145 }
25146 return resultobj;
25147 fail:
25148 return NULL;
25149 }
25150
25151
25152 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25153 PyObject *resultobj;
25154 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25155 wxLongLong result;
25156 PyObject * obj0 = 0 ;
25157 char *kwnames[] = {
25158 (char *) "self", NULL
25159 };
25160
25161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25163 if (SWIG_arg_fail(1)) SWIG_fail;
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25167
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 {
25172 PyObject *hi, *lo, *shifter, *shifted;
25173 hi = PyLong_FromLong( (&result)->GetHi() );
25174 lo = PyLong_FromLong( (&result)->GetLo() );
25175 shifter = PyLong_FromLong(32);
25176 shifted = PyNumber_Lshift(hi, shifter);
25177 resultobj = PyNumber_Or(shifted, lo);
25178 Py_DECREF(hi);
25179 Py_DECREF(lo);
25180 Py_DECREF(shifter);
25181 Py_DECREF(shifted);
25182 }
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25190 PyObject *resultobj;
25191 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25192 wxLongLong result;
25193 PyObject * obj0 = 0 ;
25194 char *kwnames[] = {
25195 (char *) "self", NULL
25196 };
25197
25198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25200 if (SWIG_arg_fail(1)) SWIG_fail;
25201 {
25202 PyThreadState* __tstate = wxPyBeginAllowThreads();
25203 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25204
25205 wxPyEndAllowThreads(__tstate);
25206 if (PyErr_Occurred()) SWIG_fail;
25207 }
25208 {
25209 PyObject *hi, *lo, *shifter, *shifted;
25210 hi = PyLong_FromLong( (&result)->GetHi() );
25211 lo = PyLong_FromLong( (&result)->GetLo() );
25212 shifter = PyLong_FromLong(32);
25213 shifted = PyNumber_Lshift(hi, shifter);
25214 resultobj = PyNumber_Or(shifted, lo);
25215 Py_DECREF(hi);
25216 Py_DECREF(lo);
25217 Py_DECREF(shifter);
25218 Py_DECREF(shifted);
25219 }
25220 return resultobj;
25221 fail:
25222 return NULL;
25223 }
25224
25225
25226 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25227 PyObject *resultobj;
25228 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25229 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25230 wxString *arg2 = (wxString *) &arg2_defvalue ;
25231 wxString result;
25232 bool temp2 = false ;
25233 PyObject * obj0 = 0 ;
25234 PyObject * obj1 = 0 ;
25235 char *kwnames[] = {
25236 (char *) "self",(char *) "format", NULL
25237 };
25238
25239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25241 if (SWIG_arg_fail(1)) SWIG_fail;
25242 if (obj1) {
25243 {
25244 arg2 = wxString_in_helper(obj1);
25245 if (arg2 == NULL) SWIG_fail;
25246 temp2 = true;
25247 }
25248 }
25249 {
25250 PyThreadState* __tstate = wxPyBeginAllowThreads();
25251 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25252
25253 wxPyEndAllowThreads(__tstate);
25254 if (PyErr_Occurred()) SWIG_fail;
25255 }
25256 {
25257 #if wxUSE_UNICODE
25258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25259 #else
25260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25261 #endif
25262 }
25263 {
25264 if (temp2)
25265 delete arg2;
25266 }
25267 return resultobj;
25268 fail:
25269 {
25270 if (temp2)
25271 delete arg2;
25272 }
25273 return NULL;
25274 }
25275
25276
25277 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25278 PyObject *obj;
25279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25280 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25281 Py_INCREF(obj);
25282 return Py_BuildValue((char *)"");
25283 }
25284 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25285 PyObject *resultobj;
25286 int arg1 = (int) 0 ;
25287 int arg2 = (int) 0 ;
25288 int arg3 = (int) 0 ;
25289 int arg4 = (int) 0 ;
25290 wxDateSpan *result;
25291 PyObject * obj0 = 0 ;
25292 PyObject * obj1 = 0 ;
25293 PyObject * obj2 = 0 ;
25294 PyObject * obj3 = 0 ;
25295 char *kwnames[] = {
25296 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25297 };
25298
25299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25300 if (obj0) {
25301 {
25302 arg1 = (int)(SWIG_As_int(obj0));
25303 if (SWIG_arg_fail(1)) SWIG_fail;
25304 }
25305 }
25306 if (obj1) {
25307 {
25308 arg2 = (int)(SWIG_As_int(obj1));
25309 if (SWIG_arg_fail(2)) SWIG_fail;
25310 }
25311 }
25312 if (obj2) {
25313 {
25314 arg3 = (int)(SWIG_As_int(obj2));
25315 if (SWIG_arg_fail(3)) SWIG_fail;
25316 }
25317 }
25318 if (obj3) {
25319 {
25320 arg4 = (int)(SWIG_As_int(obj3));
25321 if (SWIG_arg_fail(4)) SWIG_fail;
25322 }
25323 }
25324 {
25325 PyThreadState* __tstate = wxPyBeginAllowThreads();
25326 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25327
25328 wxPyEndAllowThreads(__tstate);
25329 if (PyErr_Occurred()) SWIG_fail;
25330 }
25331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25332 return resultobj;
25333 fail:
25334 return NULL;
25335 }
25336
25337
25338 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25339 PyObject *resultobj;
25340 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25341 PyObject * obj0 = 0 ;
25342 char *kwnames[] = {
25343 (char *) "self", NULL
25344 };
25345
25346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25348 if (SWIG_arg_fail(1)) SWIG_fail;
25349 {
25350 PyThreadState* __tstate = wxPyBeginAllowThreads();
25351 delete arg1;
25352
25353 wxPyEndAllowThreads(__tstate);
25354 if (PyErr_Occurred()) SWIG_fail;
25355 }
25356 Py_INCREF(Py_None); resultobj = Py_None;
25357 return resultobj;
25358 fail:
25359 return NULL;
25360 }
25361
25362
25363 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25364 PyObject *resultobj;
25365 int arg1 ;
25366 wxDateSpan result;
25367 PyObject * obj0 = 0 ;
25368 char *kwnames[] = {
25369 (char *) "days", NULL
25370 };
25371
25372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25373 {
25374 arg1 = (int)(SWIG_As_int(obj0));
25375 if (SWIG_arg_fail(1)) SWIG_fail;
25376 }
25377 {
25378 PyThreadState* __tstate = wxPyBeginAllowThreads();
25379 result = wxDateSpan::Days(arg1);
25380
25381 wxPyEndAllowThreads(__tstate);
25382 if (PyErr_Occurred()) SWIG_fail;
25383 }
25384 {
25385 wxDateSpan * resultptr;
25386 resultptr = new wxDateSpan((wxDateSpan &)(result));
25387 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25388 }
25389 return resultobj;
25390 fail:
25391 return NULL;
25392 }
25393
25394
25395 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25396 PyObject *resultobj;
25397 wxDateSpan result;
25398 char *kwnames[] = {
25399 NULL
25400 };
25401
25402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25403 {
25404 PyThreadState* __tstate = wxPyBeginAllowThreads();
25405 result = wxDateSpan::Day();
25406
25407 wxPyEndAllowThreads(__tstate);
25408 if (PyErr_Occurred()) SWIG_fail;
25409 }
25410 {
25411 wxDateSpan * resultptr;
25412 resultptr = new wxDateSpan((wxDateSpan &)(result));
25413 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25414 }
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25422 PyObject *resultobj;
25423 int arg1 ;
25424 wxDateSpan result;
25425 PyObject * obj0 = 0 ;
25426 char *kwnames[] = {
25427 (char *) "weeks", NULL
25428 };
25429
25430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25431 {
25432 arg1 = (int)(SWIG_As_int(obj0));
25433 if (SWIG_arg_fail(1)) SWIG_fail;
25434 }
25435 {
25436 PyThreadState* __tstate = wxPyBeginAllowThreads();
25437 result = wxDateSpan::Weeks(arg1);
25438
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 {
25443 wxDateSpan * resultptr;
25444 resultptr = new wxDateSpan((wxDateSpan &)(result));
25445 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25446 }
25447 return resultobj;
25448 fail:
25449 return NULL;
25450 }
25451
25452
25453 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25454 PyObject *resultobj;
25455 wxDateSpan result;
25456 char *kwnames[] = {
25457 NULL
25458 };
25459
25460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25461 {
25462 PyThreadState* __tstate = wxPyBeginAllowThreads();
25463 result = wxDateSpan::Week();
25464
25465 wxPyEndAllowThreads(__tstate);
25466 if (PyErr_Occurred()) SWIG_fail;
25467 }
25468 {
25469 wxDateSpan * resultptr;
25470 resultptr = new wxDateSpan((wxDateSpan &)(result));
25471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25472 }
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25480 PyObject *resultobj;
25481 int arg1 ;
25482 wxDateSpan result;
25483 PyObject * obj0 = 0 ;
25484 char *kwnames[] = {
25485 (char *) "mon", NULL
25486 };
25487
25488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25489 {
25490 arg1 = (int)(SWIG_As_int(obj0));
25491 if (SWIG_arg_fail(1)) SWIG_fail;
25492 }
25493 {
25494 PyThreadState* __tstate = wxPyBeginAllowThreads();
25495 result = wxDateSpan::Months(arg1);
25496
25497 wxPyEndAllowThreads(__tstate);
25498 if (PyErr_Occurred()) SWIG_fail;
25499 }
25500 {
25501 wxDateSpan * resultptr;
25502 resultptr = new wxDateSpan((wxDateSpan &)(result));
25503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25504 }
25505 return resultobj;
25506 fail:
25507 return NULL;
25508 }
25509
25510
25511 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25512 PyObject *resultobj;
25513 wxDateSpan result;
25514 char *kwnames[] = {
25515 NULL
25516 };
25517
25518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25519 {
25520 PyThreadState* __tstate = wxPyBeginAllowThreads();
25521 result = wxDateSpan::Month();
25522
25523 wxPyEndAllowThreads(__tstate);
25524 if (PyErr_Occurred()) SWIG_fail;
25525 }
25526 {
25527 wxDateSpan * resultptr;
25528 resultptr = new wxDateSpan((wxDateSpan &)(result));
25529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25530 }
25531 return resultobj;
25532 fail:
25533 return NULL;
25534 }
25535
25536
25537 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25538 PyObject *resultobj;
25539 int arg1 ;
25540 wxDateSpan result;
25541 PyObject * obj0 = 0 ;
25542 char *kwnames[] = {
25543 (char *) "years", NULL
25544 };
25545
25546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25547 {
25548 arg1 = (int)(SWIG_As_int(obj0));
25549 if (SWIG_arg_fail(1)) SWIG_fail;
25550 }
25551 {
25552 PyThreadState* __tstate = wxPyBeginAllowThreads();
25553 result = wxDateSpan::Years(arg1);
25554
25555 wxPyEndAllowThreads(__tstate);
25556 if (PyErr_Occurred()) SWIG_fail;
25557 }
25558 {
25559 wxDateSpan * resultptr;
25560 resultptr = new wxDateSpan((wxDateSpan &)(result));
25561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25562 }
25563 return resultobj;
25564 fail:
25565 return NULL;
25566 }
25567
25568
25569 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25570 PyObject *resultobj;
25571 wxDateSpan result;
25572 char *kwnames[] = {
25573 NULL
25574 };
25575
25576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 result = wxDateSpan::Year();
25580
25581 wxPyEndAllowThreads(__tstate);
25582 if (PyErr_Occurred()) SWIG_fail;
25583 }
25584 {
25585 wxDateSpan * resultptr;
25586 resultptr = new wxDateSpan((wxDateSpan &)(result));
25587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25588 }
25589 return resultobj;
25590 fail:
25591 return NULL;
25592 }
25593
25594
25595 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25596 PyObject *resultobj;
25597 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25598 int arg2 ;
25599 wxDateSpan *result;
25600 PyObject * obj0 = 0 ;
25601 PyObject * obj1 = 0 ;
25602 char *kwnames[] = {
25603 (char *) "self",(char *) "n", NULL
25604 };
25605
25606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25608 if (SWIG_arg_fail(1)) SWIG_fail;
25609 {
25610 arg2 = (int)(SWIG_As_int(obj1));
25611 if (SWIG_arg_fail(2)) SWIG_fail;
25612 }
25613 {
25614 PyThreadState* __tstate = wxPyBeginAllowThreads();
25615 {
25616 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25617 result = (wxDateSpan *) &_result_ref;
25618 }
25619
25620 wxPyEndAllowThreads(__tstate);
25621 if (PyErr_Occurred()) SWIG_fail;
25622 }
25623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25631 PyObject *resultobj;
25632 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25633 int arg2 ;
25634 wxDateSpan *result;
25635 PyObject * obj0 = 0 ;
25636 PyObject * obj1 = 0 ;
25637 char *kwnames[] = {
25638 (char *) "self",(char *) "n", NULL
25639 };
25640
25641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25643 if (SWIG_arg_fail(1)) SWIG_fail;
25644 {
25645 arg2 = (int)(SWIG_As_int(obj1));
25646 if (SWIG_arg_fail(2)) SWIG_fail;
25647 }
25648 {
25649 PyThreadState* __tstate = wxPyBeginAllowThreads();
25650 {
25651 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25652 result = (wxDateSpan *) &_result_ref;
25653 }
25654
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25659 return resultobj;
25660 fail:
25661 return NULL;
25662 }
25663
25664
25665 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25666 PyObject *resultobj;
25667 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25668 int arg2 ;
25669 wxDateSpan *result;
25670 PyObject * obj0 = 0 ;
25671 PyObject * obj1 = 0 ;
25672 char *kwnames[] = {
25673 (char *) "self",(char *) "n", NULL
25674 };
25675
25676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25678 if (SWIG_arg_fail(1)) SWIG_fail;
25679 {
25680 arg2 = (int)(SWIG_As_int(obj1));
25681 if (SWIG_arg_fail(2)) SWIG_fail;
25682 }
25683 {
25684 PyThreadState* __tstate = wxPyBeginAllowThreads();
25685 {
25686 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25687 result = (wxDateSpan *) &_result_ref;
25688 }
25689
25690 wxPyEndAllowThreads(__tstate);
25691 if (PyErr_Occurred()) SWIG_fail;
25692 }
25693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25694 return resultobj;
25695 fail:
25696 return NULL;
25697 }
25698
25699
25700 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25701 PyObject *resultobj;
25702 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25703 int arg2 ;
25704 wxDateSpan *result;
25705 PyObject * obj0 = 0 ;
25706 PyObject * obj1 = 0 ;
25707 char *kwnames[] = {
25708 (char *) "self",(char *) "n", NULL
25709 };
25710
25711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25713 if (SWIG_arg_fail(1)) SWIG_fail;
25714 {
25715 arg2 = (int)(SWIG_As_int(obj1));
25716 if (SWIG_arg_fail(2)) SWIG_fail;
25717 }
25718 {
25719 PyThreadState* __tstate = wxPyBeginAllowThreads();
25720 {
25721 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25722 result = (wxDateSpan *) &_result_ref;
25723 }
25724
25725 wxPyEndAllowThreads(__tstate);
25726 if (PyErr_Occurred()) SWIG_fail;
25727 }
25728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25729 return resultobj;
25730 fail:
25731 return NULL;
25732 }
25733
25734
25735 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25736 PyObject *resultobj;
25737 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25738 int result;
25739 PyObject * obj0 = 0 ;
25740 char *kwnames[] = {
25741 (char *) "self", NULL
25742 };
25743
25744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25746 if (SWIG_arg_fail(1)) SWIG_fail;
25747 {
25748 PyThreadState* __tstate = wxPyBeginAllowThreads();
25749 result = (int)((wxDateSpan const *)arg1)->GetYears();
25750
25751 wxPyEndAllowThreads(__tstate);
25752 if (PyErr_Occurred()) SWIG_fail;
25753 }
25754 {
25755 resultobj = SWIG_From_int((int)(result));
25756 }
25757 return resultobj;
25758 fail:
25759 return NULL;
25760 }
25761
25762
25763 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25764 PyObject *resultobj;
25765 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25766 int result;
25767 PyObject * obj0 = 0 ;
25768 char *kwnames[] = {
25769 (char *) "self", NULL
25770 };
25771
25772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25774 if (SWIG_arg_fail(1)) SWIG_fail;
25775 {
25776 PyThreadState* __tstate = wxPyBeginAllowThreads();
25777 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25778
25779 wxPyEndAllowThreads(__tstate);
25780 if (PyErr_Occurred()) SWIG_fail;
25781 }
25782 {
25783 resultobj = SWIG_From_int((int)(result));
25784 }
25785 return resultobj;
25786 fail:
25787 return NULL;
25788 }
25789
25790
25791 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25792 PyObject *resultobj;
25793 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25794 int result;
25795 PyObject * obj0 = 0 ;
25796 char *kwnames[] = {
25797 (char *) "self", NULL
25798 };
25799
25800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25802 if (SWIG_arg_fail(1)) SWIG_fail;
25803 {
25804 PyThreadState* __tstate = wxPyBeginAllowThreads();
25805 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25806
25807 wxPyEndAllowThreads(__tstate);
25808 if (PyErr_Occurred()) SWIG_fail;
25809 }
25810 {
25811 resultobj = SWIG_From_int((int)(result));
25812 }
25813 return resultobj;
25814 fail:
25815 return NULL;
25816 }
25817
25818
25819 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25820 PyObject *resultobj;
25821 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25822 int result;
25823 PyObject * obj0 = 0 ;
25824 char *kwnames[] = {
25825 (char *) "self", NULL
25826 };
25827
25828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25830 if (SWIG_arg_fail(1)) SWIG_fail;
25831 {
25832 PyThreadState* __tstate = wxPyBeginAllowThreads();
25833 result = (int)((wxDateSpan const *)arg1)->GetDays();
25834
25835 wxPyEndAllowThreads(__tstate);
25836 if (PyErr_Occurred()) SWIG_fail;
25837 }
25838 {
25839 resultobj = SWIG_From_int((int)(result));
25840 }
25841 return resultobj;
25842 fail:
25843 return NULL;
25844 }
25845
25846
25847 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25848 PyObject *resultobj;
25849 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25850 int result;
25851 PyObject * obj0 = 0 ;
25852 char *kwnames[] = {
25853 (char *) "self", NULL
25854 };
25855
25856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25858 if (SWIG_arg_fail(1)) SWIG_fail;
25859 {
25860 PyThreadState* __tstate = wxPyBeginAllowThreads();
25861 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25862
25863 wxPyEndAllowThreads(__tstate);
25864 if (PyErr_Occurred()) SWIG_fail;
25865 }
25866 {
25867 resultobj = SWIG_From_int((int)(result));
25868 }
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25876 PyObject *resultobj;
25877 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25878 wxDateSpan *arg2 = 0 ;
25879 wxDateSpan *result;
25880 PyObject * obj0 = 0 ;
25881 PyObject * obj1 = 0 ;
25882 char *kwnames[] = {
25883 (char *) "self",(char *) "other", NULL
25884 };
25885
25886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25888 if (SWIG_arg_fail(1)) SWIG_fail;
25889 {
25890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25891 if (SWIG_arg_fail(2)) SWIG_fail;
25892 if (arg2 == NULL) {
25893 SWIG_null_ref("wxDateSpan");
25894 }
25895 if (SWIG_arg_fail(2)) SWIG_fail;
25896 }
25897 {
25898 PyThreadState* __tstate = wxPyBeginAllowThreads();
25899 {
25900 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25901 result = (wxDateSpan *) &_result_ref;
25902 }
25903
25904 wxPyEndAllowThreads(__tstate);
25905 if (PyErr_Occurred()) SWIG_fail;
25906 }
25907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25915 PyObject *resultobj;
25916 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25917 wxDateSpan *arg2 = 0 ;
25918 wxDateSpan *result;
25919 PyObject * obj0 = 0 ;
25920 PyObject * obj1 = 0 ;
25921 char *kwnames[] = {
25922 (char *) "self",(char *) "other", NULL
25923 };
25924
25925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25927 if (SWIG_arg_fail(1)) SWIG_fail;
25928 {
25929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25930 if (SWIG_arg_fail(2)) SWIG_fail;
25931 if (arg2 == NULL) {
25932 SWIG_null_ref("wxDateSpan");
25933 }
25934 if (SWIG_arg_fail(2)) SWIG_fail;
25935 }
25936 {
25937 PyThreadState* __tstate = wxPyBeginAllowThreads();
25938 {
25939 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25940 result = (wxDateSpan *) &_result_ref;
25941 }
25942
25943 wxPyEndAllowThreads(__tstate);
25944 if (PyErr_Occurred()) SWIG_fail;
25945 }
25946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25947 return resultobj;
25948 fail:
25949 return NULL;
25950 }
25951
25952
25953 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25954 PyObject *resultobj;
25955 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25956 wxDateSpan *result;
25957 PyObject * obj0 = 0 ;
25958 char *kwnames[] = {
25959 (char *) "self", NULL
25960 };
25961
25962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25964 if (SWIG_arg_fail(1)) SWIG_fail;
25965 {
25966 PyThreadState* __tstate = wxPyBeginAllowThreads();
25967 {
25968 wxDateSpan &_result_ref = (arg1)->Neg();
25969 result = (wxDateSpan *) &_result_ref;
25970 }
25971
25972 wxPyEndAllowThreads(__tstate);
25973 if (PyErr_Occurred()) SWIG_fail;
25974 }
25975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25976 return resultobj;
25977 fail:
25978 return NULL;
25979 }
25980
25981
25982 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25983 PyObject *resultobj;
25984 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25985 int arg2 ;
25986 wxDateSpan *result;
25987 PyObject * obj0 = 0 ;
25988 PyObject * obj1 = 0 ;
25989 char *kwnames[] = {
25990 (char *) "self",(char *) "factor", NULL
25991 };
25992
25993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25995 if (SWIG_arg_fail(1)) SWIG_fail;
25996 {
25997 arg2 = (int)(SWIG_As_int(obj1));
25998 if (SWIG_arg_fail(2)) SWIG_fail;
25999 }
26000 {
26001 PyThreadState* __tstate = wxPyBeginAllowThreads();
26002 {
26003 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26004 result = (wxDateSpan *) &_result_ref;
26005 }
26006
26007 wxPyEndAllowThreads(__tstate);
26008 if (PyErr_Occurred()) SWIG_fail;
26009 }
26010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26011 return resultobj;
26012 fail:
26013 return NULL;
26014 }
26015
26016
26017 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26018 PyObject *resultobj;
26019 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26020 wxDateSpan *arg2 = 0 ;
26021 wxDateSpan *result;
26022 PyObject * obj0 = 0 ;
26023 PyObject * obj1 = 0 ;
26024 char *kwnames[] = {
26025 (char *) "self",(char *) "other", NULL
26026 };
26027
26028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26030 if (SWIG_arg_fail(1)) SWIG_fail;
26031 {
26032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26033 if (SWIG_arg_fail(2)) SWIG_fail;
26034 if (arg2 == NULL) {
26035 SWIG_null_ref("wxDateSpan");
26036 }
26037 if (SWIG_arg_fail(2)) SWIG_fail;
26038 }
26039 {
26040 PyThreadState* __tstate = wxPyBeginAllowThreads();
26041 {
26042 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26043 result = (wxDateSpan *) &_result_ref;
26044 }
26045
26046 wxPyEndAllowThreads(__tstate);
26047 if (PyErr_Occurred()) SWIG_fail;
26048 }
26049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26050 return resultobj;
26051 fail:
26052 return NULL;
26053 }
26054
26055
26056 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26057 PyObject *resultobj;
26058 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26059 wxDateSpan *arg2 = 0 ;
26060 wxDateSpan *result;
26061 PyObject * obj0 = 0 ;
26062 PyObject * obj1 = 0 ;
26063 char *kwnames[] = {
26064 (char *) "self",(char *) "other", NULL
26065 };
26066
26067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26069 if (SWIG_arg_fail(1)) SWIG_fail;
26070 {
26071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26072 if (SWIG_arg_fail(2)) SWIG_fail;
26073 if (arg2 == NULL) {
26074 SWIG_null_ref("wxDateSpan");
26075 }
26076 if (SWIG_arg_fail(2)) SWIG_fail;
26077 }
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 {
26081 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26082 result = (wxDateSpan *) &_result_ref;
26083 }
26084
26085 wxPyEndAllowThreads(__tstate);
26086 if (PyErr_Occurred()) SWIG_fail;
26087 }
26088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26089 return resultobj;
26090 fail:
26091 return NULL;
26092 }
26093
26094
26095 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26096 PyObject *resultobj;
26097 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26098 wxDateSpan *result;
26099 PyObject * obj0 = 0 ;
26100 char *kwnames[] = {
26101 (char *) "self", NULL
26102 };
26103
26104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26106 if (SWIG_arg_fail(1)) SWIG_fail;
26107 {
26108 PyThreadState* __tstate = wxPyBeginAllowThreads();
26109 {
26110 wxDateSpan &_result_ref = (arg1)->operator -();
26111 result = (wxDateSpan *) &_result_ref;
26112 }
26113
26114 wxPyEndAllowThreads(__tstate);
26115 if (PyErr_Occurred()) SWIG_fail;
26116 }
26117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26118 return resultobj;
26119 fail:
26120 return NULL;
26121 }
26122
26123
26124 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26125 PyObject *resultobj;
26126 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26127 int arg2 ;
26128 wxDateSpan *result;
26129 PyObject * obj0 = 0 ;
26130 PyObject * obj1 = 0 ;
26131 char *kwnames[] = {
26132 (char *) "self",(char *) "factor", NULL
26133 };
26134
26135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26137 if (SWIG_arg_fail(1)) SWIG_fail;
26138 {
26139 arg2 = (int)(SWIG_As_int(obj1));
26140 if (SWIG_arg_fail(2)) SWIG_fail;
26141 }
26142 {
26143 PyThreadState* __tstate = wxPyBeginAllowThreads();
26144 {
26145 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26146 result = (wxDateSpan *) &_result_ref;
26147 }
26148
26149 wxPyEndAllowThreads(__tstate);
26150 if (PyErr_Occurred()) SWIG_fail;
26151 }
26152 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26153 return resultobj;
26154 fail:
26155 return NULL;
26156 }
26157
26158
26159 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26160 PyObject *resultobj;
26161 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26162 wxDateSpan *arg2 = 0 ;
26163 wxDateSpan result;
26164 PyObject * obj0 = 0 ;
26165 PyObject * obj1 = 0 ;
26166 char *kwnames[] = {
26167 (char *) "self",(char *) "other", NULL
26168 };
26169
26170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26172 if (SWIG_arg_fail(1)) SWIG_fail;
26173 {
26174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26175 if (SWIG_arg_fail(2)) SWIG_fail;
26176 if (arg2 == NULL) {
26177 SWIG_null_ref("wxDateSpan");
26178 }
26179 if (SWIG_arg_fail(2)) SWIG_fail;
26180 }
26181 {
26182 PyThreadState* __tstate = wxPyBeginAllowThreads();
26183 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26184
26185 wxPyEndAllowThreads(__tstate);
26186 if (PyErr_Occurred()) SWIG_fail;
26187 }
26188 {
26189 wxDateSpan * resultptr;
26190 resultptr = new wxDateSpan((wxDateSpan &)(result));
26191 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26192 }
26193 return resultobj;
26194 fail:
26195 return NULL;
26196 }
26197
26198
26199 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26200 PyObject *resultobj;
26201 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26202 wxDateSpan *arg2 = 0 ;
26203 wxDateSpan result;
26204 PyObject * obj0 = 0 ;
26205 PyObject * obj1 = 0 ;
26206 char *kwnames[] = {
26207 (char *) "self",(char *) "other", NULL
26208 };
26209
26210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26212 if (SWIG_arg_fail(1)) SWIG_fail;
26213 {
26214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26215 if (SWIG_arg_fail(2)) SWIG_fail;
26216 if (arg2 == NULL) {
26217 SWIG_null_ref("wxDateSpan");
26218 }
26219 if (SWIG_arg_fail(2)) SWIG_fail;
26220 }
26221 {
26222 PyThreadState* __tstate = wxPyBeginAllowThreads();
26223 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26224
26225 wxPyEndAllowThreads(__tstate);
26226 if (PyErr_Occurred()) SWIG_fail;
26227 }
26228 {
26229 wxDateSpan * resultptr;
26230 resultptr = new wxDateSpan((wxDateSpan &)(result));
26231 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26232 }
26233 return resultobj;
26234 fail:
26235 return NULL;
26236 }
26237
26238
26239 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26240 PyObject *resultobj;
26241 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26242 int arg2 ;
26243 wxDateSpan result;
26244 PyObject * obj0 = 0 ;
26245 PyObject * obj1 = 0 ;
26246 char *kwnames[] = {
26247 (char *) "self",(char *) "n", NULL
26248 };
26249
26250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26252 if (SWIG_arg_fail(1)) SWIG_fail;
26253 {
26254 arg2 = (int)(SWIG_As_int(obj1));
26255 if (SWIG_arg_fail(2)) SWIG_fail;
26256 }
26257 {
26258 PyThreadState* __tstate = wxPyBeginAllowThreads();
26259 result = wxDateSpan___mul__(arg1,arg2);
26260
26261 wxPyEndAllowThreads(__tstate);
26262 if (PyErr_Occurred()) SWIG_fail;
26263 }
26264 {
26265 wxDateSpan * resultptr;
26266 resultptr = new wxDateSpan((wxDateSpan &)(result));
26267 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26268 }
26269 return resultobj;
26270 fail:
26271 return NULL;
26272 }
26273
26274
26275 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26276 PyObject *resultobj;
26277 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26278 int arg2 ;
26279 wxDateSpan result;
26280 PyObject * obj0 = 0 ;
26281 PyObject * obj1 = 0 ;
26282 char *kwnames[] = {
26283 (char *) "self",(char *) "n", NULL
26284 };
26285
26286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26288 if (SWIG_arg_fail(1)) SWIG_fail;
26289 {
26290 arg2 = (int)(SWIG_As_int(obj1));
26291 if (SWIG_arg_fail(2)) SWIG_fail;
26292 }
26293 {
26294 PyThreadState* __tstate = wxPyBeginAllowThreads();
26295 result = wxDateSpan___rmul__(arg1,arg2);
26296
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 {
26301 wxDateSpan * resultptr;
26302 resultptr = new wxDateSpan((wxDateSpan &)(result));
26303 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26304 }
26305 return resultobj;
26306 fail:
26307 return NULL;
26308 }
26309
26310
26311 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26312 PyObject *resultobj;
26313 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26314 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26315 bool result;
26316 PyObject * obj0 = 0 ;
26317 PyObject * obj1 = 0 ;
26318 char *kwnames[] = {
26319 (char *) "self",(char *) "other", NULL
26320 };
26321
26322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26324 if (SWIG_arg_fail(1)) SWIG_fail;
26325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26326 if (SWIG_arg_fail(2)) SWIG_fail;
26327 {
26328 PyThreadState* __tstate = wxPyBeginAllowThreads();
26329 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26330
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 {
26335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26336 }
26337 return resultobj;
26338 fail:
26339 return NULL;
26340 }
26341
26342
26343 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26344 PyObject *resultobj;
26345 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26346 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26347 bool result;
26348 PyObject * obj0 = 0 ;
26349 PyObject * obj1 = 0 ;
26350 char *kwnames[] = {
26351 (char *) "self",(char *) "other", NULL
26352 };
26353
26354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26356 if (SWIG_arg_fail(1)) SWIG_fail;
26357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26358 if (SWIG_arg_fail(2)) SWIG_fail;
26359 {
26360 PyThreadState* __tstate = wxPyBeginAllowThreads();
26361 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26362
26363 wxPyEndAllowThreads(__tstate);
26364 if (PyErr_Occurred()) SWIG_fail;
26365 }
26366 {
26367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26368 }
26369 return resultobj;
26370 fail:
26371 return NULL;
26372 }
26373
26374
26375 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26376 PyObject *obj;
26377 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26378 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26379 Py_INCREF(obj);
26380 return Py_BuildValue((char *)"");
26381 }
26382 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26383 PyObject *resultobj;
26384 long result;
26385 char *kwnames[] = {
26386 NULL
26387 };
26388
26389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26390 {
26391 PyThreadState* __tstate = wxPyBeginAllowThreads();
26392 result = (long)wxGetLocalTime();
26393
26394 wxPyEndAllowThreads(__tstate);
26395 if (PyErr_Occurred()) SWIG_fail;
26396 }
26397 {
26398 resultobj = SWIG_From_long((long)(result));
26399 }
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26407 PyObject *resultobj;
26408 long result;
26409 char *kwnames[] = {
26410 NULL
26411 };
26412
26413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26414 {
26415 PyThreadState* __tstate = wxPyBeginAllowThreads();
26416 result = (long)wxGetUTCTime();
26417
26418 wxPyEndAllowThreads(__tstate);
26419 if (PyErr_Occurred()) SWIG_fail;
26420 }
26421 {
26422 resultobj = SWIG_From_long((long)(result));
26423 }
26424 return resultobj;
26425 fail:
26426 return NULL;
26427 }
26428
26429
26430 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26431 PyObject *resultobj;
26432 long result;
26433 char *kwnames[] = {
26434 NULL
26435 };
26436
26437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26438 {
26439 PyThreadState* __tstate = wxPyBeginAllowThreads();
26440 result = (long)wxGetCurrentTime();
26441
26442 wxPyEndAllowThreads(__tstate);
26443 if (PyErr_Occurred()) SWIG_fail;
26444 }
26445 {
26446 resultobj = SWIG_From_long((long)(result));
26447 }
26448 return resultobj;
26449 fail:
26450 return NULL;
26451 }
26452
26453
26454 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26455 PyObject *resultobj;
26456 wxLongLong result;
26457 char *kwnames[] = {
26458 NULL
26459 };
26460
26461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26462 {
26463 PyThreadState* __tstate = wxPyBeginAllowThreads();
26464 result = wxGetLocalTimeMillis();
26465
26466 wxPyEndAllowThreads(__tstate);
26467 if (PyErr_Occurred()) SWIG_fail;
26468 }
26469 {
26470 PyObject *hi, *lo, *shifter, *shifted;
26471 hi = PyLong_FromLong( (&result)->GetHi() );
26472 lo = PyLong_FromLong( (&result)->GetLo() );
26473 shifter = PyLong_FromLong(32);
26474 shifted = PyNumber_Lshift(hi, shifter);
26475 resultobj = PyNumber_Or(shifted, lo);
26476 Py_DECREF(hi);
26477 Py_DECREF(lo);
26478 Py_DECREF(shifter);
26479 Py_DECREF(shifted);
26480 }
26481 return resultobj;
26482 fail:
26483 return NULL;
26484 }
26485
26486
26487 static int _wrap_DefaultDateTime_set(PyObject *) {
26488 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26489 return 1;
26490 }
26491
26492
26493 static PyObject *_wrap_DefaultDateTime_get(void) {
26494 PyObject *pyobj;
26495
26496 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26497 return pyobj;
26498 }
26499
26500
26501 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26502 PyObject *resultobj;
26503 wxDataFormatId arg1 ;
26504 wxDataFormat *result;
26505 PyObject * obj0 = 0 ;
26506 char *kwnames[] = {
26507 (char *) "type", NULL
26508 };
26509
26510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26511 {
26512 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26513 if (SWIG_arg_fail(1)) SWIG_fail;
26514 }
26515 {
26516 PyThreadState* __tstate = wxPyBeginAllowThreads();
26517 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26518
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26523 return resultobj;
26524 fail:
26525 return NULL;
26526 }
26527
26528
26529 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26530 PyObject *resultobj;
26531 wxString *arg1 = 0 ;
26532 wxDataFormat *result;
26533 bool temp1 = false ;
26534 PyObject * obj0 = 0 ;
26535 char *kwnames[] = {
26536 (char *) "format", NULL
26537 };
26538
26539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26540 {
26541 arg1 = wxString_in_helper(obj0);
26542 if (arg1 == NULL) SWIG_fail;
26543 temp1 = true;
26544 }
26545 {
26546 PyThreadState* __tstate = wxPyBeginAllowThreads();
26547 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26548
26549 wxPyEndAllowThreads(__tstate);
26550 if (PyErr_Occurred()) SWIG_fail;
26551 }
26552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26553 {
26554 if (temp1)
26555 delete arg1;
26556 }
26557 return resultobj;
26558 fail:
26559 {
26560 if (temp1)
26561 delete arg1;
26562 }
26563 return NULL;
26564 }
26565
26566
26567 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26568 PyObject *resultobj;
26569 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26570 PyObject * obj0 = 0 ;
26571 char *kwnames[] = {
26572 (char *) "self", NULL
26573 };
26574
26575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26577 if (SWIG_arg_fail(1)) SWIG_fail;
26578 {
26579 PyThreadState* __tstate = wxPyBeginAllowThreads();
26580 delete arg1;
26581
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 Py_INCREF(Py_None); resultobj = Py_None;
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26593 PyObject *resultobj;
26594 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26595 wxDataFormatId arg2 ;
26596 bool result;
26597 PyObject * obj0 = 0 ;
26598 PyObject * obj1 = 0 ;
26599
26600 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26602 if (SWIG_arg_fail(1)) SWIG_fail;
26603 {
26604 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26605 if (SWIG_arg_fail(2)) SWIG_fail;
26606 }
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26610
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 {
26615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26616 }
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26624 PyObject *resultobj;
26625 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26626 wxDataFormatId arg2 ;
26627 bool result;
26628 PyObject * obj0 = 0 ;
26629 PyObject * obj1 = 0 ;
26630
26631 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26633 if (SWIG_arg_fail(1)) SWIG_fail;
26634 {
26635 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26636 if (SWIG_arg_fail(2)) SWIG_fail;
26637 }
26638 {
26639 PyThreadState* __tstate = wxPyBeginAllowThreads();
26640 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26641
26642 wxPyEndAllowThreads(__tstate);
26643 if (PyErr_Occurred()) SWIG_fail;
26644 }
26645 {
26646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26647 }
26648 return resultobj;
26649 fail:
26650 return NULL;
26651 }
26652
26653
26654 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26655 PyObject *resultobj;
26656 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26657 wxDataFormat *arg2 = 0 ;
26658 bool result;
26659 PyObject * obj0 = 0 ;
26660 PyObject * obj1 = 0 ;
26661
26662 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26664 if (SWIG_arg_fail(1)) SWIG_fail;
26665 {
26666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26667 if (SWIG_arg_fail(2)) SWIG_fail;
26668 if (arg2 == NULL) {
26669 SWIG_null_ref("wxDataFormat");
26670 }
26671 if (SWIG_arg_fail(2)) SWIG_fail;
26672 }
26673 {
26674 PyThreadState* __tstate = wxPyBeginAllowThreads();
26675 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26676
26677 wxPyEndAllowThreads(__tstate);
26678 if (PyErr_Occurred()) SWIG_fail;
26679 }
26680 {
26681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26682 }
26683 return resultobj;
26684 fail:
26685 return NULL;
26686 }
26687
26688
26689 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26690 int argc;
26691 PyObject *argv[3];
26692 int ii;
26693
26694 argc = PyObject_Length(args);
26695 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26696 argv[ii] = PyTuple_GetItem(args,ii);
26697 }
26698 if (argc == 2) {
26699 int _v;
26700 {
26701 void *ptr;
26702 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26703 _v = 0;
26704 PyErr_Clear();
26705 } else {
26706 _v = 1;
26707 }
26708 }
26709 if (_v) {
26710 {
26711 void *ptr = 0;
26712 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26713 _v = 0;
26714 PyErr_Clear();
26715 } else {
26716 _v = (ptr != 0);
26717 }
26718 }
26719 if (_v) {
26720 return _wrap_DataFormat___eq____SWIG_1(self,args);
26721 }
26722 }
26723 }
26724 if (argc == 2) {
26725 int _v;
26726 {
26727 void *ptr;
26728 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26729 _v = 0;
26730 PyErr_Clear();
26731 } else {
26732 _v = 1;
26733 }
26734 }
26735 if (_v) {
26736 _v = SWIG_Check_int(argv[1]);
26737 if (_v) {
26738 return _wrap_DataFormat___eq____SWIG_0(self,args);
26739 }
26740 }
26741 }
26742
26743 Py_INCREF(Py_NotImplemented);
26744 return Py_NotImplemented;
26745 }
26746
26747
26748 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26749 PyObject *resultobj;
26750 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26751 wxDataFormat *arg2 = 0 ;
26752 bool result;
26753 PyObject * obj0 = 0 ;
26754 PyObject * obj1 = 0 ;
26755
26756 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26758 if (SWIG_arg_fail(1)) SWIG_fail;
26759 {
26760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26761 if (SWIG_arg_fail(2)) SWIG_fail;
26762 if (arg2 == NULL) {
26763 SWIG_null_ref("wxDataFormat");
26764 }
26765 if (SWIG_arg_fail(2)) SWIG_fail;
26766 }
26767 {
26768 PyThreadState* __tstate = wxPyBeginAllowThreads();
26769 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26770
26771 wxPyEndAllowThreads(__tstate);
26772 if (PyErr_Occurred()) SWIG_fail;
26773 }
26774 {
26775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26776 }
26777 return resultobj;
26778 fail:
26779 return NULL;
26780 }
26781
26782
26783 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26784 int argc;
26785 PyObject *argv[3];
26786 int ii;
26787
26788 argc = PyObject_Length(args);
26789 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26790 argv[ii] = PyTuple_GetItem(args,ii);
26791 }
26792 if (argc == 2) {
26793 int _v;
26794 {
26795 void *ptr;
26796 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26797 _v = 0;
26798 PyErr_Clear();
26799 } else {
26800 _v = 1;
26801 }
26802 }
26803 if (_v) {
26804 {
26805 void *ptr = 0;
26806 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26807 _v = 0;
26808 PyErr_Clear();
26809 } else {
26810 _v = (ptr != 0);
26811 }
26812 }
26813 if (_v) {
26814 return _wrap_DataFormat___ne____SWIG_1(self,args);
26815 }
26816 }
26817 }
26818 if (argc == 2) {
26819 int _v;
26820 {
26821 void *ptr;
26822 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26823 _v = 0;
26824 PyErr_Clear();
26825 } else {
26826 _v = 1;
26827 }
26828 }
26829 if (_v) {
26830 _v = SWIG_Check_int(argv[1]);
26831 if (_v) {
26832 return _wrap_DataFormat___ne____SWIG_0(self,args);
26833 }
26834 }
26835 }
26836
26837 Py_INCREF(Py_NotImplemented);
26838 return Py_NotImplemented;
26839 }
26840
26841
26842 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26843 PyObject *resultobj;
26844 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26845 wxDataFormatId arg2 ;
26846 PyObject * obj0 = 0 ;
26847 PyObject * obj1 = 0 ;
26848 char *kwnames[] = {
26849 (char *) "self",(char *) "format", NULL
26850 };
26851
26852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26854 if (SWIG_arg_fail(1)) SWIG_fail;
26855 {
26856 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26857 if (SWIG_arg_fail(2)) SWIG_fail;
26858 }
26859 {
26860 PyThreadState* __tstate = wxPyBeginAllowThreads();
26861 (arg1)->SetType((wxDataFormatId )arg2);
26862
26863 wxPyEndAllowThreads(__tstate);
26864 if (PyErr_Occurred()) SWIG_fail;
26865 }
26866 Py_INCREF(Py_None); resultobj = Py_None;
26867 return resultobj;
26868 fail:
26869 return NULL;
26870 }
26871
26872
26873 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26874 PyObject *resultobj;
26875 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26876 wxDataFormatId result;
26877 PyObject * obj0 = 0 ;
26878 char *kwnames[] = {
26879 (char *) "self", NULL
26880 };
26881
26882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26884 if (SWIG_arg_fail(1)) SWIG_fail;
26885 {
26886 PyThreadState* __tstate = wxPyBeginAllowThreads();
26887 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26888
26889 wxPyEndAllowThreads(__tstate);
26890 if (PyErr_Occurred()) SWIG_fail;
26891 }
26892 resultobj = SWIG_From_int((result));
26893 return resultobj;
26894 fail:
26895 return NULL;
26896 }
26897
26898
26899 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26900 PyObject *resultobj;
26901 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26902 wxString result;
26903 PyObject * obj0 = 0 ;
26904 char *kwnames[] = {
26905 (char *) "self", NULL
26906 };
26907
26908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26910 if (SWIG_arg_fail(1)) SWIG_fail;
26911 {
26912 PyThreadState* __tstate = wxPyBeginAllowThreads();
26913 result = ((wxDataFormat const *)arg1)->GetId();
26914
26915 wxPyEndAllowThreads(__tstate);
26916 if (PyErr_Occurred()) SWIG_fail;
26917 }
26918 {
26919 #if wxUSE_UNICODE
26920 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26921 #else
26922 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26923 #endif
26924 }
26925 return resultobj;
26926 fail:
26927 return NULL;
26928 }
26929
26930
26931 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26932 PyObject *resultobj;
26933 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26934 wxString *arg2 = 0 ;
26935 bool temp2 = false ;
26936 PyObject * obj0 = 0 ;
26937 PyObject * obj1 = 0 ;
26938 char *kwnames[] = {
26939 (char *) "self",(char *) "format", NULL
26940 };
26941
26942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26944 if (SWIG_arg_fail(1)) SWIG_fail;
26945 {
26946 arg2 = wxString_in_helper(obj1);
26947 if (arg2 == NULL) SWIG_fail;
26948 temp2 = true;
26949 }
26950 {
26951 PyThreadState* __tstate = wxPyBeginAllowThreads();
26952 (arg1)->SetId((wxString const &)*arg2);
26953
26954 wxPyEndAllowThreads(__tstate);
26955 if (PyErr_Occurred()) SWIG_fail;
26956 }
26957 Py_INCREF(Py_None); resultobj = Py_None;
26958 {
26959 if (temp2)
26960 delete arg2;
26961 }
26962 return resultobj;
26963 fail:
26964 {
26965 if (temp2)
26966 delete arg2;
26967 }
26968 return NULL;
26969 }
26970
26971
26972 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26973 PyObject *obj;
26974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26975 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26976 Py_INCREF(obj);
26977 return Py_BuildValue((char *)"");
26978 }
26979 static int _wrap_FormatInvalid_set(PyObject *) {
26980 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26981 return 1;
26982 }
26983
26984
26985 static PyObject *_wrap_FormatInvalid_get(void) {
26986 PyObject *pyobj;
26987
26988 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26989 return pyobj;
26990 }
26991
26992
26993 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26994 PyObject *resultobj;
26995 wxDataObject *arg1 = (wxDataObject *) 0 ;
26996 PyObject * obj0 = 0 ;
26997 char *kwnames[] = {
26998 (char *) "self", NULL
26999 };
27000
27001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27003 if (SWIG_arg_fail(1)) SWIG_fail;
27004 {
27005 PyThreadState* __tstate = wxPyBeginAllowThreads();
27006 delete arg1;
27007
27008 wxPyEndAllowThreads(__tstate);
27009 if (PyErr_Occurred()) SWIG_fail;
27010 }
27011 Py_INCREF(Py_None); resultobj = Py_None;
27012 return resultobj;
27013 fail:
27014 return NULL;
27015 }
27016
27017
27018 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27019 PyObject *resultobj;
27020 wxDataObject *arg1 = (wxDataObject *) 0 ;
27021 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27022 SwigValueWrapper<wxDataFormat > result;
27023 PyObject * obj0 = 0 ;
27024 PyObject * obj1 = 0 ;
27025 char *kwnames[] = {
27026 (char *) "self",(char *) "dir", NULL
27027 };
27028
27029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) 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 if (obj1) {
27033 {
27034 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27035 if (SWIG_arg_fail(2)) SWIG_fail;
27036 }
27037 }
27038 {
27039 PyThreadState* __tstate = wxPyBeginAllowThreads();
27040 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27041
27042 wxPyEndAllowThreads(__tstate);
27043 if (PyErr_Occurred()) SWIG_fail;
27044 }
27045 {
27046 wxDataFormat * resultptr;
27047 resultptr = new wxDataFormat((wxDataFormat &)(result));
27048 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27049 }
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj;
27058 wxDataObject *arg1 = (wxDataObject *) 0 ;
27059 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27060 size_t result;
27061 PyObject * obj0 = 0 ;
27062 PyObject * obj1 = 0 ;
27063 char *kwnames[] = {
27064 (char *) "self",(char *) "dir", NULL
27065 };
27066
27067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27069 if (SWIG_arg_fail(1)) SWIG_fail;
27070 if (obj1) {
27071 {
27072 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27073 if (SWIG_arg_fail(2)) SWIG_fail;
27074 }
27075 }
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27079
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 {
27084 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27085 }
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj;
27094 wxDataObject *arg1 = (wxDataObject *) 0 ;
27095 wxDataFormat *arg2 = 0 ;
27096 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27097 bool result;
27098 PyObject * obj0 = 0 ;
27099 PyObject * obj1 = 0 ;
27100 PyObject * obj2 = 0 ;
27101 char *kwnames[] = {
27102 (char *) "self",(char *) "format",(char *) "dir", NULL
27103 };
27104
27105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27107 if (SWIG_arg_fail(1)) SWIG_fail;
27108 {
27109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27110 if (SWIG_arg_fail(2)) SWIG_fail;
27111 if (arg2 == NULL) {
27112 SWIG_null_ref("wxDataFormat");
27113 }
27114 if (SWIG_arg_fail(2)) SWIG_fail;
27115 }
27116 if (obj2) {
27117 {
27118 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27119 if (SWIG_arg_fail(3)) SWIG_fail;
27120 }
27121 }
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27125
27126 wxPyEndAllowThreads(__tstate);
27127 if (PyErr_Occurred()) SWIG_fail;
27128 }
27129 {
27130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27131 }
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27139 PyObject *resultobj;
27140 wxDataObject *arg1 = (wxDataObject *) 0 ;
27141 wxDataFormat *arg2 = 0 ;
27142 size_t result;
27143 PyObject * obj0 = 0 ;
27144 PyObject * obj1 = 0 ;
27145 char *kwnames[] = {
27146 (char *) "self",(char *) "format", NULL
27147 };
27148
27149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27151 if (SWIG_arg_fail(1)) SWIG_fail;
27152 {
27153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27154 if (SWIG_arg_fail(2)) SWIG_fail;
27155 if (arg2 == NULL) {
27156 SWIG_null_ref("wxDataFormat");
27157 }
27158 if (SWIG_arg_fail(2)) SWIG_fail;
27159 }
27160 {
27161 PyThreadState* __tstate = wxPyBeginAllowThreads();
27162 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27163
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 {
27168 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27169 }
27170 return resultobj;
27171 fail:
27172 return NULL;
27173 }
27174
27175
27176 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27177 PyObject *resultobj;
27178 wxDataObject *arg1 = (wxDataObject *) 0 ;
27179 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27180 PyObject *result;
27181 PyObject * obj0 = 0 ;
27182 PyObject * obj1 = 0 ;
27183 char *kwnames[] = {
27184 (char *) "self",(char *) "dir", NULL
27185 };
27186
27187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27189 if (SWIG_arg_fail(1)) SWIG_fail;
27190 if (obj1) {
27191 {
27192 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27193 if (SWIG_arg_fail(2)) SWIG_fail;
27194 }
27195 }
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27199
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 resultobj = result;
27204 return resultobj;
27205 fail:
27206 return NULL;
27207 }
27208
27209
27210 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27211 PyObject *resultobj;
27212 wxDataObject *arg1 = (wxDataObject *) 0 ;
27213 wxDataFormat *arg2 = 0 ;
27214 PyObject *result;
27215 PyObject * obj0 = 0 ;
27216 PyObject * obj1 = 0 ;
27217 char *kwnames[] = {
27218 (char *) "self",(char *) "format", NULL
27219 };
27220
27221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27223 if (SWIG_arg_fail(1)) SWIG_fail;
27224 {
27225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27226 if (SWIG_arg_fail(2)) SWIG_fail;
27227 if (arg2 == NULL) {
27228 SWIG_null_ref("wxDataFormat");
27229 }
27230 if (SWIG_arg_fail(2)) SWIG_fail;
27231 }
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27235
27236 wxPyEndAllowThreads(__tstate);
27237 if (PyErr_Occurred()) SWIG_fail;
27238 }
27239 resultobj = result;
27240 return resultobj;
27241 fail:
27242 return NULL;
27243 }
27244
27245
27246 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27247 PyObject *resultobj;
27248 wxDataObject *arg1 = (wxDataObject *) 0 ;
27249 wxDataFormat *arg2 = 0 ;
27250 PyObject *arg3 = (PyObject *) 0 ;
27251 bool result;
27252 PyObject * obj0 = 0 ;
27253 PyObject * obj1 = 0 ;
27254 PyObject * obj2 = 0 ;
27255 char *kwnames[] = {
27256 (char *) "self",(char *) "format",(char *) "data", NULL
27257 };
27258
27259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27261 if (SWIG_arg_fail(1)) SWIG_fail;
27262 {
27263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27264 if (SWIG_arg_fail(2)) SWIG_fail;
27265 if (arg2 == NULL) {
27266 SWIG_null_ref("wxDataFormat");
27267 }
27268 if (SWIG_arg_fail(2)) SWIG_fail;
27269 }
27270 arg3 = obj2;
27271 {
27272 PyThreadState* __tstate = wxPyBeginAllowThreads();
27273 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27274
27275 wxPyEndAllowThreads(__tstate);
27276 if (PyErr_Occurred()) SWIG_fail;
27277 }
27278 {
27279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27280 }
27281 return resultobj;
27282 fail:
27283 return NULL;
27284 }
27285
27286
27287 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27288 PyObject *obj;
27289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27290 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27291 Py_INCREF(obj);
27292 return Py_BuildValue((char *)"");
27293 }
27294 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27295 PyObject *resultobj;
27296 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27297 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27298 wxDataObjectSimple *result;
27299 PyObject * obj0 = 0 ;
27300 char *kwnames[] = {
27301 (char *) "format", NULL
27302 };
27303
27304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27305 if (obj0) {
27306 {
27307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27308 if (SWIG_arg_fail(1)) SWIG_fail;
27309 if (arg1 == NULL) {
27310 SWIG_null_ref("wxDataFormat");
27311 }
27312 if (SWIG_arg_fail(1)) SWIG_fail;
27313 }
27314 }
27315 {
27316 PyThreadState* __tstate = wxPyBeginAllowThreads();
27317 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27318
27319 wxPyEndAllowThreads(__tstate);
27320 if (PyErr_Occurred()) SWIG_fail;
27321 }
27322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27323 return resultobj;
27324 fail:
27325 return NULL;
27326 }
27327
27328
27329 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27330 PyObject *resultobj;
27331 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27332 wxDataFormat *result;
27333 PyObject * obj0 = 0 ;
27334 char *kwnames[] = {
27335 (char *) "self", NULL
27336 };
27337
27338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27340 if (SWIG_arg_fail(1)) SWIG_fail;
27341 {
27342 PyThreadState* __tstate = wxPyBeginAllowThreads();
27343 {
27344 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27345 result = (wxDataFormat *) &_result_ref;
27346 }
27347
27348 wxPyEndAllowThreads(__tstate);
27349 if (PyErr_Occurred()) SWIG_fail;
27350 }
27351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27352 return resultobj;
27353 fail:
27354 return NULL;
27355 }
27356
27357
27358 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27359 PyObject *resultobj;
27360 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27361 wxDataFormat *arg2 = 0 ;
27362 PyObject * obj0 = 0 ;
27363 PyObject * obj1 = 0 ;
27364 char *kwnames[] = {
27365 (char *) "self",(char *) "format", NULL
27366 };
27367
27368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27370 if (SWIG_arg_fail(1)) SWIG_fail;
27371 {
27372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27373 if (SWIG_arg_fail(2)) SWIG_fail;
27374 if (arg2 == NULL) {
27375 SWIG_null_ref("wxDataFormat");
27376 }
27377 if (SWIG_arg_fail(2)) SWIG_fail;
27378 }
27379 {
27380 PyThreadState* __tstate = wxPyBeginAllowThreads();
27381 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27382
27383 wxPyEndAllowThreads(__tstate);
27384 if (PyErr_Occurred()) SWIG_fail;
27385 }
27386 Py_INCREF(Py_None); resultobj = Py_None;
27387 return resultobj;
27388 fail:
27389 return NULL;
27390 }
27391
27392
27393 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27394 PyObject *resultobj;
27395 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27396 size_t result;
27397 PyObject * obj0 = 0 ;
27398 char *kwnames[] = {
27399 (char *) "self", NULL
27400 };
27401
27402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27404 if (SWIG_arg_fail(1)) SWIG_fail;
27405 {
27406 PyThreadState* __tstate = wxPyBeginAllowThreads();
27407 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27408
27409 wxPyEndAllowThreads(__tstate);
27410 if (PyErr_Occurred()) SWIG_fail;
27411 }
27412 {
27413 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27414 }
27415 return resultobj;
27416 fail:
27417 return NULL;
27418 }
27419
27420
27421 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27422 PyObject *resultobj;
27423 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27424 PyObject *result;
27425 PyObject * obj0 = 0 ;
27426 char *kwnames[] = {
27427 (char *) "self", NULL
27428 };
27429
27430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27432 if (SWIG_arg_fail(1)) SWIG_fail;
27433 {
27434 PyThreadState* __tstate = wxPyBeginAllowThreads();
27435 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27436
27437 wxPyEndAllowThreads(__tstate);
27438 if (PyErr_Occurred()) SWIG_fail;
27439 }
27440 resultobj = result;
27441 return resultobj;
27442 fail:
27443 return NULL;
27444 }
27445
27446
27447 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27448 PyObject *resultobj;
27449 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27450 PyObject *arg2 = (PyObject *) 0 ;
27451 bool result;
27452 PyObject * obj0 = 0 ;
27453 PyObject * obj1 = 0 ;
27454 char *kwnames[] = {
27455 (char *) "self",(char *) "data", NULL
27456 };
27457
27458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27460 if (SWIG_arg_fail(1)) SWIG_fail;
27461 arg2 = obj1;
27462 {
27463 PyThreadState* __tstate = wxPyBeginAllowThreads();
27464 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27465
27466 wxPyEndAllowThreads(__tstate);
27467 if (PyErr_Occurred()) SWIG_fail;
27468 }
27469 {
27470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27471 }
27472 return resultobj;
27473 fail:
27474 return NULL;
27475 }
27476
27477
27478 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27479 PyObject *obj;
27480 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27481 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27482 Py_INCREF(obj);
27483 return Py_BuildValue((char *)"");
27484 }
27485 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj;
27487 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27488 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27489 wxPyDataObjectSimple *result;
27490 PyObject * obj0 = 0 ;
27491 char *kwnames[] = {
27492 (char *) "format", NULL
27493 };
27494
27495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27496 if (obj0) {
27497 {
27498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27499 if (SWIG_arg_fail(1)) SWIG_fail;
27500 if (arg1 == NULL) {
27501 SWIG_null_ref("wxDataFormat");
27502 }
27503 if (SWIG_arg_fail(1)) SWIG_fail;
27504 }
27505 }
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27509
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27514 return resultobj;
27515 fail:
27516 return NULL;
27517 }
27518
27519
27520 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27521 PyObject *resultobj;
27522 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27523 PyObject *arg2 = (PyObject *) 0 ;
27524 PyObject *arg3 = (PyObject *) 0 ;
27525 PyObject * obj0 = 0 ;
27526 PyObject * obj1 = 0 ;
27527 PyObject * obj2 = 0 ;
27528 char *kwnames[] = {
27529 (char *) "self",(char *) "self",(char *) "_class", NULL
27530 };
27531
27532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27534 if (SWIG_arg_fail(1)) SWIG_fail;
27535 arg2 = obj1;
27536 arg3 = obj2;
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 (arg1)->_setCallbackInfo(arg2,arg3);
27540
27541 wxPyEndAllowThreads(__tstate);
27542 if (PyErr_Occurred()) SWIG_fail;
27543 }
27544 Py_INCREF(Py_None); resultobj = Py_None;
27545 return resultobj;
27546 fail:
27547 return NULL;
27548 }
27549
27550
27551 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27552 PyObject *obj;
27553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27554 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27555 Py_INCREF(obj);
27556 return Py_BuildValue((char *)"");
27557 }
27558 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27559 PyObject *resultobj;
27560 wxDataObjectComposite *result;
27561 char *kwnames[] = {
27562 NULL
27563 };
27564
27565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27566 {
27567 PyThreadState* __tstate = wxPyBeginAllowThreads();
27568 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27569
27570 wxPyEndAllowThreads(__tstate);
27571 if (PyErr_Occurred()) SWIG_fail;
27572 }
27573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27574 return resultobj;
27575 fail:
27576 return NULL;
27577 }
27578
27579
27580 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27581 PyObject *resultobj;
27582 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27583 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27584 bool arg3 = (bool) false ;
27585 PyObject * obj0 = 0 ;
27586 PyObject * obj1 = 0 ;
27587 PyObject * obj2 = 0 ;
27588 char *kwnames[] = {
27589 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27590 };
27591
27592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27594 if (SWIG_arg_fail(1)) SWIG_fail;
27595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27596 if (SWIG_arg_fail(2)) SWIG_fail;
27597 if (obj2) {
27598 {
27599 arg3 = (bool)(SWIG_As_bool(obj2));
27600 if (SWIG_arg_fail(3)) SWIG_fail;
27601 }
27602 }
27603 {
27604 PyThreadState* __tstate = wxPyBeginAllowThreads();
27605 (arg1)->Add(arg2,arg3);
27606
27607 wxPyEndAllowThreads(__tstate);
27608 if (PyErr_Occurred()) SWIG_fail;
27609 }
27610 Py_INCREF(Py_None); resultobj = Py_None;
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27618 PyObject *obj;
27619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27620 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27621 Py_INCREF(obj);
27622 return Py_BuildValue((char *)"");
27623 }
27624 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27625 PyObject *resultobj;
27626 wxString const &arg1_defvalue = wxPyEmptyString ;
27627 wxString *arg1 = (wxString *) &arg1_defvalue ;
27628 wxTextDataObject *result;
27629 bool temp1 = false ;
27630 PyObject * obj0 = 0 ;
27631 char *kwnames[] = {
27632 (char *) "text", NULL
27633 };
27634
27635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27636 if (obj0) {
27637 {
27638 arg1 = wxString_in_helper(obj0);
27639 if (arg1 == NULL) SWIG_fail;
27640 temp1 = true;
27641 }
27642 }
27643 {
27644 PyThreadState* __tstate = wxPyBeginAllowThreads();
27645 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27646
27647 wxPyEndAllowThreads(__tstate);
27648 if (PyErr_Occurred()) SWIG_fail;
27649 }
27650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27651 {
27652 if (temp1)
27653 delete arg1;
27654 }
27655 return resultobj;
27656 fail:
27657 {
27658 if (temp1)
27659 delete arg1;
27660 }
27661 return NULL;
27662 }
27663
27664
27665 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27666 PyObject *resultobj;
27667 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27668 size_t result;
27669 PyObject * obj0 = 0 ;
27670 char *kwnames[] = {
27671 (char *) "self", NULL
27672 };
27673
27674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27676 if (SWIG_arg_fail(1)) SWIG_fail;
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 result = (size_t)(arg1)->GetTextLength();
27680
27681 wxPyEndAllowThreads(__tstate);
27682 if (PyErr_Occurred()) SWIG_fail;
27683 }
27684 {
27685 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27686 }
27687 return resultobj;
27688 fail:
27689 return NULL;
27690 }
27691
27692
27693 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27694 PyObject *resultobj;
27695 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27696 wxString result;
27697 PyObject * obj0 = 0 ;
27698 char *kwnames[] = {
27699 (char *) "self", NULL
27700 };
27701
27702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27704 if (SWIG_arg_fail(1)) SWIG_fail;
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 result = (arg1)->GetText();
27708
27709 wxPyEndAllowThreads(__tstate);
27710 if (PyErr_Occurred()) SWIG_fail;
27711 }
27712 {
27713 #if wxUSE_UNICODE
27714 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27715 #else
27716 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27717 #endif
27718 }
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj;
27727 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27728 wxString *arg2 = 0 ;
27729 bool temp2 = false ;
27730 PyObject * obj0 = 0 ;
27731 PyObject * obj1 = 0 ;
27732 char *kwnames[] = {
27733 (char *) "self",(char *) "text", NULL
27734 };
27735
27736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27738 if (SWIG_arg_fail(1)) SWIG_fail;
27739 {
27740 arg2 = wxString_in_helper(obj1);
27741 if (arg2 == NULL) SWIG_fail;
27742 temp2 = true;
27743 }
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 (arg1)->SetText((wxString const &)*arg2);
27747
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 Py_INCREF(Py_None); resultobj = Py_None;
27752 {
27753 if (temp2)
27754 delete arg2;
27755 }
27756 return resultobj;
27757 fail:
27758 {
27759 if (temp2)
27760 delete arg2;
27761 }
27762 return NULL;
27763 }
27764
27765
27766 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27767 PyObject *obj;
27768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27769 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27770 Py_INCREF(obj);
27771 return Py_BuildValue((char *)"");
27772 }
27773 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27774 PyObject *resultobj;
27775 wxString const &arg1_defvalue = wxPyEmptyString ;
27776 wxString *arg1 = (wxString *) &arg1_defvalue ;
27777 wxPyTextDataObject *result;
27778 bool temp1 = false ;
27779 PyObject * obj0 = 0 ;
27780 char *kwnames[] = {
27781 (char *) "text", NULL
27782 };
27783
27784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27785 if (obj0) {
27786 {
27787 arg1 = wxString_in_helper(obj0);
27788 if (arg1 == NULL) SWIG_fail;
27789 temp1 = true;
27790 }
27791 }
27792 {
27793 PyThreadState* __tstate = wxPyBeginAllowThreads();
27794 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27795
27796 wxPyEndAllowThreads(__tstate);
27797 if (PyErr_Occurred()) SWIG_fail;
27798 }
27799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27800 {
27801 if (temp1)
27802 delete arg1;
27803 }
27804 return resultobj;
27805 fail:
27806 {
27807 if (temp1)
27808 delete arg1;
27809 }
27810 return NULL;
27811 }
27812
27813
27814 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27815 PyObject *resultobj;
27816 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27817 PyObject *arg2 = (PyObject *) 0 ;
27818 PyObject *arg3 = (PyObject *) 0 ;
27819 PyObject * obj0 = 0 ;
27820 PyObject * obj1 = 0 ;
27821 PyObject * obj2 = 0 ;
27822 char *kwnames[] = {
27823 (char *) "self",(char *) "self",(char *) "_class", NULL
27824 };
27825
27826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27828 if (SWIG_arg_fail(1)) SWIG_fail;
27829 arg2 = obj1;
27830 arg3 = obj2;
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 (arg1)->_setCallbackInfo(arg2,arg3);
27834
27835 wxPyEndAllowThreads(__tstate);
27836 if (PyErr_Occurred()) SWIG_fail;
27837 }
27838 Py_INCREF(Py_None); resultobj = Py_None;
27839 return resultobj;
27840 fail:
27841 return NULL;
27842 }
27843
27844
27845 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27846 PyObject *obj;
27847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27848 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27849 Py_INCREF(obj);
27850 return Py_BuildValue((char *)"");
27851 }
27852 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27853 PyObject *resultobj;
27854 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27855 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27856 wxBitmapDataObject *result;
27857 PyObject * obj0 = 0 ;
27858 char *kwnames[] = {
27859 (char *) "bitmap", NULL
27860 };
27861
27862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27863 if (obj0) {
27864 {
27865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27866 if (SWIG_arg_fail(1)) SWIG_fail;
27867 if (arg1 == NULL) {
27868 SWIG_null_ref("wxBitmap");
27869 }
27870 if (SWIG_arg_fail(1)) SWIG_fail;
27871 }
27872 }
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27876
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27888 PyObject *resultobj;
27889 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27890 wxBitmap result;
27891 PyObject * obj0 = 0 ;
27892 char *kwnames[] = {
27893 (char *) "self", NULL
27894 };
27895
27896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27898 if (SWIG_arg_fail(1)) SWIG_fail;
27899 {
27900 PyThreadState* __tstate = wxPyBeginAllowThreads();
27901 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27902
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 {
27907 wxBitmap * resultptr;
27908 resultptr = new wxBitmap((wxBitmap &)(result));
27909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27910 }
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27918 PyObject *resultobj;
27919 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27920 wxBitmap *arg2 = 0 ;
27921 PyObject * obj0 = 0 ;
27922 PyObject * obj1 = 0 ;
27923 char *kwnames[] = {
27924 (char *) "self",(char *) "bitmap", NULL
27925 };
27926
27927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27929 if (SWIG_arg_fail(1)) SWIG_fail;
27930 {
27931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27932 if (SWIG_arg_fail(2)) SWIG_fail;
27933 if (arg2 == NULL) {
27934 SWIG_null_ref("wxBitmap");
27935 }
27936 if (SWIG_arg_fail(2)) SWIG_fail;
27937 }
27938 {
27939 PyThreadState* __tstate = wxPyBeginAllowThreads();
27940 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27941
27942 wxPyEndAllowThreads(__tstate);
27943 if (PyErr_Occurred()) SWIG_fail;
27944 }
27945 Py_INCREF(Py_None); resultobj = Py_None;
27946 return resultobj;
27947 fail:
27948 return NULL;
27949 }
27950
27951
27952 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27953 PyObject *obj;
27954 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27955 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27956 Py_INCREF(obj);
27957 return Py_BuildValue((char *)"");
27958 }
27959 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj;
27961 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27962 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27963 wxPyBitmapDataObject *result;
27964 PyObject * obj0 = 0 ;
27965 char *kwnames[] = {
27966 (char *) "bitmap", NULL
27967 };
27968
27969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27970 if (obj0) {
27971 {
27972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27973 if (SWIG_arg_fail(1)) SWIG_fail;
27974 if (arg1 == NULL) {
27975 SWIG_null_ref("wxBitmap");
27976 }
27977 if (SWIG_arg_fail(1)) SWIG_fail;
27978 }
27979 }
27980 {
27981 PyThreadState* __tstate = wxPyBeginAllowThreads();
27982 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27983
27984 wxPyEndAllowThreads(__tstate);
27985 if (PyErr_Occurred()) SWIG_fail;
27986 }
27987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27988 return resultobj;
27989 fail:
27990 return NULL;
27991 }
27992
27993
27994 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27995 PyObject *resultobj;
27996 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27997 PyObject *arg2 = (PyObject *) 0 ;
27998 PyObject *arg3 = (PyObject *) 0 ;
27999 PyObject * obj0 = 0 ;
28000 PyObject * obj1 = 0 ;
28001 PyObject * obj2 = 0 ;
28002 char *kwnames[] = {
28003 (char *) "self",(char *) "self",(char *) "_class", NULL
28004 };
28005
28006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28008 if (SWIG_arg_fail(1)) SWIG_fail;
28009 arg2 = obj1;
28010 arg3 = obj2;
28011 {
28012 PyThreadState* __tstate = wxPyBeginAllowThreads();
28013 (arg1)->_setCallbackInfo(arg2,arg3);
28014
28015 wxPyEndAllowThreads(__tstate);
28016 if (PyErr_Occurred()) SWIG_fail;
28017 }
28018 Py_INCREF(Py_None); resultobj = Py_None;
28019 return resultobj;
28020 fail:
28021 return NULL;
28022 }
28023
28024
28025 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28026 PyObject *obj;
28027 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28028 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28029 Py_INCREF(obj);
28030 return Py_BuildValue((char *)"");
28031 }
28032 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28033 PyObject *resultobj;
28034 wxFileDataObject *result;
28035 char *kwnames[] = {
28036 NULL
28037 };
28038
28039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28040 {
28041 PyThreadState* __tstate = wxPyBeginAllowThreads();
28042 result = (wxFileDataObject *)new wxFileDataObject();
28043
28044 wxPyEndAllowThreads(__tstate);
28045 if (PyErr_Occurred()) SWIG_fail;
28046 }
28047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28048 return resultobj;
28049 fail:
28050 return NULL;
28051 }
28052
28053
28054 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28055 PyObject *resultobj;
28056 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28057 wxArrayString *result;
28058 PyObject * obj0 = 0 ;
28059 char *kwnames[] = {
28060 (char *) "self", NULL
28061 };
28062
28063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28065 if (SWIG_arg_fail(1)) SWIG_fail;
28066 {
28067 PyThreadState* __tstate = wxPyBeginAllowThreads();
28068 {
28069 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28070 result = (wxArrayString *) &_result_ref;
28071 }
28072
28073 wxPyEndAllowThreads(__tstate);
28074 if (PyErr_Occurred()) SWIG_fail;
28075 }
28076 {
28077 resultobj = wxArrayString2PyList_helper(*result);
28078 }
28079 return resultobj;
28080 fail:
28081 return NULL;
28082 }
28083
28084
28085 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28086 PyObject *resultobj;
28087 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28088 wxString *arg2 = 0 ;
28089 bool temp2 = false ;
28090 PyObject * obj0 = 0 ;
28091 PyObject * obj1 = 0 ;
28092 char *kwnames[] = {
28093 (char *) "self",(char *) "filename", NULL
28094 };
28095
28096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28098 if (SWIG_arg_fail(1)) SWIG_fail;
28099 {
28100 arg2 = wxString_in_helper(obj1);
28101 if (arg2 == NULL) SWIG_fail;
28102 temp2 = true;
28103 }
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 (arg1)->AddFile((wxString const &)*arg2);
28107
28108 wxPyEndAllowThreads(__tstate);
28109 if (PyErr_Occurred()) SWIG_fail;
28110 }
28111 Py_INCREF(Py_None); resultobj = Py_None;
28112 {
28113 if (temp2)
28114 delete arg2;
28115 }
28116 return resultobj;
28117 fail:
28118 {
28119 if (temp2)
28120 delete arg2;
28121 }
28122 return NULL;
28123 }
28124
28125
28126 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28127 PyObject *obj;
28128 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28129 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28130 Py_INCREF(obj);
28131 return Py_BuildValue((char *)"");
28132 }
28133 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28134 PyObject *resultobj;
28135 wxDataFormat *arg1 = 0 ;
28136 wxCustomDataObject *result;
28137 PyObject * obj0 = 0 ;
28138
28139 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28140 {
28141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28142 if (SWIG_arg_fail(1)) SWIG_fail;
28143 if (arg1 == NULL) {
28144 SWIG_null_ref("wxDataFormat");
28145 }
28146 if (SWIG_arg_fail(1)) SWIG_fail;
28147 }
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28151
28152 wxPyEndAllowThreads(__tstate);
28153 if (PyErr_Occurred()) SWIG_fail;
28154 }
28155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28156 return resultobj;
28157 fail:
28158 return NULL;
28159 }
28160
28161
28162 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28163 PyObject *resultobj;
28164 wxString *arg1 = 0 ;
28165 wxCustomDataObject *result;
28166 bool temp1 = false ;
28167 PyObject * obj0 = 0 ;
28168
28169 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28170 {
28171 arg1 = wxString_in_helper(obj0);
28172 if (arg1 == NULL) SWIG_fail;
28173 temp1 = true;
28174 }
28175 {
28176 PyThreadState* __tstate = wxPyBeginAllowThreads();
28177 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28178
28179 wxPyEndAllowThreads(__tstate);
28180 if (PyErr_Occurred()) SWIG_fail;
28181 }
28182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28183 {
28184 if (temp1)
28185 delete arg1;
28186 }
28187 return resultobj;
28188 fail:
28189 {
28190 if (temp1)
28191 delete arg1;
28192 }
28193 return NULL;
28194 }
28195
28196
28197 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28198 PyObject *resultobj;
28199 wxCustomDataObject *result;
28200
28201 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28202 {
28203 PyThreadState* __tstate = wxPyBeginAllowThreads();
28204 result = (wxCustomDataObject *)new wxCustomDataObject();
28205
28206 wxPyEndAllowThreads(__tstate);
28207 if (PyErr_Occurred()) SWIG_fail;
28208 }
28209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28210 return resultobj;
28211 fail:
28212 return NULL;
28213 }
28214
28215
28216 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28217 int argc;
28218 PyObject *argv[2];
28219 int ii;
28220
28221 argc = PyObject_Length(args);
28222 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28223 argv[ii] = PyTuple_GetItem(args,ii);
28224 }
28225 if (argc == 0) {
28226 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28227 }
28228 if (argc == 1) {
28229 int _v;
28230 {
28231 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28232 }
28233 if (_v) {
28234 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28235 }
28236 }
28237 if (argc == 1) {
28238 int _v;
28239 {
28240 void *ptr = 0;
28241 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28242 _v = 0;
28243 PyErr_Clear();
28244 } else {
28245 _v = (ptr != 0);
28246 }
28247 }
28248 if (_v) {
28249 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28250 }
28251 }
28252
28253 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28254 return NULL;
28255 }
28256
28257
28258 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28259 PyObject *resultobj;
28260 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28261 PyObject *arg2 = (PyObject *) 0 ;
28262 bool result;
28263 PyObject * obj0 = 0 ;
28264 PyObject * obj1 = 0 ;
28265 char *kwnames[] = {
28266 (char *) "self",(char *) "data", NULL
28267 };
28268
28269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28271 if (SWIG_arg_fail(1)) SWIG_fail;
28272 arg2 = obj1;
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28276
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 {
28281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28282 }
28283 return resultobj;
28284 fail:
28285 return NULL;
28286 }
28287
28288
28289 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28290 PyObject *resultobj;
28291 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28292 size_t result;
28293 PyObject * obj0 = 0 ;
28294 char *kwnames[] = {
28295 (char *) "self", NULL
28296 };
28297
28298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28300 if (SWIG_arg_fail(1)) SWIG_fail;
28301 {
28302 PyThreadState* __tstate = wxPyBeginAllowThreads();
28303 result = (size_t)(arg1)->GetSize();
28304
28305 wxPyEndAllowThreads(__tstate);
28306 if (PyErr_Occurred()) SWIG_fail;
28307 }
28308 {
28309 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28310 }
28311 return resultobj;
28312 fail:
28313 return NULL;
28314 }
28315
28316
28317 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28318 PyObject *resultobj;
28319 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28320 PyObject *result;
28321 PyObject * obj0 = 0 ;
28322 char *kwnames[] = {
28323 (char *) "self", NULL
28324 };
28325
28326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28328 if (SWIG_arg_fail(1)) SWIG_fail;
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28332
28333 wxPyEndAllowThreads(__tstate);
28334 if (PyErr_Occurred()) SWIG_fail;
28335 }
28336 resultobj = result;
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28344 PyObject *obj;
28345 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28346 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28347 Py_INCREF(obj);
28348 return Py_BuildValue((char *)"");
28349 }
28350 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28351 PyObject *resultobj;
28352 wxURLDataObject *result;
28353 char *kwnames[] = {
28354 NULL
28355 };
28356
28357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (wxURLDataObject *)new wxURLDataObject();
28361
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28366 return resultobj;
28367 fail:
28368 return NULL;
28369 }
28370
28371
28372 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28373 PyObject *resultobj;
28374 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28375 wxString result;
28376 PyObject * obj0 = 0 ;
28377 char *kwnames[] = {
28378 (char *) "self", NULL
28379 };
28380
28381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28383 if (SWIG_arg_fail(1)) SWIG_fail;
28384 {
28385 PyThreadState* __tstate = wxPyBeginAllowThreads();
28386 result = (arg1)->GetURL();
28387
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 {
28392 #if wxUSE_UNICODE
28393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28394 #else
28395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28396 #endif
28397 }
28398 return resultobj;
28399 fail:
28400 return NULL;
28401 }
28402
28403
28404 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28405 PyObject *resultobj;
28406 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28407 wxString *arg2 = 0 ;
28408 bool temp2 = false ;
28409 PyObject * obj0 = 0 ;
28410 PyObject * obj1 = 0 ;
28411 char *kwnames[] = {
28412 (char *) "self",(char *) "url", NULL
28413 };
28414
28415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28417 if (SWIG_arg_fail(1)) SWIG_fail;
28418 {
28419 arg2 = wxString_in_helper(obj1);
28420 if (arg2 == NULL) SWIG_fail;
28421 temp2 = true;
28422 }
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 (arg1)->SetURL((wxString const &)*arg2);
28426
28427 wxPyEndAllowThreads(__tstate);
28428 if (PyErr_Occurred()) SWIG_fail;
28429 }
28430 Py_INCREF(Py_None); resultobj = Py_None;
28431 {
28432 if (temp2)
28433 delete arg2;
28434 }
28435 return resultobj;
28436 fail:
28437 {
28438 if (temp2)
28439 delete arg2;
28440 }
28441 return NULL;
28442 }
28443
28444
28445 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28446 PyObject *obj;
28447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28448 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28449 Py_INCREF(obj);
28450 return Py_BuildValue((char *)"");
28451 }
28452 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28453 PyObject *resultobj;
28454 wxMetafileDataObject *result;
28455 char *kwnames[] = {
28456 NULL
28457 };
28458
28459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28463
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28475 PyObject *resultobj;
28476 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28477 wxMetafile *arg2 = 0 ;
28478 PyObject * obj0 = 0 ;
28479 PyObject * obj1 = 0 ;
28480 char *kwnames[] = {
28481 (char *) "self",(char *) "metafile", NULL
28482 };
28483
28484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28486 if (SWIG_arg_fail(1)) SWIG_fail;
28487 {
28488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28489 if (SWIG_arg_fail(2)) SWIG_fail;
28490 if (arg2 == NULL) {
28491 SWIG_null_ref("wxMetafile");
28492 }
28493 if (SWIG_arg_fail(2)) SWIG_fail;
28494 }
28495 {
28496 PyThreadState* __tstate = wxPyBeginAllowThreads();
28497 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28498
28499 wxPyEndAllowThreads(__tstate);
28500 if (PyErr_Occurred()) SWIG_fail;
28501 }
28502 Py_INCREF(Py_None); resultobj = Py_None;
28503 return resultobj;
28504 fail:
28505 return NULL;
28506 }
28507
28508
28509 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28510 PyObject *resultobj;
28511 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28512 wxMetafile result;
28513 PyObject * obj0 = 0 ;
28514 char *kwnames[] = {
28515 (char *) "self", NULL
28516 };
28517
28518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28520 if (SWIG_arg_fail(1)) SWIG_fail;
28521 {
28522 PyThreadState* __tstate = wxPyBeginAllowThreads();
28523 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28524
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 {
28529 wxMetafile * resultptr;
28530 resultptr = new wxMetafile((wxMetafile &)(result));
28531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28532 }
28533 return resultobj;
28534 fail:
28535 return NULL;
28536 }
28537
28538
28539 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28540 PyObject *obj;
28541 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28542 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28543 Py_INCREF(obj);
28544 return Py_BuildValue((char *)"");
28545 }
28546 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj;
28548 wxDragResult arg1 ;
28549 bool result;
28550 PyObject * obj0 = 0 ;
28551 char *kwnames[] = {
28552 (char *) "res", NULL
28553 };
28554
28555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28556 {
28557 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28558 if (SWIG_arg_fail(1)) SWIG_fail;
28559 }
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28563
28564 wxPyEndAllowThreads(__tstate);
28565 if (PyErr_Occurred()) SWIG_fail;
28566 }
28567 {
28568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28569 }
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28577 PyObject *resultobj;
28578 wxWindow *arg1 = (wxWindow *) 0 ;
28579 wxCursor const &arg2_defvalue = wxNullCursor ;
28580 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28581 wxCursor const &arg3_defvalue = wxNullCursor ;
28582 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28583 wxCursor const &arg4_defvalue = wxNullCursor ;
28584 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28585 wxPyDropSource *result;
28586 PyObject * obj0 = 0 ;
28587 PyObject * obj1 = 0 ;
28588 PyObject * obj2 = 0 ;
28589 PyObject * obj3 = 0 ;
28590 char *kwnames[] = {
28591 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28592 };
28593
28594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28596 if (SWIG_arg_fail(1)) SWIG_fail;
28597 if (obj1) {
28598 {
28599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28600 if (SWIG_arg_fail(2)) SWIG_fail;
28601 if (arg2 == NULL) {
28602 SWIG_null_ref("wxCursor");
28603 }
28604 if (SWIG_arg_fail(2)) SWIG_fail;
28605 }
28606 }
28607 if (obj2) {
28608 {
28609 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28610 if (SWIG_arg_fail(3)) SWIG_fail;
28611 if (arg3 == NULL) {
28612 SWIG_null_ref("wxCursor");
28613 }
28614 if (SWIG_arg_fail(3)) SWIG_fail;
28615 }
28616 }
28617 if (obj3) {
28618 {
28619 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28620 if (SWIG_arg_fail(4)) SWIG_fail;
28621 if (arg4 == NULL) {
28622 SWIG_null_ref("wxCursor");
28623 }
28624 if (SWIG_arg_fail(4)) SWIG_fail;
28625 }
28626 }
28627 {
28628 PyThreadState* __tstate = wxPyBeginAllowThreads();
28629 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28630
28631 wxPyEndAllowThreads(__tstate);
28632 if (PyErr_Occurred()) SWIG_fail;
28633 }
28634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28635 return resultobj;
28636 fail:
28637 return NULL;
28638 }
28639
28640
28641 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28642 PyObject *resultobj;
28643 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28644 PyObject *arg2 = (PyObject *) 0 ;
28645 PyObject *arg3 = (PyObject *) 0 ;
28646 int arg4 ;
28647 PyObject * obj0 = 0 ;
28648 PyObject * obj1 = 0 ;
28649 PyObject * obj2 = 0 ;
28650 PyObject * obj3 = 0 ;
28651 char *kwnames[] = {
28652 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28653 };
28654
28655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28657 if (SWIG_arg_fail(1)) SWIG_fail;
28658 arg2 = obj1;
28659 arg3 = obj2;
28660 {
28661 arg4 = (int)(SWIG_As_int(obj3));
28662 if (SWIG_arg_fail(4)) SWIG_fail;
28663 }
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28667
28668 wxPyEndAllowThreads(__tstate);
28669 if (PyErr_Occurred()) SWIG_fail;
28670 }
28671 Py_INCREF(Py_None); resultobj = Py_None;
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj;
28680 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28681 PyObject * obj0 = 0 ;
28682 char *kwnames[] = {
28683 (char *) "self", NULL
28684 };
28685
28686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28688 if (SWIG_arg_fail(1)) SWIG_fail;
28689 {
28690 PyThreadState* __tstate = wxPyBeginAllowThreads();
28691 delete arg1;
28692
28693 wxPyEndAllowThreads(__tstate);
28694 if (PyErr_Occurred()) SWIG_fail;
28695 }
28696 Py_INCREF(Py_None); resultobj = Py_None;
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj;
28705 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28706 wxDataObject *arg2 = 0 ;
28707 PyObject * obj0 = 0 ;
28708 PyObject * obj1 = 0 ;
28709 char *kwnames[] = {
28710 (char *) "self",(char *) "data", NULL
28711 };
28712
28713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28715 if (SWIG_arg_fail(1)) SWIG_fail;
28716 {
28717 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28718 if (SWIG_arg_fail(2)) SWIG_fail;
28719 if (arg2 == NULL) {
28720 SWIG_null_ref("wxDataObject");
28721 }
28722 if (SWIG_arg_fail(2)) SWIG_fail;
28723 }
28724 {
28725 PyThreadState* __tstate = wxPyBeginAllowThreads();
28726 (arg1)->SetData(*arg2);
28727
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 Py_INCREF(Py_None); resultobj = Py_None;
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28739 PyObject *resultobj;
28740 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28741 wxDataObject *result;
28742 PyObject * obj0 = 0 ;
28743 char *kwnames[] = {
28744 (char *) "self", NULL
28745 };
28746
28747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28749 if (SWIG_arg_fail(1)) SWIG_fail;
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (wxDataObject *)(arg1)->GetDataObject();
28753
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28765 PyObject *resultobj;
28766 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28767 wxDragResult arg2 ;
28768 wxCursor *arg3 = 0 ;
28769 PyObject * obj0 = 0 ;
28770 PyObject * obj1 = 0 ;
28771 PyObject * obj2 = 0 ;
28772 char *kwnames[] = {
28773 (char *) "self",(char *) "res",(char *) "cursor", NULL
28774 };
28775
28776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28778 if (SWIG_arg_fail(1)) SWIG_fail;
28779 {
28780 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28781 if (SWIG_arg_fail(2)) SWIG_fail;
28782 }
28783 {
28784 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28785 if (SWIG_arg_fail(3)) SWIG_fail;
28786 if (arg3 == NULL) {
28787 SWIG_null_ref("wxCursor");
28788 }
28789 if (SWIG_arg_fail(3)) SWIG_fail;
28790 }
28791 {
28792 PyThreadState* __tstate = wxPyBeginAllowThreads();
28793 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28794
28795 wxPyEndAllowThreads(__tstate);
28796 if (PyErr_Occurred()) SWIG_fail;
28797 }
28798 Py_INCREF(Py_None); resultobj = Py_None;
28799 return resultobj;
28800 fail:
28801 return NULL;
28802 }
28803
28804
28805 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28806 PyObject *resultobj;
28807 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28808 int arg2 = (int) wxDrag_CopyOnly ;
28809 wxDragResult result;
28810 PyObject * obj0 = 0 ;
28811 PyObject * obj1 = 0 ;
28812 char *kwnames[] = {
28813 (char *) "self",(char *) "flags", NULL
28814 };
28815
28816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28818 if (SWIG_arg_fail(1)) SWIG_fail;
28819 if (obj1) {
28820 {
28821 arg2 = (int)(SWIG_As_int(obj1));
28822 if (SWIG_arg_fail(2)) SWIG_fail;
28823 }
28824 }
28825 {
28826 PyThreadState* __tstate = wxPyBeginAllowThreads();
28827 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28828
28829 wxPyEndAllowThreads(__tstate);
28830 if (PyErr_Occurred()) SWIG_fail;
28831 }
28832 resultobj = SWIG_From_int((result));
28833 return resultobj;
28834 fail:
28835 return NULL;
28836 }
28837
28838
28839 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28840 PyObject *resultobj;
28841 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28842 wxDragResult arg2 ;
28843 bool result;
28844 PyObject * obj0 = 0 ;
28845 PyObject * obj1 = 0 ;
28846 char *kwnames[] = {
28847 (char *) "self",(char *) "effect", NULL
28848 };
28849
28850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28852 if (SWIG_arg_fail(1)) SWIG_fail;
28853 {
28854 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28855 if (SWIG_arg_fail(2)) SWIG_fail;
28856 }
28857 {
28858 PyThreadState* __tstate = wxPyBeginAllowThreads();
28859 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28860
28861 wxPyEndAllowThreads(__tstate);
28862 if (PyErr_Occurred()) SWIG_fail;
28863 }
28864 {
28865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28866 }
28867 return resultobj;
28868 fail:
28869 return NULL;
28870 }
28871
28872
28873 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28874 PyObject *obj;
28875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28876 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28877 Py_INCREF(obj);
28878 return Py_BuildValue((char *)"");
28879 }
28880 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28881 PyObject *resultobj;
28882 wxDataObject *arg1 = (wxDataObject *) NULL ;
28883 wxPyDropTarget *result;
28884 PyObject * obj0 = 0 ;
28885 char *kwnames[] = {
28886 (char *) "dataObject", NULL
28887 };
28888
28889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28890 if (obj0) {
28891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28892 if (SWIG_arg_fail(1)) SWIG_fail;
28893 }
28894 {
28895 PyThreadState* __tstate = wxPyBeginAllowThreads();
28896 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28897
28898 wxPyEndAllowThreads(__tstate);
28899 if (PyErr_Occurred()) SWIG_fail;
28900 }
28901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28902 return resultobj;
28903 fail:
28904 return NULL;
28905 }
28906
28907
28908 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28909 PyObject *resultobj;
28910 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28911 PyObject *arg2 = (PyObject *) 0 ;
28912 PyObject *arg3 = (PyObject *) 0 ;
28913 PyObject * obj0 = 0 ;
28914 PyObject * obj1 = 0 ;
28915 PyObject * obj2 = 0 ;
28916 char *kwnames[] = {
28917 (char *) "self",(char *) "self",(char *) "_class", NULL
28918 };
28919
28920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28922 if (SWIG_arg_fail(1)) SWIG_fail;
28923 arg2 = obj1;
28924 arg3 = obj2;
28925 {
28926 PyThreadState* __tstate = wxPyBeginAllowThreads();
28927 (arg1)->_setCallbackInfo(arg2,arg3);
28928
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 Py_INCREF(Py_None); resultobj = Py_None;
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28940 PyObject *resultobj;
28941 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28942 PyObject * obj0 = 0 ;
28943 char *kwnames[] = {
28944 (char *) "self", NULL
28945 };
28946
28947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28949 if (SWIG_arg_fail(1)) SWIG_fail;
28950 {
28951 PyThreadState* __tstate = wxPyBeginAllowThreads();
28952 delete arg1;
28953
28954 wxPyEndAllowThreads(__tstate);
28955 if (PyErr_Occurred()) SWIG_fail;
28956 }
28957 Py_INCREF(Py_None); resultobj = Py_None;
28958 return resultobj;
28959 fail:
28960 return NULL;
28961 }
28962
28963
28964 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28965 PyObject *resultobj;
28966 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28967 wxDataObject *result;
28968 PyObject * obj0 = 0 ;
28969 char *kwnames[] = {
28970 (char *) "self", NULL
28971 };
28972
28973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28975 if (SWIG_arg_fail(1)) SWIG_fail;
28976 {
28977 PyThreadState* __tstate = wxPyBeginAllowThreads();
28978 result = (wxDataObject *)(arg1)->GetDataObject();
28979
28980 wxPyEndAllowThreads(__tstate);
28981 if (PyErr_Occurred()) SWIG_fail;
28982 }
28983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28984 return resultobj;
28985 fail:
28986 return NULL;
28987 }
28988
28989
28990 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28991 PyObject *resultobj;
28992 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28993 wxDataObject *arg2 = (wxDataObject *) 0 ;
28994 PyObject * obj0 = 0 ;
28995 PyObject * obj1 = 0 ;
28996 char *kwnames[] = {
28997 (char *) "self",(char *) "dataObject", NULL
28998 };
28999
29000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29002 if (SWIG_arg_fail(1)) SWIG_fail;
29003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29004 if (SWIG_arg_fail(2)) SWIG_fail;
29005 {
29006 PyThreadState* __tstate = wxPyBeginAllowThreads();
29007 (arg1)->SetDataObject(arg2);
29008
29009 wxPyEndAllowThreads(__tstate);
29010 if (PyErr_Occurred()) SWIG_fail;
29011 }
29012 Py_INCREF(Py_None); resultobj = Py_None;
29013 return resultobj;
29014 fail:
29015 return NULL;
29016 }
29017
29018
29019 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29020 PyObject *resultobj;
29021 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29022 int arg2 ;
29023 int arg3 ;
29024 wxDragResult arg4 ;
29025 wxDragResult result;
29026 PyObject * obj0 = 0 ;
29027 PyObject * obj1 = 0 ;
29028 PyObject * obj2 = 0 ;
29029 PyObject * obj3 = 0 ;
29030 char *kwnames[] = {
29031 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29032 };
29033
29034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29036 if (SWIG_arg_fail(1)) SWIG_fail;
29037 {
29038 arg2 = (int)(SWIG_As_int(obj1));
29039 if (SWIG_arg_fail(2)) SWIG_fail;
29040 }
29041 {
29042 arg3 = (int)(SWIG_As_int(obj2));
29043 if (SWIG_arg_fail(3)) SWIG_fail;
29044 }
29045 {
29046 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29047 if (SWIG_arg_fail(4)) SWIG_fail;
29048 }
29049 {
29050 PyThreadState* __tstate = wxPyBeginAllowThreads();
29051 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29052
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 resultobj = SWIG_From_int((result));
29057 return resultobj;
29058 fail:
29059 return NULL;
29060 }
29061
29062
29063 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29064 PyObject *resultobj;
29065 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29066 int arg2 ;
29067 int arg3 ;
29068 wxDragResult arg4 ;
29069 wxDragResult result;
29070 PyObject * obj0 = 0 ;
29071 PyObject * obj1 = 0 ;
29072 PyObject * obj2 = 0 ;
29073 PyObject * obj3 = 0 ;
29074 char *kwnames[] = {
29075 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29076 };
29077
29078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29080 if (SWIG_arg_fail(1)) SWIG_fail;
29081 {
29082 arg2 = (int)(SWIG_As_int(obj1));
29083 if (SWIG_arg_fail(2)) SWIG_fail;
29084 }
29085 {
29086 arg3 = (int)(SWIG_As_int(obj2));
29087 if (SWIG_arg_fail(3)) SWIG_fail;
29088 }
29089 {
29090 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29091 if (SWIG_arg_fail(4)) SWIG_fail;
29092 }
29093 {
29094 PyThreadState* __tstate = wxPyBeginAllowThreads();
29095 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29096
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 resultobj = SWIG_From_int((result));
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29108 PyObject *resultobj;
29109 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29110 PyObject * obj0 = 0 ;
29111 char *kwnames[] = {
29112 (char *) "self", NULL
29113 };
29114
29115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29117 if (SWIG_arg_fail(1)) SWIG_fail;
29118 {
29119 PyThreadState* __tstate = wxPyBeginAllowThreads();
29120 (arg1)->base_OnLeave();
29121
29122 wxPyEndAllowThreads(__tstate);
29123 if (PyErr_Occurred()) SWIG_fail;
29124 }
29125 Py_INCREF(Py_None); resultobj = Py_None;
29126 return resultobj;
29127 fail:
29128 return NULL;
29129 }
29130
29131
29132 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29133 PyObject *resultobj;
29134 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29135 int arg2 ;
29136 int arg3 ;
29137 bool result;
29138 PyObject * obj0 = 0 ;
29139 PyObject * obj1 = 0 ;
29140 PyObject * obj2 = 0 ;
29141 char *kwnames[] = {
29142 (char *) "self",(char *) "x",(char *) "y", NULL
29143 };
29144
29145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29147 if (SWIG_arg_fail(1)) SWIG_fail;
29148 {
29149 arg2 = (int)(SWIG_As_int(obj1));
29150 if (SWIG_arg_fail(2)) SWIG_fail;
29151 }
29152 {
29153 arg3 = (int)(SWIG_As_int(obj2));
29154 if (SWIG_arg_fail(3)) SWIG_fail;
29155 }
29156 {
29157 PyThreadState* __tstate = wxPyBeginAllowThreads();
29158 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29159
29160 wxPyEndAllowThreads(__tstate);
29161 if (PyErr_Occurred()) SWIG_fail;
29162 }
29163 {
29164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29165 }
29166 return resultobj;
29167 fail:
29168 return NULL;
29169 }
29170
29171
29172 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29173 PyObject *resultobj;
29174 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29175 bool result;
29176 PyObject * obj0 = 0 ;
29177 char *kwnames[] = {
29178 (char *) "self", NULL
29179 };
29180
29181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29183 if (SWIG_arg_fail(1)) SWIG_fail;
29184 {
29185 PyThreadState* __tstate = wxPyBeginAllowThreads();
29186 result = (bool)(arg1)->GetData();
29187
29188 wxPyEndAllowThreads(__tstate);
29189 if (PyErr_Occurred()) SWIG_fail;
29190 }
29191 {
29192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29193 }
29194 return resultobj;
29195 fail:
29196 return NULL;
29197 }
29198
29199
29200 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29201 PyObject *resultobj;
29202 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29203 wxDragResult arg2 ;
29204 PyObject * obj0 = 0 ;
29205 PyObject * obj1 = 0 ;
29206 char *kwnames[] = {
29207 (char *) "self",(char *) "action", NULL
29208 };
29209
29210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29212 if (SWIG_arg_fail(1)) SWIG_fail;
29213 {
29214 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29215 if (SWIG_arg_fail(2)) SWIG_fail;
29216 }
29217 {
29218 PyThreadState* __tstate = wxPyBeginAllowThreads();
29219 (arg1)->SetDefaultAction((wxDragResult )arg2);
29220
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 Py_INCREF(Py_None); resultobj = Py_None;
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29232 PyObject *resultobj;
29233 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29234 wxDragResult result;
29235 PyObject * obj0 = 0 ;
29236 char *kwnames[] = {
29237 (char *) "self", NULL
29238 };
29239
29240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29242 if (SWIG_arg_fail(1)) SWIG_fail;
29243 {
29244 PyThreadState* __tstate = wxPyBeginAllowThreads();
29245 result = (wxDragResult)(arg1)->GetDefaultAction();
29246
29247 wxPyEndAllowThreads(__tstate);
29248 if (PyErr_Occurred()) SWIG_fail;
29249 }
29250 resultobj = SWIG_From_int((result));
29251 return resultobj;
29252 fail:
29253 return NULL;
29254 }
29255
29256
29257 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29258 PyObject *obj;
29259 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29260 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29261 Py_INCREF(obj);
29262 return Py_BuildValue((char *)"");
29263 }
29264 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29265 PyObject *resultobj;
29266 wxPyTextDropTarget *result;
29267 char *kwnames[] = {
29268 NULL
29269 };
29270
29271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29272 {
29273 PyThreadState* __tstate = wxPyBeginAllowThreads();
29274 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29275
29276 wxPyEndAllowThreads(__tstate);
29277 if (PyErr_Occurred()) SWIG_fail;
29278 }
29279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29287 PyObject *resultobj;
29288 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29289 PyObject *arg2 = (PyObject *) 0 ;
29290 PyObject *arg3 = (PyObject *) 0 ;
29291 PyObject * obj0 = 0 ;
29292 PyObject * obj1 = 0 ;
29293 PyObject * obj2 = 0 ;
29294 char *kwnames[] = {
29295 (char *) "self",(char *) "self",(char *) "_class", NULL
29296 };
29297
29298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29300 if (SWIG_arg_fail(1)) SWIG_fail;
29301 arg2 = obj1;
29302 arg3 = obj2;
29303 {
29304 PyThreadState* __tstate = wxPyBeginAllowThreads();
29305 (arg1)->_setCallbackInfo(arg2,arg3);
29306
29307 wxPyEndAllowThreads(__tstate);
29308 if (PyErr_Occurred()) SWIG_fail;
29309 }
29310 Py_INCREF(Py_None); resultobj = Py_None;
29311 return resultobj;
29312 fail:
29313 return NULL;
29314 }
29315
29316
29317 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29318 PyObject *resultobj;
29319 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29320 int arg2 ;
29321 int arg3 ;
29322 wxDragResult arg4 ;
29323 wxDragResult result;
29324 PyObject * obj0 = 0 ;
29325 PyObject * obj1 = 0 ;
29326 PyObject * obj2 = 0 ;
29327 PyObject * obj3 = 0 ;
29328 char *kwnames[] = {
29329 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29330 };
29331
29332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29334 if (SWIG_arg_fail(1)) SWIG_fail;
29335 {
29336 arg2 = (int)(SWIG_As_int(obj1));
29337 if (SWIG_arg_fail(2)) SWIG_fail;
29338 }
29339 {
29340 arg3 = (int)(SWIG_As_int(obj2));
29341 if (SWIG_arg_fail(3)) SWIG_fail;
29342 }
29343 {
29344 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29345 if (SWIG_arg_fail(4)) SWIG_fail;
29346 }
29347 {
29348 PyThreadState* __tstate = wxPyBeginAllowThreads();
29349 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29350
29351 wxPyEndAllowThreads(__tstate);
29352 if (PyErr_Occurred()) SWIG_fail;
29353 }
29354 resultobj = SWIG_From_int((result));
29355 return resultobj;
29356 fail:
29357 return NULL;
29358 }
29359
29360
29361 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29362 PyObject *resultobj;
29363 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29364 int arg2 ;
29365 int arg3 ;
29366 wxDragResult arg4 ;
29367 wxDragResult result;
29368 PyObject * obj0 = 0 ;
29369 PyObject * obj1 = 0 ;
29370 PyObject * obj2 = 0 ;
29371 PyObject * obj3 = 0 ;
29372 char *kwnames[] = {
29373 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29374 };
29375
29376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29378 if (SWIG_arg_fail(1)) SWIG_fail;
29379 {
29380 arg2 = (int)(SWIG_As_int(obj1));
29381 if (SWIG_arg_fail(2)) SWIG_fail;
29382 }
29383 {
29384 arg3 = (int)(SWIG_As_int(obj2));
29385 if (SWIG_arg_fail(3)) SWIG_fail;
29386 }
29387 {
29388 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29389 if (SWIG_arg_fail(4)) SWIG_fail;
29390 }
29391 {
29392 PyThreadState* __tstate = wxPyBeginAllowThreads();
29393 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29394
29395 wxPyEndAllowThreads(__tstate);
29396 if (PyErr_Occurred()) SWIG_fail;
29397 }
29398 resultobj = SWIG_From_int((result));
29399 return resultobj;
29400 fail:
29401 return NULL;
29402 }
29403
29404
29405 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29406 PyObject *resultobj;
29407 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29408 PyObject * obj0 = 0 ;
29409 char *kwnames[] = {
29410 (char *) "self", NULL
29411 };
29412
29413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29415 if (SWIG_arg_fail(1)) SWIG_fail;
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 (arg1)->base_OnLeave();
29419
29420 wxPyEndAllowThreads(__tstate);
29421 if (PyErr_Occurred()) SWIG_fail;
29422 }
29423 Py_INCREF(Py_None); resultobj = Py_None;
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29431 PyObject *resultobj;
29432 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29433 int arg2 ;
29434 int arg3 ;
29435 bool result;
29436 PyObject * obj0 = 0 ;
29437 PyObject * obj1 = 0 ;
29438 PyObject * obj2 = 0 ;
29439 char *kwnames[] = {
29440 (char *) "self",(char *) "x",(char *) "y", NULL
29441 };
29442
29443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29445 if (SWIG_arg_fail(1)) SWIG_fail;
29446 {
29447 arg2 = (int)(SWIG_As_int(obj1));
29448 if (SWIG_arg_fail(2)) SWIG_fail;
29449 }
29450 {
29451 arg3 = (int)(SWIG_As_int(obj2));
29452 if (SWIG_arg_fail(3)) SWIG_fail;
29453 }
29454 {
29455 PyThreadState* __tstate = wxPyBeginAllowThreads();
29456 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29457
29458 wxPyEndAllowThreads(__tstate);
29459 if (PyErr_Occurred()) SWIG_fail;
29460 }
29461 {
29462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29463 }
29464 return resultobj;
29465 fail:
29466 return NULL;
29467 }
29468
29469
29470 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29471 PyObject *resultobj;
29472 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29473 int arg2 ;
29474 int arg3 ;
29475 wxDragResult arg4 ;
29476 wxDragResult result;
29477 PyObject * obj0 = 0 ;
29478 PyObject * obj1 = 0 ;
29479 PyObject * obj2 = 0 ;
29480 PyObject * obj3 = 0 ;
29481 char *kwnames[] = {
29482 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29483 };
29484
29485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29487 if (SWIG_arg_fail(1)) SWIG_fail;
29488 {
29489 arg2 = (int)(SWIG_As_int(obj1));
29490 if (SWIG_arg_fail(2)) SWIG_fail;
29491 }
29492 {
29493 arg3 = (int)(SWIG_As_int(obj2));
29494 if (SWIG_arg_fail(3)) SWIG_fail;
29495 }
29496 {
29497 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29498 if (SWIG_arg_fail(4)) SWIG_fail;
29499 }
29500 {
29501 PyThreadState* __tstate = wxPyBeginAllowThreads();
29502 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29503
29504 wxPyEndAllowThreads(__tstate);
29505 if (PyErr_Occurred()) SWIG_fail;
29506 }
29507 resultobj = SWIG_From_int((result));
29508 return resultobj;
29509 fail:
29510 return NULL;
29511 }
29512
29513
29514 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29515 PyObject *obj;
29516 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29517 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29518 Py_INCREF(obj);
29519 return Py_BuildValue((char *)"");
29520 }
29521 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29522 PyObject *resultobj;
29523 wxPyFileDropTarget *result;
29524 char *kwnames[] = {
29525 NULL
29526 };
29527
29528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29529 {
29530 PyThreadState* __tstate = wxPyBeginAllowThreads();
29531 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29532
29533 wxPyEndAllowThreads(__tstate);
29534 if (PyErr_Occurred()) SWIG_fail;
29535 }
29536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29537 return resultobj;
29538 fail:
29539 return NULL;
29540 }
29541
29542
29543 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29544 PyObject *resultobj;
29545 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29546 PyObject *arg2 = (PyObject *) 0 ;
29547 PyObject *arg3 = (PyObject *) 0 ;
29548 PyObject * obj0 = 0 ;
29549 PyObject * obj1 = 0 ;
29550 PyObject * obj2 = 0 ;
29551 char *kwnames[] = {
29552 (char *) "self",(char *) "self",(char *) "_class", NULL
29553 };
29554
29555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29557 if (SWIG_arg_fail(1)) SWIG_fail;
29558 arg2 = obj1;
29559 arg3 = obj2;
29560 {
29561 PyThreadState* __tstate = wxPyBeginAllowThreads();
29562 (arg1)->_setCallbackInfo(arg2,arg3);
29563
29564 wxPyEndAllowThreads(__tstate);
29565 if (PyErr_Occurred()) SWIG_fail;
29566 }
29567 Py_INCREF(Py_None); resultobj = Py_None;
29568 return resultobj;
29569 fail:
29570 return NULL;
29571 }
29572
29573
29574 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29575 PyObject *resultobj;
29576 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29577 int arg2 ;
29578 int arg3 ;
29579 wxDragResult arg4 ;
29580 wxDragResult result;
29581 PyObject * obj0 = 0 ;
29582 PyObject * obj1 = 0 ;
29583 PyObject * obj2 = 0 ;
29584 PyObject * obj3 = 0 ;
29585 char *kwnames[] = {
29586 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29587 };
29588
29589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29591 if (SWIG_arg_fail(1)) SWIG_fail;
29592 {
29593 arg2 = (int)(SWIG_As_int(obj1));
29594 if (SWIG_arg_fail(2)) SWIG_fail;
29595 }
29596 {
29597 arg3 = (int)(SWIG_As_int(obj2));
29598 if (SWIG_arg_fail(3)) SWIG_fail;
29599 }
29600 {
29601 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29602 if (SWIG_arg_fail(4)) SWIG_fail;
29603 }
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29607
29608 wxPyEndAllowThreads(__tstate);
29609 if (PyErr_Occurred()) SWIG_fail;
29610 }
29611 resultobj = SWIG_From_int((result));
29612 return resultobj;
29613 fail:
29614 return NULL;
29615 }
29616
29617
29618 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29619 PyObject *resultobj;
29620 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29621 int arg2 ;
29622 int arg3 ;
29623 wxDragResult arg4 ;
29624 wxDragResult result;
29625 PyObject * obj0 = 0 ;
29626 PyObject * obj1 = 0 ;
29627 PyObject * obj2 = 0 ;
29628 PyObject * obj3 = 0 ;
29629 char *kwnames[] = {
29630 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29631 };
29632
29633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29635 if (SWIG_arg_fail(1)) SWIG_fail;
29636 {
29637 arg2 = (int)(SWIG_As_int(obj1));
29638 if (SWIG_arg_fail(2)) SWIG_fail;
29639 }
29640 {
29641 arg3 = (int)(SWIG_As_int(obj2));
29642 if (SWIG_arg_fail(3)) SWIG_fail;
29643 }
29644 {
29645 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29646 if (SWIG_arg_fail(4)) SWIG_fail;
29647 }
29648 {
29649 PyThreadState* __tstate = wxPyBeginAllowThreads();
29650 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29651
29652 wxPyEndAllowThreads(__tstate);
29653 if (PyErr_Occurred()) SWIG_fail;
29654 }
29655 resultobj = SWIG_From_int((result));
29656 return resultobj;
29657 fail:
29658 return NULL;
29659 }
29660
29661
29662 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29663 PyObject *resultobj;
29664 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29665 PyObject * obj0 = 0 ;
29666 char *kwnames[] = {
29667 (char *) "self", NULL
29668 };
29669
29670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29672 if (SWIG_arg_fail(1)) SWIG_fail;
29673 {
29674 PyThreadState* __tstate = wxPyBeginAllowThreads();
29675 (arg1)->base_OnLeave();
29676
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 Py_INCREF(Py_None); resultobj = Py_None;
29681 return resultobj;
29682 fail:
29683 return NULL;
29684 }
29685
29686
29687 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29688 PyObject *resultobj;
29689 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29690 int arg2 ;
29691 int arg3 ;
29692 bool result;
29693 PyObject * obj0 = 0 ;
29694 PyObject * obj1 = 0 ;
29695 PyObject * obj2 = 0 ;
29696 char *kwnames[] = {
29697 (char *) "self",(char *) "x",(char *) "y", NULL
29698 };
29699
29700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29702 if (SWIG_arg_fail(1)) SWIG_fail;
29703 {
29704 arg2 = (int)(SWIG_As_int(obj1));
29705 if (SWIG_arg_fail(2)) SWIG_fail;
29706 }
29707 {
29708 arg3 = (int)(SWIG_As_int(obj2));
29709 if (SWIG_arg_fail(3)) SWIG_fail;
29710 }
29711 {
29712 PyThreadState* __tstate = wxPyBeginAllowThreads();
29713 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29714
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 {
29719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29720 }
29721 return resultobj;
29722 fail:
29723 return NULL;
29724 }
29725
29726
29727 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29728 PyObject *resultobj;
29729 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29730 int arg2 ;
29731 int arg3 ;
29732 wxDragResult arg4 ;
29733 wxDragResult result;
29734 PyObject * obj0 = 0 ;
29735 PyObject * obj1 = 0 ;
29736 PyObject * obj2 = 0 ;
29737 PyObject * obj3 = 0 ;
29738 char *kwnames[] = {
29739 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29740 };
29741
29742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29744 if (SWIG_arg_fail(1)) SWIG_fail;
29745 {
29746 arg2 = (int)(SWIG_As_int(obj1));
29747 if (SWIG_arg_fail(2)) SWIG_fail;
29748 }
29749 {
29750 arg3 = (int)(SWIG_As_int(obj2));
29751 if (SWIG_arg_fail(3)) SWIG_fail;
29752 }
29753 {
29754 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29755 if (SWIG_arg_fail(4)) SWIG_fail;
29756 }
29757 {
29758 PyThreadState* __tstate = wxPyBeginAllowThreads();
29759 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29760
29761 wxPyEndAllowThreads(__tstate);
29762 if (PyErr_Occurred()) SWIG_fail;
29763 }
29764 resultobj = SWIG_From_int((result));
29765 return resultobj;
29766 fail:
29767 return NULL;
29768 }
29769
29770
29771 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29772 PyObject *obj;
29773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29774 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29775 Py_INCREF(obj);
29776 return Py_BuildValue((char *)"");
29777 }
29778 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29779 PyObject *resultobj;
29780 wxClipboard *result;
29781 char *kwnames[] = {
29782 NULL
29783 };
29784
29785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 result = (wxClipboard *)new wxClipboard();
29789
29790 wxPyEndAllowThreads(__tstate);
29791 if (PyErr_Occurred()) SWIG_fail;
29792 }
29793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29794 return resultobj;
29795 fail:
29796 return NULL;
29797 }
29798
29799
29800 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29801 PyObject *resultobj;
29802 wxClipboard *arg1 = (wxClipboard *) 0 ;
29803 PyObject * obj0 = 0 ;
29804 char *kwnames[] = {
29805 (char *) "self", NULL
29806 };
29807
29808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29810 if (SWIG_arg_fail(1)) SWIG_fail;
29811 {
29812 PyThreadState* __tstate = wxPyBeginAllowThreads();
29813 delete arg1;
29814
29815 wxPyEndAllowThreads(__tstate);
29816 if (PyErr_Occurred()) SWIG_fail;
29817 }
29818 Py_INCREF(Py_None); resultobj = Py_None;
29819 return resultobj;
29820 fail:
29821 return NULL;
29822 }
29823
29824
29825 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29826 PyObject *resultobj;
29827 wxClipboard *arg1 = (wxClipboard *) 0 ;
29828 bool result;
29829 PyObject * obj0 = 0 ;
29830 char *kwnames[] = {
29831 (char *) "self", NULL
29832 };
29833
29834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29836 if (SWIG_arg_fail(1)) SWIG_fail;
29837 {
29838 PyThreadState* __tstate = wxPyBeginAllowThreads();
29839 result = (bool)(arg1)->Open();
29840
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 {
29845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29846 }
29847 return resultobj;
29848 fail:
29849 return NULL;
29850 }
29851
29852
29853 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29854 PyObject *resultobj;
29855 wxClipboard *arg1 = (wxClipboard *) 0 ;
29856 PyObject * obj0 = 0 ;
29857 char *kwnames[] = {
29858 (char *) "self", NULL
29859 };
29860
29861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29863 if (SWIG_arg_fail(1)) SWIG_fail;
29864 {
29865 PyThreadState* __tstate = wxPyBeginAllowThreads();
29866 (arg1)->Close();
29867
29868 wxPyEndAllowThreads(__tstate);
29869 if (PyErr_Occurred()) SWIG_fail;
29870 }
29871 Py_INCREF(Py_None); resultobj = Py_None;
29872 return resultobj;
29873 fail:
29874 return NULL;
29875 }
29876
29877
29878 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29879 PyObject *resultobj;
29880 wxClipboard *arg1 = (wxClipboard *) 0 ;
29881 bool result;
29882 PyObject * obj0 = 0 ;
29883 char *kwnames[] = {
29884 (char *) "self", NULL
29885 };
29886
29887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29889 if (SWIG_arg_fail(1)) SWIG_fail;
29890 {
29891 PyThreadState* __tstate = wxPyBeginAllowThreads();
29892 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29893
29894 wxPyEndAllowThreads(__tstate);
29895 if (PyErr_Occurred()) SWIG_fail;
29896 }
29897 {
29898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29899 }
29900 return resultobj;
29901 fail:
29902 return NULL;
29903 }
29904
29905
29906 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29907 PyObject *resultobj;
29908 wxClipboard *arg1 = (wxClipboard *) 0 ;
29909 wxDataObject *arg2 = (wxDataObject *) 0 ;
29910 bool result;
29911 PyObject * obj0 = 0 ;
29912 PyObject * obj1 = 0 ;
29913 char *kwnames[] = {
29914 (char *) "self",(char *) "data", NULL
29915 };
29916
29917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29919 if (SWIG_arg_fail(1)) SWIG_fail;
29920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29921 if (SWIG_arg_fail(2)) SWIG_fail;
29922 {
29923 PyThreadState* __tstate = wxPyBeginAllowThreads();
29924 result = (bool)(arg1)->AddData(arg2);
29925
29926 wxPyEndAllowThreads(__tstate);
29927 if (PyErr_Occurred()) SWIG_fail;
29928 }
29929 {
29930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29931 }
29932 return resultobj;
29933 fail:
29934 return NULL;
29935 }
29936
29937
29938 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29939 PyObject *resultobj;
29940 wxClipboard *arg1 = (wxClipboard *) 0 ;
29941 wxDataObject *arg2 = (wxDataObject *) 0 ;
29942 bool result;
29943 PyObject * obj0 = 0 ;
29944 PyObject * obj1 = 0 ;
29945 char *kwnames[] = {
29946 (char *) "self",(char *) "data", NULL
29947 };
29948
29949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29951 if (SWIG_arg_fail(1)) SWIG_fail;
29952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29953 if (SWIG_arg_fail(2)) SWIG_fail;
29954 {
29955 PyThreadState* __tstate = wxPyBeginAllowThreads();
29956 result = (bool)(arg1)->SetData(arg2);
29957
29958 wxPyEndAllowThreads(__tstate);
29959 if (PyErr_Occurred()) SWIG_fail;
29960 }
29961 {
29962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29963 }
29964 return resultobj;
29965 fail:
29966 return NULL;
29967 }
29968
29969
29970 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29971 PyObject *resultobj;
29972 wxClipboard *arg1 = (wxClipboard *) 0 ;
29973 wxDataFormat *arg2 = 0 ;
29974 bool result;
29975 PyObject * obj0 = 0 ;
29976 PyObject * obj1 = 0 ;
29977 char *kwnames[] = {
29978 (char *) "self",(char *) "format", NULL
29979 };
29980
29981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29983 if (SWIG_arg_fail(1)) SWIG_fail;
29984 {
29985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29986 if (SWIG_arg_fail(2)) SWIG_fail;
29987 if (arg2 == NULL) {
29988 SWIG_null_ref("wxDataFormat");
29989 }
29990 if (SWIG_arg_fail(2)) SWIG_fail;
29991 }
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29995
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 {
30000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30001 }
30002 return resultobj;
30003 fail:
30004 return NULL;
30005 }
30006
30007
30008 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30009 PyObject *resultobj;
30010 wxClipboard *arg1 = (wxClipboard *) 0 ;
30011 wxDataObject *arg2 = 0 ;
30012 bool result;
30013 PyObject * obj0 = 0 ;
30014 PyObject * obj1 = 0 ;
30015 char *kwnames[] = {
30016 (char *) "self",(char *) "data", NULL
30017 };
30018
30019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30021 if (SWIG_arg_fail(1)) SWIG_fail;
30022 {
30023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30024 if (SWIG_arg_fail(2)) SWIG_fail;
30025 if (arg2 == NULL) {
30026 SWIG_null_ref("wxDataObject");
30027 }
30028 if (SWIG_arg_fail(2)) SWIG_fail;
30029 }
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 result = (bool)(arg1)->GetData(*arg2);
30033
30034 wxPyEndAllowThreads(__tstate);
30035 if (PyErr_Occurred()) SWIG_fail;
30036 }
30037 {
30038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30039 }
30040 return resultobj;
30041 fail:
30042 return NULL;
30043 }
30044
30045
30046 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30047 PyObject *resultobj;
30048 wxClipboard *arg1 = (wxClipboard *) 0 ;
30049 PyObject * obj0 = 0 ;
30050 char *kwnames[] = {
30051 (char *) "self", NULL
30052 };
30053
30054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30056 if (SWIG_arg_fail(1)) SWIG_fail;
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 (arg1)->Clear();
30060
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 Py_INCREF(Py_None); resultobj = Py_None;
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30072 PyObject *resultobj;
30073 wxClipboard *arg1 = (wxClipboard *) 0 ;
30074 bool result;
30075 PyObject * obj0 = 0 ;
30076 char *kwnames[] = {
30077 (char *) "self", NULL
30078 };
30079
30080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30082 if (SWIG_arg_fail(1)) SWIG_fail;
30083 {
30084 PyThreadState* __tstate = wxPyBeginAllowThreads();
30085 result = (bool)(arg1)->Flush();
30086
30087 wxPyEndAllowThreads(__tstate);
30088 if (PyErr_Occurred()) SWIG_fail;
30089 }
30090 {
30091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30092 }
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30100 PyObject *resultobj;
30101 wxClipboard *arg1 = (wxClipboard *) 0 ;
30102 bool arg2 = (bool) true ;
30103 PyObject * obj0 = 0 ;
30104 PyObject * obj1 = 0 ;
30105 char *kwnames[] = {
30106 (char *) "self",(char *) "primary", NULL
30107 };
30108
30109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30111 if (SWIG_arg_fail(1)) SWIG_fail;
30112 if (obj1) {
30113 {
30114 arg2 = (bool)(SWIG_As_bool(obj1));
30115 if (SWIG_arg_fail(2)) SWIG_fail;
30116 }
30117 }
30118 {
30119 PyThreadState* __tstate = wxPyBeginAllowThreads();
30120 (arg1)->UsePrimarySelection(arg2);
30121
30122 wxPyEndAllowThreads(__tstate);
30123 if (PyErr_Occurred()) SWIG_fail;
30124 }
30125 Py_INCREF(Py_None); resultobj = Py_None;
30126 return resultobj;
30127 fail:
30128 return NULL;
30129 }
30130
30131
30132 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30133 PyObject *resultobj;
30134 wxClipboard *result;
30135 char *kwnames[] = {
30136 NULL
30137 };
30138
30139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30140 {
30141 PyThreadState* __tstate = wxPyBeginAllowThreads();
30142 result = (wxClipboard *)wxClipboard::Get();
30143
30144 wxPyEndAllowThreads(__tstate);
30145 if (PyErr_Occurred()) SWIG_fail;
30146 }
30147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30148 return resultobj;
30149 fail:
30150 return NULL;
30151 }
30152
30153
30154 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30155 PyObject *obj;
30156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30157 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30158 Py_INCREF(obj);
30159 return Py_BuildValue((char *)"");
30160 }
30161 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30162 PyObject *resultobj;
30163 wxClipboard *arg1 = (wxClipboard *) NULL ;
30164 wxClipboardLocker *result;
30165 PyObject * obj0 = 0 ;
30166 char *kwnames[] = {
30167 (char *) "clipboard", NULL
30168 };
30169
30170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30171 if (obj0) {
30172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30173 if (SWIG_arg_fail(1)) SWIG_fail;
30174 }
30175 {
30176 PyThreadState* __tstate = wxPyBeginAllowThreads();
30177 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30178
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30183 return resultobj;
30184 fail:
30185 return NULL;
30186 }
30187
30188
30189 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30190 PyObject *resultobj;
30191 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30192 PyObject * obj0 = 0 ;
30193 char *kwnames[] = {
30194 (char *) "self", NULL
30195 };
30196
30197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30199 if (SWIG_arg_fail(1)) SWIG_fail;
30200 {
30201 PyThreadState* __tstate = wxPyBeginAllowThreads();
30202 delete arg1;
30203
30204 wxPyEndAllowThreads(__tstate);
30205 if (PyErr_Occurred()) SWIG_fail;
30206 }
30207 Py_INCREF(Py_None); resultobj = Py_None;
30208 return resultobj;
30209 fail:
30210 return NULL;
30211 }
30212
30213
30214 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30215 PyObject *resultobj;
30216 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30217 bool result;
30218 PyObject * obj0 = 0 ;
30219 char *kwnames[] = {
30220 (char *) "self", NULL
30221 };
30222
30223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30225 if (SWIG_arg_fail(1)) SWIG_fail;
30226 {
30227 PyThreadState* __tstate = wxPyBeginAllowThreads();
30228 result = (bool)wxClipboardLocker___nonzero__(arg1);
30229
30230 wxPyEndAllowThreads(__tstate);
30231 if (PyErr_Occurred()) SWIG_fail;
30232 }
30233 {
30234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30235 }
30236 return resultobj;
30237 fail:
30238 return NULL;
30239 }
30240
30241
30242 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30243 PyObject *obj;
30244 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30245 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30246 Py_INCREF(obj);
30247 return Py_BuildValue((char *)"");
30248 }
30249 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30250 PyObject *resultobj;
30251 int arg1 = (int) 0 ;
30252 int arg2 = (int) 0 ;
30253 int arg3 = (int) 0 ;
30254 int arg4 = (int) 0 ;
30255 wxVideoMode *result;
30256 PyObject * obj0 = 0 ;
30257 PyObject * obj1 = 0 ;
30258 PyObject * obj2 = 0 ;
30259 PyObject * obj3 = 0 ;
30260 char *kwnames[] = {
30261 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30262 };
30263
30264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30265 if (obj0) {
30266 {
30267 arg1 = (int)(SWIG_As_int(obj0));
30268 if (SWIG_arg_fail(1)) SWIG_fail;
30269 }
30270 }
30271 if (obj1) {
30272 {
30273 arg2 = (int)(SWIG_As_int(obj1));
30274 if (SWIG_arg_fail(2)) SWIG_fail;
30275 }
30276 }
30277 if (obj2) {
30278 {
30279 arg3 = (int)(SWIG_As_int(obj2));
30280 if (SWIG_arg_fail(3)) SWIG_fail;
30281 }
30282 }
30283 if (obj3) {
30284 {
30285 arg4 = (int)(SWIG_As_int(obj3));
30286 if (SWIG_arg_fail(4)) SWIG_fail;
30287 }
30288 }
30289 {
30290 PyThreadState* __tstate = wxPyBeginAllowThreads();
30291 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30292
30293 wxPyEndAllowThreads(__tstate);
30294 if (PyErr_Occurred()) SWIG_fail;
30295 }
30296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30297 return resultobj;
30298 fail:
30299 return NULL;
30300 }
30301
30302
30303 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30304 PyObject *resultobj;
30305 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30306 PyObject * obj0 = 0 ;
30307 char *kwnames[] = {
30308 (char *) "self", NULL
30309 };
30310
30311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30313 if (SWIG_arg_fail(1)) SWIG_fail;
30314 {
30315 PyThreadState* __tstate = wxPyBeginAllowThreads();
30316 delete arg1;
30317
30318 wxPyEndAllowThreads(__tstate);
30319 if (PyErr_Occurred()) SWIG_fail;
30320 }
30321 Py_INCREF(Py_None); resultobj = Py_None;
30322 return resultobj;
30323 fail:
30324 return NULL;
30325 }
30326
30327
30328 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30329 PyObject *resultobj;
30330 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30331 wxVideoMode *arg2 = 0 ;
30332 bool result;
30333 PyObject * obj0 = 0 ;
30334 PyObject * obj1 = 0 ;
30335 char *kwnames[] = {
30336 (char *) "self",(char *) "other", NULL
30337 };
30338
30339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30341 if (SWIG_arg_fail(1)) SWIG_fail;
30342 {
30343 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30344 if (SWIG_arg_fail(2)) SWIG_fail;
30345 if (arg2 == NULL) {
30346 SWIG_null_ref("wxVideoMode");
30347 }
30348 if (SWIG_arg_fail(2)) SWIG_fail;
30349 }
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30353
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 {
30358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30359 }
30360 return resultobj;
30361 fail:
30362 return NULL;
30363 }
30364
30365
30366 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30367 PyObject *resultobj;
30368 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30369 int result;
30370 PyObject * obj0 = 0 ;
30371 char *kwnames[] = {
30372 (char *) "self", NULL
30373 };
30374
30375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30377 if (SWIG_arg_fail(1)) SWIG_fail;
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30381
30382 wxPyEndAllowThreads(__tstate);
30383 if (PyErr_Occurred()) SWIG_fail;
30384 }
30385 {
30386 resultobj = SWIG_From_int((int)(result));
30387 }
30388 return resultobj;
30389 fail:
30390 return NULL;
30391 }
30392
30393
30394 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30395 PyObject *resultobj;
30396 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30397 int result;
30398 PyObject * obj0 = 0 ;
30399 char *kwnames[] = {
30400 (char *) "self", NULL
30401 };
30402
30403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30405 if (SWIG_arg_fail(1)) SWIG_fail;
30406 {
30407 PyThreadState* __tstate = wxPyBeginAllowThreads();
30408 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30409
30410 wxPyEndAllowThreads(__tstate);
30411 if (PyErr_Occurred()) SWIG_fail;
30412 }
30413 {
30414 resultobj = SWIG_From_int((int)(result));
30415 }
30416 return resultobj;
30417 fail:
30418 return NULL;
30419 }
30420
30421
30422 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30423 PyObject *resultobj;
30424 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30425 int result;
30426 PyObject * obj0 = 0 ;
30427 char *kwnames[] = {
30428 (char *) "self", NULL
30429 };
30430
30431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30433 if (SWIG_arg_fail(1)) SWIG_fail;
30434 {
30435 PyThreadState* __tstate = wxPyBeginAllowThreads();
30436 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30437
30438 wxPyEndAllowThreads(__tstate);
30439 if (PyErr_Occurred()) SWIG_fail;
30440 }
30441 {
30442 resultobj = SWIG_From_int((int)(result));
30443 }
30444 return resultobj;
30445 fail:
30446 return NULL;
30447 }
30448
30449
30450 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30451 PyObject *resultobj;
30452 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30453 bool result;
30454 PyObject * obj0 = 0 ;
30455 char *kwnames[] = {
30456 (char *) "self", NULL
30457 };
30458
30459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30461 if (SWIG_arg_fail(1)) SWIG_fail;
30462 {
30463 PyThreadState* __tstate = wxPyBeginAllowThreads();
30464 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30465
30466 wxPyEndAllowThreads(__tstate);
30467 if (PyErr_Occurred()) SWIG_fail;
30468 }
30469 {
30470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30471 }
30472 return resultobj;
30473 fail:
30474 return NULL;
30475 }
30476
30477
30478 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30479 PyObject *resultobj;
30480 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30481 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30482 bool result;
30483 PyObject * obj0 = 0 ;
30484 PyObject * obj1 = 0 ;
30485 char *kwnames[] = {
30486 (char *) "self",(char *) "other", NULL
30487 };
30488
30489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30491 if (SWIG_arg_fail(1)) SWIG_fail;
30492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30493 if (SWIG_arg_fail(2)) SWIG_fail;
30494 {
30495 PyThreadState* __tstate = wxPyBeginAllowThreads();
30496 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30497
30498 wxPyEndAllowThreads(__tstate);
30499 if (PyErr_Occurred()) SWIG_fail;
30500 }
30501 {
30502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30503 }
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30511 PyObject *resultobj;
30512 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30513 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30514 bool result;
30515 PyObject * obj0 = 0 ;
30516 PyObject * obj1 = 0 ;
30517 char *kwnames[] = {
30518 (char *) "self",(char *) "other", NULL
30519 };
30520
30521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30523 if (SWIG_arg_fail(1)) SWIG_fail;
30524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30525 if (SWIG_arg_fail(2)) SWIG_fail;
30526 {
30527 PyThreadState* __tstate = wxPyBeginAllowThreads();
30528 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30529
30530 wxPyEndAllowThreads(__tstate);
30531 if (PyErr_Occurred()) SWIG_fail;
30532 }
30533 {
30534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30535 }
30536 return resultobj;
30537 fail:
30538 return NULL;
30539 }
30540
30541
30542 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30543 PyObject *resultobj;
30544 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30545 int arg2 ;
30546 PyObject * obj0 = 0 ;
30547 PyObject * obj1 = 0 ;
30548 char *kwnames[] = {
30549 (char *) "self",(char *) "w", NULL
30550 };
30551
30552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30554 if (SWIG_arg_fail(1)) SWIG_fail;
30555 {
30556 arg2 = (int)(SWIG_As_int(obj1));
30557 if (SWIG_arg_fail(2)) SWIG_fail;
30558 }
30559 if (arg1) (arg1)->w = arg2;
30560
30561 Py_INCREF(Py_None); resultobj = Py_None;
30562 return resultobj;
30563 fail:
30564 return NULL;
30565 }
30566
30567
30568 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30569 PyObject *resultobj;
30570 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30571 int result;
30572 PyObject * obj0 = 0 ;
30573 char *kwnames[] = {
30574 (char *) "self", NULL
30575 };
30576
30577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30579 if (SWIG_arg_fail(1)) SWIG_fail;
30580 result = (int) ((arg1)->w);
30581
30582 {
30583 resultobj = SWIG_From_int((int)(result));
30584 }
30585 return resultobj;
30586 fail:
30587 return NULL;
30588 }
30589
30590
30591 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30592 PyObject *resultobj;
30593 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30594 int arg2 ;
30595 PyObject * obj0 = 0 ;
30596 PyObject * obj1 = 0 ;
30597 char *kwnames[] = {
30598 (char *) "self",(char *) "h", NULL
30599 };
30600
30601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30603 if (SWIG_arg_fail(1)) SWIG_fail;
30604 {
30605 arg2 = (int)(SWIG_As_int(obj1));
30606 if (SWIG_arg_fail(2)) SWIG_fail;
30607 }
30608 if (arg1) (arg1)->h = arg2;
30609
30610 Py_INCREF(Py_None); resultobj = Py_None;
30611 return resultobj;
30612 fail:
30613 return NULL;
30614 }
30615
30616
30617 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30618 PyObject *resultobj;
30619 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30620 int result;
30621 PyObject * obj0 = 0 ;
30622 char *kwnames[] = {
30623 (char *) "self", NULL
30624 };
30625
30626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30628 if (SWIG_arg_fail(1)) SWIG_fail;
30629 result = (int) ((arg1)->h);
30630
30631 {
30632 resultobj = SWIG_From_int((int)(result));
30633 }
30634 return resultobj;
30635 fail:
30636 return NULL;
30637 }
30638
30639
30640 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30641 PyObject *resultobj;
30642 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30643 int arg2 ;
30644 PyObject * obj0 = 0 ;
30645 PyObject * obj1 = 0 ;
30646 char *kwnames[] = {
30647 (char *) "self",(char *) "bpp", NULL
30648 };
30649
30650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30652 if (SWIG_arg_fail(1)) SWIG_fail;
30653 {
30654 arg2 = (int)(SWIG_As_int(obj1));
30655 if (SWIG_arg_fail(2)) SWIG_fail;
30656 }
30657 if (arg1) (arg1)->bpp = arg2;
30658
30659 Py_INCREF(Py_None); resultobj = Py_None;
30660 return resultobj;
30661 fail:
30662 return NULL;
30663 }
30664
30665
30666 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30667 PyObject *resultobj;
30668 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30669 int result;
30670 PyObject * obj0 = 0 ;
30671 char *kwnames[] = {
30672 (char *) "self", NULL
30673 };
30674
30675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30677 if (SWIG_arg_fail(1)) SWIG_fail;
30678 result = (int) ((arg1)->bpp);
30679
30680 {
30681 resultobj = SWIG_From_int((int)(result));
30682 }
30683 return resultobj;
30684 fail:
30685 return NULL;
30686 }
30687
30688
30689 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30690 PyObject *resultobj;
30691 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30692 int arg2 ;
30693 PyObject * obj0 = 0 ;
30694 PyObject * obj1 = 0 ;
30695 char *kwnames[] = {
30696 (char *) "self",(char *) "refresh", NULL
30697 };
30698
30699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30701 if (SWIG_arg_fail(1)) SWIG_fail;
30702 {
30703 arg2 = (int)(SWIG_As_int(obj1));
30704 if (SWIG_arg_fail(2)) SWIG_fail;
30705 }
30706 if (arg1) (arg1)->refresh = arg2;
30707
30708 Py_INCREF(Py_None); resultobj = Py_None;
30709 return resultobj;
30710 fail:
30711 return NULL;
30712 }
30713
30714
30715 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30716 PyObject *resultobj;
30717 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30718 int result;
30719 PyObject * obj0 = 0 ;
30720 char *kwnames[] = {
30721 (char *) "self", NULL
30722 };
30723
30724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30726 if (SWIG_arg_fail(1)) SWIG_fail;
30727 result = (int) ((arg1)->refresh);
30728
30729 {
30730 resultobj = SWIG_From_int((int)(result));
30731 }
30732 return resultobj;
30733 fail:
30734 return NULL;
30735 }
30736
30737
30738 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30739 PyObject *obj;
30740 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30741 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30742 Py_INCREF(obj);
30743 return Py_BuildValue((char *)"");
30744 }
30745 static int _wrap_DefaultVideoMode_set(PyObject *) {
30746 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30747 return 1;
30748 }
30749
30750
30751 static PyObject *_wrap_DefaultVideoMode_get(void) {
30752 PyObject *pyobj;
30753
30754 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30755 return pyobj;
30756 }
30757
30758
30759 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30760 PyObject *resultobj;
30761 size_t arg1 = (size_t) 0 ;
30762 wxDisplay *result;
30763 PyObject * obj0 = 0 ;
30764 char *kwnames[] = {
30765 (char *) "index", NULL
30766 };
30767
30768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30769 if (obj0) {
30770 {
30771 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30772 if (SWIG_arg_fail(1)) SWIG_fail;
30773 }
30774 }
30775 {
30776 PyThreadState* __tstate = wxPyBeginAllowThreads();
30777 result = (wxDisplay *)new wxDisplay(arg1);
30778
30779 wxPyEndAllowThreads(__tstate);
30780 if (PyErr_Occurred()) SWIG_fail;
30781 }
30782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30790 PyObject *resultobj;
30791 wxDisplay *arg1 = (wxDisplay *) 0 ;
30792 PyObject * obj0 = 0 ;
30793 char *kwnames[] = {
30794 (char *) "self", NULL
30795 };
30796
30797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30799 if (SWIG_arg_fail(1)) SWIG_fail;
30800 {
30801 PyThreadState* __tstate = wxPyBeginAllowThreads();
30802 delete arg1;
30803
30804 wxPyEndAllowThreads(__tstate);
30805 if (PyErr_Occurred()) SWIG_fail;
30806 }
30807 Py_INCREF(Py_None); resultobj = Py_None;
30808 return resultobj;
30809 fail:
30810 return NULL;
30811 }
30812
30813
30814 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30815 PyObject *resultobj;
30816 size_t result;
30817 char *kwnames[] = {
30818 NULL
30819 };
30820
30821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30822 {
30823 PyThreadState* __tstate = wxPyBeginAllowThreads();
30824 result = (size_t)wxDisplay::GetCount();
30825
30826 wxPyEndAllowThreads(__tstate);
30827 if (PyErr_Occurred()) SWIG_fail;
30828 }
30829 {
30830 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30831 }
30832 return resultobj;
30833 fail:
30834 return NULL;
30835 }
30836
30837
30838 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30839 PyObject *resultobj;
30840 wxPoint *arg1 = 0 ;
30841 int result;
30842 wxPoint temp1 ;
30843 PyObject * obj0 = 0 ;
30844 char *kwnames[] = {
30845 (char *) "pt", NULL
30846 };
30847
30848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30849 {
30850 arg1 = &temp1;
30851 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30852 }
30853 {
30854 PyThreadState* __tstate = wxPyBeginAllowThreads();
30855 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30856
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 {
30861 resultobj = SWIG_From_int((int)(result));
30862 }
30863 return resultobj;
30864 fail:
30865 return NULL;
30866 }
30867
30868
30869 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30870 PyObject *resultobj;
30871 wxWindow *arg1 = (wxWindow *) 0 ;
30872 int result;
30873 PyObject * obj0 = 0 ;
30874 char *kwnames[] = {
30875 (char *) "window", NULL
30876 };
30877
30878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30880 if (SWIG_arg_fail(1)) SWIG_fail;
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 result = (int)wxDisplay::GetFromWindow(arg1);
30884
30885 wxPyEndAllowThreads(__tstate);
30886 if (PyErr_Occurred()) SWIG_fail;
30887 }
30888 {
30889 resultobj = SWIG_From_int((int)(result));
30890 }
30891 return resultobj;
30892 fail:
30893 return NULL;
30894 }
30895
30896
30897 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30898 PyObject *resultobj;
30899 wxDisplay *arg1 = (wxDisplay *) 0 ;
30900 bool result;
30901 PyObject * obj0 = 0 ;
30902 char *kwnames[] = {
30903 (char *) "self", NULL
30904 };
30905
30906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30908 if (SWIG_arg_fail(1)) SWIG_fail;
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = (bool)((wxDisplay const *)arg1)->IsOk();
30912
30913 wxPyEndAllowThreads(__tstate);
30914 if (PyErr_Occurred()) SWIG_fail;
30915 }
30916 {
30917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30918 }
30919 return resultobj;
30920 fail:
30921 return NULL;
30922 }
30923
30924
30925 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30926 PyObject *resultobj;
30927 wxDisplay *arg1 = (wxDisplay *) 0 ;
30928 wxRect result;
30929 PyObject * obj0 = 0 ;
30930 char *kwnames[] = {
30931 (char *) "self", NULL
30932 };
30933
30934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30936 if (SWIG_arg_fail(1)) SWIG_fail;
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = ((wxDisplay const *)arg1)->GetGeometry();
30940
30941 wxPyEndAllowThreads(__tstate);
30942 if (PyErr_Occurred()) SWIG_fail;
30943 }
30944 {
30945 wxRect * resultptr;
30946 resultptr = new wxRect((wxRect &)(result));
30947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30948 }
30949 return resultobj;
30950 fail:
30951 return NULL;
30952 }
30953
30954
30955 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30956 PyObject *resultobj;
30957 wxDisplay *arg1 = (wxDisplay *) 0 ;
30958 wxString result;
30959 PyObject * obj0 = 0 ;
30960 char *kwnames[] = {
30961 (char *) "self", NULL
30962 };
30963
30964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30966 if (SWIG_arg_fail(1)) SWIG_fail;
30967 {
30968 PyThreadState* __tstate = wxPyBeginAllowThreads();
30969 result = ((wxDisplay const *)arg1)->GetName();
30970
30971 wxPyEndAllowThreads(__tstate);
30972 if (PyErr_Occurred()) SWIG_fail;
30973 }
30974 {
30975 #if wxUSE_UNICODE
30976 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30977 #else
30978 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30979 #endif
30980 }
30981 return resultobj;
30982 fail:
30983 return NULL;
30984 }
30985
30986
30987 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30988 PyObject *resultobj;
30989 wxDisplay *arg1 = (wxDisplay *) 0 ;
30990 bool result;
30991 PyObject * obj0 = 0 ;
30992 char *kwnames[] = {
30993 (char *) "self", NULL
30994 };
30995
30996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30998 if (SWIG_arg_fail(1)) SWIG_fail;
30999 {
31000 PyThreadState* __tstate = wxPyBeginAllowThreads();
31001 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31002
31003 wxPyEndAllowThreads(__tstate);
31004 if (PyErr_Occurred()) SWIG_fail;
31005 }
31006 {
31007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31008 }
31009 return resultobj;
31010 fail:
31011 return NULL;
31012 }
31013
31014
31015 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31016 PyObject *resultobj;
31017 wxDisplay *arg1 = (wxDisplay *) 0 ;
31018 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31019 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31020 PyObject *result;
31021 PyObject * obj0 = 0 ;
31022 PyObject * obj1 = 0 ;
31023 char *kwnames[] = {
31024 (char *) "self",(char *) "mode", NULL
31025 };
31026
31027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31029 if (SWIG_arg_fail(1)) SWIG_fail;
31030 if (obj1) {
31031 {
31032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31033 if (SWIG_arg_fail(2)) SWIG_fail;
31034 if (arg2 == NULL) {
31035 SWIG_null_ref("wxVideoMode");
31036 }
31037 if (SWIG_arg_fail(2)) SWIG_fail;
31038 }
31039 }
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31043
31044 wxPyEndAllowThreads(__tstate);
31045 if (PyErr_Occurred()) SWIG_fail;
31046 }
31047 resultobj = result;
31048 return resultobj;
31049 fail:
31050 return NULL;
31051 }
31052
31053
31054 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31055 PyObject *resultobj;
31056 wxDisplay *arg1 = (wxDisplay *) 0 ;
31057 wxVideoMode result;
31058 PyObject * obj0 = 0 ;
31059 char *kwnames[] = {
31060 (char *) "self", NULL
31061 };
31062
31063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31065 if (SWIG_arg_fail(1)) SWIG_fail;
31066 {
31067 PyThreadState* __tstate = wxPyBeginAllowThreads();
31068 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31069
31070 wxPyEndAllowThreads(__tstate);
31071 if (PyErr_Occurred()) SWIG_fail;
31072 }
31073 {
31074 wxVideoMode * resultptr;
31075 resultptr = new wxVideoMode((wxVideoMode &)(result));
31076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31077 }
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31085 PyObject *resultobj;
31086 wxDisplay *arg1 = (wxDisplay *) 0 ;
31087 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31088 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31089 bool result;
31090 PyObject * obj0 = 0 ;
31091 PyObject * obj1 = 0 ;
31092 char *kwnames[] = {
31093 (char *) "self",(char *) "mode", NULL
31094 };
31095
31096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31098 if (SWIG_arg_fail(1)) SWIG_fail;
31099 if (obj1) {
31100 {
31101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31102 if (SWIG_arg_fail(2)) SWIG_fail;
31103 if (arg2 == NULL) {
31104 SWIG_null_ref("wxVideoMode");
31105 }
31106 if (SWIG_arg_fail(2)) SWIG_fail;
31107 }
31108 }
31109 {
31110 PyThreadState* __tstate = wxPyBeginAllowThreads();
31111 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31112
31113 wxPyEndAllowThreads(__tstate);
31114 if (PyErr_Occurred()) SWIG_fail;
31115 }
31116 {
31117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31118 }
31119 return resultobj;
31120 fail:
31121 return NULL;
31122 }
31123
31124
31125 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31126 PyObject *resultobj;
31127 wxDisplay *arg1 = (wxDisplay *) 0 ;
31128 PyObject * obj0 = 0 ;
31129 char *kwnames[] = {
31130 (char *) "self", NULL
31131 };
31132
31133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31135 if (SWIG_arg_fail(1)) SWIG_fail;
31136 {
31137 PyThreadState* __tstate = wxPyBeginAllowThreads();
31138 (arg1)->ResetMode();
31139
31140 wxPyEndAllowThreads(__tstate);
31141 if (PyErr_Occurred()) SWIG_fail;
31142 }
31143 Py_INCREF(Py_None); resultobj = Py_None;
31144 return resultobj;
31145 fail:
31146 return NULL;
31147 }
31148
31149
31150 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31151 PyObject *obj;
31152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31153 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31154 Py_INCREF(obj);
31155 return Py_BuildValue((char *)"");
31156 }
31157 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31158 PyObject *resultobj;
31159 wxStandardPaths *result;
31160 char *kwnames[] = {
31161 NULL
31162 };
31163
31164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 result = (wxStandardPaths *)StandardPaths_Get();
31168
31169 wxPyEndAllowThreads(__tstate);
31170 if (PyErr_Occurred()) SWIG_fail;
31171 }
31172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31173 return resultobj;
31174 fail:
31175 return NULL;
31176 }
31177
31178
31179 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31180 PyObject *resultobj;
31181 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31182 wxString result;
31183 PyObject * obj0 = 0 ;
31184 char *kwnames[] = {
31185 (char *) "self", NULL
31186 };
31187
31188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31190 if (SWIG_arg_fail(1)) SWIG_fail;
31191 {
31192 PyThreadState* __tstate = wxPyBeginAllowThreads();
31193 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31194
31195 wxPyEndAllowThreads(__tstate);
31196 if (PyErr_Occurred()) SWIG_fail;
31197 }
31198 {
31199 #if wxUSE_UNICODE
31200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31201 #else
31202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31203 #endif
31204 }
31205 return resultobj;
31206 fail:
31207 return NULL;
31208 }
31209
31210
31211 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31212 PyObject *resultobj;
31213 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31214 wxString result;
31215 PyObject * obj0 = 0 ;
31216 char *kwnames[] = {
31217 (char *) "self", NULL
31218 };
31219
31220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31222 if (SWIG_arg_fail(1)) SWIG_fail;
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31226
31227 wxPyEndAllowThreads(__tstate);
31228 if (PyErr_Occurred()) SWIG_fail;
31229 }
31230 {
31231 #if wxUSE_UNICODE
31232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31233 #else
31234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31235 #endif
31236 }
31237 return resultobj;
31238 fail:
31239 return NULL;
31240 }
31241
31242
31243 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31244 PyObject *resultobj;
31245 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31246 wxString result;
31247 PyObject * obj0 = 0 ;
31248 char *kwnames[] = {
31249 (char *) "self", NULL
31250 };
31251
31252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31254 if (SWIG_arg_fail(1)) SWIG_fail;
31255 {
31256 PyThreadState* __tstate = wxPyBeginAllowThreads();
31257 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31258
31259 wxPyEndAllowThreads(__tstate);
31260 if (PyErr_Occurred()) SWIG_fail;
31261 }
31262 {
31263 #if wxUSE_UNICODE
31264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31265 #else
31266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31267 #endif
31268 }
31269 return resultobj;
31270 fail:
31271 return NULL;
31272 }
31273
31274
31275 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31276 PyObject *resultobj;
31277 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31278 wxString result;
31279 PyObject * obj0 = 0 ;
31280 char *kwnames[] = {
31281 (char *) "self", NULL
31282 };
31283
31284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31286 if (SWIG_arg_fail(1)) SWIG_fail;
31287 {
31288 PyThreadState* __tstate = wxPyBeginAllowThreads();
31289 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31290
31291 wxPyEndAllowThreads(__tstate);
31292 if (PyErr_Occurred()) SWIG_fail;
31293 }
31294 {
31295 #if wxUSE_UNICODE
31296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31297 #else
31298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31299 #endif
31300 }
31301 return resultobj;
31302 fail:
31303 return NULL;
31304 }
31305
31306
31307 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31308 PyObject *resultobj;
31309 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31310 wxString result;
31311 PyObject * obj0 = 0 ;
31312 char *kwnames[] = {
31313 (char *) "self", NULL
31314 };
31315
31316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31318 if (SWIG_arg_fail(1)) SWIG_fail;
31319 {
31320 PyThreadState* __tstate = wxPyBeginAllowThreads();
31321 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31322
31323 wxPyEndAllowThreads(__tstate);
31324 if (PyErr_Occurred()) SWIG_fail;
31325 }
31326 {
31327 #if wxUSE_UNICODE
31328 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31329 #else
31330 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31331 #endif
31332 }
31333 return resultobj;
31334 fail:
31335 return NULL;
31336 }
31337
31338
31339 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31340 PyObject *resultobj;
31341 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31342 wxString result;
31343 PyObject * obj0 = 0 ;
31344 char *kwnames[] = {
31345 (char *) "self", NULL
31346 };
31347
31348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31350 if (SWIG_arg_fail(1)) SWIG_fail;
31351 {
31352 PyThreadState* __tstate = wxPyBeginAllowThreads();
31353 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31354
31355 wxPyEndAllowThreads(__tstate);
31356 if (PyErr_Occurred()) SWIG_fail;
31357 }
31358 {
31359 #if wxUSE_UNICODE
31360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31361 #else
31362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31363 #endif
31364 }
31365 return resultobj;
31366 fail:
31367 return NULL;
31368 }
31369
31370
31371 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31372 PyObject *resultobj;
31373 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31374 wxString result;
31375 PyObject * obj0 = 0 ;
31376 char *kwnames[] = {
31377 (char *) "self", NULL
31378 };
31379
31380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31382 if (SWIG_arg_fail(1)) SWIG_fail;
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31386
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 {
31391 #if wxUSE_UNICODE
31392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31393 #else
31394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31395 #endif
31396 }
31397 return resultobj;
31398 fail:
31399 return NULL;
31400 }
31401
31402
31403 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31404 PyObject *resultobj;
31405 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31406 wxString *arg2 = 0 ;
31407 bool temp2 = false ;
31408 PyObject * obj0 = 0 ;
31409 PyObject * obj1 = 0 ;
31410 char *kwnames[] = {
31411 (char *) "self",(char *) "prefix", NULL
31412 };
31413
31414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31416 if (SWIG_arg_fail(1)) SWIG_fail;
31417 {
31418 arg2 = wxString_in_helper(obj1);
31419 if (arg2 == NULL) SWIG_fail;
31420 temp2 = true;
31421 }
31422 {
31423 PyThreadState* __tstate = wxPyBeginAllowThreads();
31424 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31425
31426 wxPyEndAllowThreads(__tstate);
31427 if (PyErr_Occurred()) SWIG_fail;
31428 }
31429 Py_INCREF(Py_None); resultobj = Py_None;
31430 {
31431 if (temp2)
31432 delete arg2;
31433 }
31434 return resultobj;
31435 fail:
31436 {
31437 if (temp2)
31438 delete arg2;
31439 }
31440 return NULL;
31441 }
31442
31443
31444 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31445 PyObject *resultobj;
31446 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31447 wxString result;
31448 PyObject * obj0 = 0 ;
31449 char *kwnames[] = {
31450 (char *) "self", NULL
31451 };
31452
31453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31455 if (SWIG_arg_fail(1)) SWIG_fail;
31456 {
31457 PyThreadState* __tstate = wxPyBeginAllowThreads();
31458 result = wxStandardPaths_GetInstallPrefix(arg1);
31459
31460 wxPyEndAllowThreads(__tstate);
31461 if (PyErr_Occurred()) SWIG_fail;
31462 }
31463 {
31464 #if wxUSE_UNICODE
31465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31466 #else
31467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31468 #endif
31469 }
31470 return resultobj;
31471 fail:
31472 return NULL;
31473 }
31474
31475
31476 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31477 PyObject *obj;
31478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31479 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31480 Py_INCREF(obj);
31481 return Py_BuildValue((char *)"");
31482 }
31483 static PyMethodDef SwigMethods[] = {
31484 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31491 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31499 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31563 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31571 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31589 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31592 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31595 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31598 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31604 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31618 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31624 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31630 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31633 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31647 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31650 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31651 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31654 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31681 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31683 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31685 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31687 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31694 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31700 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31714 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31718 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31721 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31738 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31746 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31793 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31811 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31821 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31837 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31853 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31867 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31877 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31920 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31923 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31926 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31930 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32023 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32024 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32025 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32026 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32043 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32088 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32122 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32130 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32131 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32136 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32145 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32152 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32155 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32158 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32163 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32166 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32170 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32173 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32177 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32178 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32182 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32186 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32190 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32200 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32213 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32221 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32229 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32243 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32247 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32265 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32279 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32290 { NULL, NULL, 0, NULL }
32291 };
32292
32293
32294 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32295
32296 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32297 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32298 }
32299 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32300 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32301 }
32302 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32303 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32304 }
32305 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32306 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32307 }
32308 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32309 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32310 }
32311 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32312 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32313 }
32314 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32315 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32316 }
32317 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32318 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32319 }
32320 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32321 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32322 }
32323 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32324 return (void *)((wxEvent *) ((wxPyEvent *) x));
32325 }
32326 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32327 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32328 }
32329 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32330 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32331 }
32332 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32333 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32334 }
32335 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32336 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32337 }
32338 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32339 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32340 }
32341 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32342 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32343 }
32344 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32345 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32346 }
32347 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32348 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32349 }
32350 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32351 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32352 }
32353 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32354 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32355 }
32356 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32357 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32358 }
32359 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32360 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32361 }
32362 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32363 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32364 }
32365 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32366 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32367 }
32368 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32369 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32370 }
32371 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32372 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32373 }
32374 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32375 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32376 }
32377 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32378 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32379 }
32380 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32381 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32382 }
32383 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32384 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32385 }
32386 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32387 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32388 }
32389 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32390 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32391 }
32392 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32393 return (void *)((wxEvent *) ((wxShowEvent *) x));
32394 }
32395 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32396 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32397 }
32398 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32399 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32400 }
32401 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32402 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32403 }
32404 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32405 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32406 }
32407 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32408 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32409 }
32410 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32411 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32412 }
32413 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32414 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32415 }
32416 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32417 return (void *)((wxConfigBase *) ((wxConfig *) x));
32418 }
32419 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32420 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32421 }
32422 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32423 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32424 }
32425 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32426 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32427 }
32428 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32429 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32430 }
32431 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32432 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32433 }
32434 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32435 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32436 }
32437 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32438 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32439 }
32440 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32441 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32442 }
32443 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32444 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32445 }
32446 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32447 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32448 }
32449 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32450 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32451 }
32452 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32453 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32454 }
32455 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32456 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32457 }
32458 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32459 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32460 }
32461 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32462 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32463 }
32464 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32465 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32466 }
32467 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32468 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32469 }
32470 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32471 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32472 }
32473 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32474 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32475 }
32476 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32477 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32478 }
32479 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32480 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32481 }
32482 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32483 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32484 }
32485 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32486 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32487 }
32488 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32489 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32490 }
32491 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32492 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32493 }
32494 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32495 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32496 }
32497 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32498 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32499 }
32500 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32501 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32502 }
32503 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32504 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32505 }
32506 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32507 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32508 }
32509 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32510 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32511 }
32512 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32513 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32514 }
32515 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32516 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32517 }
32518 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32519 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32520 }
32521 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32522 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32523 }
32524 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32525 return (void *)((wxObject *) ((wxSizerItem *) x));
32526 }
32527 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32528 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32529 }
32530 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32531 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32532 }
32533 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32534 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32535 }
32536 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32537 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32538 }
32539 static void *_p_wxSizerTo_p_wxObject(void *x) {
32540 return (void *)((wxObject *) ((wxSizer *) x));
32541 }
32542 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32543 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32544 }
32545 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32546 return (void *)((wxObject *) ((wxFileHistory *) x));
32547 }
32548 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32549 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32550 }
32551 static void *_p_wxEventTo_p_wxObject(void *x) {
32552 return (void *)((wxObject *) ((wxEvent *) x));
32553 }
32554 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32555 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32556 }
32557 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32558 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32559 }
32560 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32561 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32562 }
32563 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32564 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32565 }
32566 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32567 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32568 }
32569 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32570 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32571 }
32572 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32573 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32574 }
32575 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32576 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32577 }
32578 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32579 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32580 }
32581 static void *_p_wxControlTo_p_wxObject(void *x) {
32582 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32583 }
32584 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32585 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32586 }
32587 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32588 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32589 }
32590 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32591 return (void *)((wxObject *) ((wxFSFile *) x));
32592 }
32593 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32594 return (void *)((wxObject *) ((wxClipboard *) x));
32595 }
32596 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32597 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32598 }
32599 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32600 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32601 }
32602 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32603 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32604 }
32605 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32606 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32607 }
32608 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32609 return (void *)((wxObject *) ((wxToolTip *) x));
32610 }
32611 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32612 return (void *)((wxObject *) ((wxMenuItem *) x));
32613 }
32614 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32615 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32616 }
32617 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32618 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32619 }
32620 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32621 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32622 }
32623 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32624 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32625 }
32626 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32627 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32628 }
32629 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32630 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32631 }
32632 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32633 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32634 }
32635 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32636 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32637 }
32638 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32639 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32640 }
32641 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32642 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32643 }
32644 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32645 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32646 }
32647 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32648 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32649 }
32650 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32651 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32652 }
32653 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32654 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32655 }
32656 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32657 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32658 }
32659 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32660 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32661 }
32662 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32663 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32664 }
32665 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32666 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32667 }
32668 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32669 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32670 }
32671 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32672 return (void *)((wxObject *) ((wxImageHandler *) x));
32673 }
32674 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32675 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32676 }
32677 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32678 return (void *)((wxObject *) ((wxEvtHandler *) x));
32679 }
32680 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32681 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32682 }
32683 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32684 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32685 }
32686 static void *_p_wxImageTo_p_wxObject(void *x) {
32687 return (void *)((wxObject *) ((wxImage *) x));
32688 }
32689 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32690 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32691 }
32692 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32693 return (void *)((wxObject *) ((wxSystemOptions *) x));
32694 }
32695 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32696 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32697 }
32698 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32699 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32700 }
32701 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32702 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32703 }
32704 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32705 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32706 }
32707 static void *_p_wxWindowTo_p_wxObject(void *x) {
32708 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32709 }
32710 static void *_p_wxMenuTo_p_wxObject(void *x) {
32711 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32712 }
32713 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32714 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32715 }
32716 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32717 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32718 }
32719 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32720 return (void *)((wxObject *) ((wxFileSystem *) x));
32721 }
32722 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32723 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32724 }
32725 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32726 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32727 }
32728 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32729 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32730 }
32731 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32732 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32733 }
32734 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32735 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32736 }
32737 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32738 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32739 }
32740 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32741 return (void *)((wxObject *) ((wxBusyInfo *) x));
32742 }
32743 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32744 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32745 }
32746 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32747 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32748 }
32749 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32750 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32751 }
32752 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32753 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32754 }
32755 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32756 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32757 }
32758 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32759 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32760 }
32761 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32762 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32763 }
32764 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32765 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32766 }
32767 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32768 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32769 }
32770 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32771 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32772 }
32773 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32774 return (void *)((wxLog *) ((wxLogStderr *) x));
32775 }
32776 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32777 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32778 }
32779 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32780 return (void *)((wxLog *) ((wxLogWindow *) x));
32781 }
32782 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32783 return (void *)((wxLog *) ((wxLogChain *) x));
32784 }
32785 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32786 return (void *)((wxLog *) ((wxLogGui *) x));
32787 }
32788 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32789 return (void *)((wxLog *) ((wxPyLog *) x));
32790 }
32791 static void *_p_wxControlTo_p_wxWindow(void *x) {
32792 return (void *)((wxWindow *) ((wxControl *) x));
32793 }
32794 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32795 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32796 }
32797 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32798 return (void *)((wxWindow *) ((wxMenuBar *) x));
32799 }
32800 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32801 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32802 }
32803 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32804 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32805 }
32806 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}};
32807 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}};
32808 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}};
32809 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}};
32810 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}};
32811 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}};
32812 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32813 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}};
32814 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}};
32815 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}};
32816 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}};
32817 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}};
32818 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}};
32819 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}};
32820 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}};
32821 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}};
32822 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}};
32823 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}};
32824 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}};
32825 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}};
32826 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}};
32827 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}};
32828 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32829 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}};
32830 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}};
32831 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}};
32832 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}};
32833 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}};
32834 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}};
32835 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}};
32836 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}};
32837 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}};
32838 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}};
32839 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}};
32840 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}};
32841 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}};
32842 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}};
32843 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}};
32844 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}};
32845 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}};
32846 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}};
32847 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}};
32848 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}};
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 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}};
32856 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}};
32857 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}};
32858 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}};
32859 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}};
32860 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}};
32861 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}};
32862 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}};
32863 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}};
32864 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}};
32865 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}};
32866 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}};
32867 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}};
32868 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}};
32869 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}};
32870 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}};
32871 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}};
32872 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}};
32873 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}};
32874 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}};
32875 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}};
32876 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}};
32877 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32878 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}};
32879 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}};
32880 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}};
32881 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}};
32882 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}};
32883 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}};
32884 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}};
32885 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}};
32886 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}};
32887 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}};
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 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}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903
32904 static swig_type_info *swig_types_initial[] = {
32905 _swigt__p_wxLogChain,
32906 _swigt__p_wxMutexGuiLocker,
32907 _swigt__p_wxMetafile,
32908 _swigt__p_wxFileHistory,
32909 _swigt__p_wxLog,
32910 _swigt__p_wxMenu,
32911 _swigt__p_wxEvent,
32912 _swigt__p_wxDateTime__TimeZone,
32913 _swigt__p_wxConfigBase,
32914 _swigt__p_wxDisplay,
32915 _swigt__p_wxFileType,
32916 _swigt__p_wxLogGui,
32917 _swigt__p_wxFont,
32918 _swigt__p_wxDataFormat,
32919 _swigt__p_wxTimerEvent,
32920 _swigt__p_wxCaret,
32921 _swigt__ptrdiff_t,
32922 _swigt__std__ptrdiff_t,
32923 _swigt__p_int,
32924 _swigt__p_wxSize,
32925 _swigt__p_wxClipboard,
32926 _swigt__p_wxStopWatch,
32927 _swigt__p_wxDC,
32928 _swigt__p_wxClipboardLocker,
32929 _swigt__p_wxIcon,
32930 _swigt__p_wxLogStderr,
32931 _swigt__p_wxLogTextCtrl,
32932 _swigt__p_wxTextCtrl,
32933 _swigt__p_wxBusyCursor,
32934 _swigt__p_wxBitmapDataObject,
32935 _swigt__p_wxTextDataObject,
32936 _swigt__p_wxDataObject,
32937 _swigt__p_wxPyTextDataObject,
32938 _swigt__p_wxPyBitmapDataObject,
32939 _swigt__p_wxFileDataObject,
32940 _swigt__p_wxCustomDataObject,
32941 _swigt__p_wxURLDataObject,
32942 _swigt__p_wxMetafileDataObject,
32943 _swigt__p_wxSound,
32944 _swigt__p_wxTimerRunner,
32945 _swigt__p_wxLogWindow,
32946 _swigt__p_wxTimeSpan,
32947 _swigt__p_wxArrayString,
32948 _swigt__p_wxWindowDisabler,
32949 _swigt__p_form_ops_t,
32950 _swigt__p_wxToolTip,
32951 _swigt__p_wxDataObjectComposite,
32952 _swigt__p_wxSystemSettings,
32953 _swigt__p_wxFileConfig,
32954 _swigt__p_wxVideoMode,
32955 _swigt__p_wxDataObjectSimple,
32956 _swigt__p_wxPyDataObjectSimple,
32957 _swigt__p_wxDuplexMode,
32958 _swigt__p_wxEvtHandler,
32959 _swigt__p_wxRect,
32960 _swigt__p_char,
32961 _swigt__p_wxSingleInstanceChecker,
32962 _swigt__p_wxStandardPaths,
32963 _swigt__p_wxFileTypeInfo,
32964 _swigt__p_wxFrame,
32965 _swigt__p_wxTimer,
32966 _swigt__p_wxPaperSize,
32967 _swigt__p_wxMimeTypesManager,
32968 _swigt__p_wxPyArtProvider,
32969 _swigt__p_wxPyTipProvider,
32970 _swigt__p_wxTipProvider,
32971 _swigt__p_wxJoystick,
32972 _swigt__p_wxSystemOptions,
32973 _swigt__p_wxPoint,
32974 _swigt__p_wxJoystickEvent,
32975 _swigt__p_wxCursor,
32976 _swigt__p_wxObject,
32977 _swigt__p_wxOutputStream,
32978 _swigt__p_wxDateTime,
32979 _swigt__p_wxPyDropSource,
32980 _swigt__p_unsigned_long,
32981 _swigt__p_wxKillError,
32982 _swigt__p_wxWindow,
32983 _swigt__p_wxString,
32984 _swigt__p_wxPyProcess,
32985 _swigt__p_wxBitmap,
32986 _swigt__p_wxConfig,
32987 _swigt__unsigned_int,
32988 _swigt__p_unsigned_int,
32989 _swigt__p_unsigned_char,
32990 _swigt__p_wxChar,
32991 _swigt__p_wxBusyInfo,
32992 _swigt__p_wxPyDropTarget,
32993 _swigt__p_wxPyTextDropTarget,
32994 _swigt__p_wxPyFileDropTarget,
32995 _swigt__p_wxProcessEvent,
32996 _swigt__p_wxPyLog,
32997 _swigt__p_wxLogNull,
32998 _swigt__p_wxColour,
32999 _swigt__p_wxPyTimer,
33000 _swigt__p_wxConfigPathChanger,
33001 _swigt__p_wxDateSpan,
33002 0
33003 };
33004
33005
33006 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33007
33008 static swig_const_info swig_const_table[] = {
33009 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33010 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33011 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33012 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33013 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33014 {0, 0, 0, 0.0, 0, 0}};
33015
33016 #ifdef __cplusplus
33017 }
33018 #endif
33019
33020
33021 #ifdef __cplusplus
33022 extern "C" {
33023 #endif
33024
33025 /* Python-specific SWIG API */
33026 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33027 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33028 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33029
33030 /* -----------------------------------------------------------------------------
33031 * global variable support code.
33032 * ----------------------------------------------------------------------------- */
33033
33034 typedef struct swig_globalvar {
33035 char *name; /* Name of global variable */
33036 PyObject *(*get_attr)(); /* Return the current value */
33037 int (*set_attr)(PyObject *); /* Set the value */
33038 struct swig_globalvar *next;
33039 } swig_globalvar;
33040
33041 typedef struct swig_varlinkobject {
33042 PyObject_HEAD
33043 swig_globalvar *vars;
33044 } swig_varlinkobject;
33045
33046 static PyObject *
33047 swig_varlink_repr(swig_varlinkobject *v) {
33048 v = v;
33049 return PyString_FromString("<Swig global variables>");
33050 }
33051
33052 static int
33053 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33054 swig_globalvar *var;
33055 flags = flags;
33056 fprintf(fp,"Swig global variables { ");
33057 for (var = v->vars; var; var=var->next) {
33058 fprintf(fp,"%s", var->name);
33059 if (var->next) fprintf(fp,", ");
33060 }
33061 fprintf(fp," }\n");
33062 return 0;
33063 }
33064
33065 static PyObject *
33066 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33067 swig_globalvar *var = v->vars;
33068 while (var) {
33069 if (strcmp(var->name,n) == 0) {
33070 return (*var->get_attr)();
33071 }
33072 var = var->next;
33073 }
33074 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33075 return NULL;
33076 }
33077
33078 static int
33079 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33080 swig_globalvar *var = v->vars;
33081 while (var) {
33082 if (strcmp(var->name,n) == 0) {
33083 return (*var->set_attr)(p);
33084 }
33085 var = var->next;
33086 }
33087 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33088 return 1;
33089 }
33090
33091 static PyTypeObject varlinktype = {
33092 PyObject_HEAD_INIT(0)
33093 0, /* Number of items in variable part (ob_size) */
33094 (char *)"swigvarlink", /* Type name (tp_name) */
33095 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33096 0, /* Itemsize (tp_itemsize) */
33097 0, /* Deallocator (tp_dealloc) */
33098 (printfunc) swig_varlink_print, /* Print (tp_print) */
33099 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33100 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33101 0, /* tp_compare */
33102 (reprfunc) swig_varlink_repr, /* tp_repr */
33103 0, /* tp_as_number */
33104 0, /* tp_as_sequence */
33105 0, /* tp_as_mapping */
33106 0, /* tp_hash */
33107 0, /* tp_call */
33108 0, /* tp_str */
33109 0, /* tp_getattro */
33110 0, /* tp_setattro */
33111 0, /* tp_as_buffer */
33112 0, /* tp_flags */
33113 0, /* tp_doc */
33114 #if PY_VERSION_HEX >= 0x02000000
33115 0, /* tp_traverse */
33116 0, /* tp_clear */
33117 #endif
33118 #if PY_VERSION_HEX >= 0x02010000
33119 0, /* tp_richcompare */
33120 0, /* tp_weaklistoffset */
33121 #endif
33122 #if PY_VERSION_HEX >= 0x02020000
33123 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33124 #endif
33125 #if PY_VERSION_HEX >= 0x02030000
33126 0, /* tp_del */
33127 #endif
33128 #ifdef COUNT_ALLOCS
33129 0,0,0,0 /* tp_alloc -> tp_next */
33130 #endif
33131 };
33132
33133 /* Create a variable linking object for use later */
33134 static PyObject *
33135 SWIG_Python_newvarlink(void) {
33136 swig_varlinkobject *result = 0;
33137 result = PyMem_NEW(swig_varlinkobject,1);
33138 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33139 result->ob_type = &varlinktype;
33140 result->vars = 0;
33141 result->ob_refcnt = 0;
33142 Py_XINCREF((PyObject *) result);
33143 return ((PyObject*) result);
33144 }
33145
33146 static void
33147 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33148 swig_varlinkobject *v;
33149 swig_globalvar *gv;
33150 v= (swig_varlinkobject *) p;
33151 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33152 gv->name = (char *) malloc(strlen(name)+1);
33153 strcpy(gv->name,name);
33154 gv->get_attr = get_attr;
33155 gv->set_attr = set_attr;
33156 gv->next = v->vars;
33157 v->vars = gv;
33158 }
33159
33160 /* -----------------------------------------------------------------------------
33161 * constants/methods manipulation
33162 * ----------------------------------------------------------------------------- */
33163
33164 /* Install Constants */
33165 static void
33166 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33167 PyObject *obj = 0;
33168 size_t i;
33169 for (i = 0; constants[i].type; i++) {
33170 switch(constants[i].type) {
33171 case SWIG_PY_INT:
33172 obj = PyInt_FromLong(constants[i].lvalue);
33173 break;
33174 case SWIG_PY_FLOAT:
33175 obj = PyFloat_FromDouble(constants[i].dvalue);
33176 break;
33177 case SWIG_PY_STRING:
33178 if (constants[i].pvalue) {
33179 obj = PyString_FromString((char *) constants[i].pvalue);
33180 } else {
33181 Py_INCREF(Py_None);
33182 obj = Py_None;
33183 }
33184 break;
33185 case SWIG_PY_POINTER:
33186 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33187 break;
33188 case SWIG_PY_BINARY:
33189 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33190 break;
33191 default:
33192 obj = 0;
33193 break;
33194 }
33195 if (obj) {
33196 PyDict_SetItemString(d,constants[i].name,obj);
33197 Py_DECREF(obj);
33198 }
33199 }
33200 }
33201
33202 /* -----------------------------------------------------------------------------*/
33203 /* Fix SwigMethods to carry the callback ptrs when needed */
33204 /* -----------------------------------------------------------------------------*/
33205
33206 static void
33207 SWIG_Python_FixMethods(PyMethodDef *methods,
33208 swig_const_info *const_table,
33209 swig_type_info **types,
33210 swig_type_info **types_initial) {
33211 size_t i;
33212 for (i = 0; methods[i].ml_name; ++i) {
33213 char *c = methods[i].ml_doc;
33214 if (c && (c = strstr(c, "swig_ptr: "))) {
33215 int j;
33216 swig_const_info *ci = 0;
33217 char *name = c + 10;
33218 for (j = 0; const_table[j].type; j++) {
33219 if (strncmp(const_table[j].name, name,
33220 strlen(const_table[j].name)) == 0) {
33221 ci = &(const_table[j]);
33222 break;
33223 }
33224 }
33225 if (ci) {
33226 size_t shift = (ci->ptype) - types;
33227 swig_type_info *ty = types_initial[shift];
33228 size_t ldoc = (c - methods[i].ml_doc);
33229 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33230 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33231 char *buff = ndoc;
33232 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33233 strncpy(buff, methods[i].ml_doc, ldoc);
33234 buff += ldoc;
33235 strncpy(buff, "swig_ptr: ", 10);
33236 buff += 10;
33237 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33238 methods[i].ml_doc = ndoc;
33239 }
33240 }
33241 }
33242 }
33243
33244 /* -----------------------------------------------------------------------------*
33245 * Initialize type list
33246 * -----------------------------------------------------------------------------*/
33247
33248 #if PY_MAJOR_VERSION < 2
33249 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33250 is copied out of Python/modsupport.c in python version 2.3.4 */
33251 static int
33252 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33253 {
33254 PyObject *dict;
33255 if (!PyModule_Check(m)) {
33256 PyErr_SetString(PyExc_TypeError,
33257 "PyModule_AddObject() needs module as first arg");
33258 return -1;
33259 }
33260 if (!o) {
33261 PyErr_SetString(PyExc_TypeError,
33262 "PyModule_AddObject() needs non-NULL value");
33263 return -1;
33264 }
33265
33266 dict = PyModule_GetDict(m);
33267 if (dict == NULL) {
33268 /* Internal error -- modules must have a dict! */
33269 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33270 PyModule_GetName(m));
33271 return -1;
33272 }
33273 if (PyDict_SetItemString(dict, name, o))
33274 return -1;
33275 Py_DECREF(o);
33276 return 0;
33277 }
33278 #endif
33279
33280 static swig_type_info **
33281 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33282 static PyMethodDef swig_empty_runtime_method_table[] = {
33283 {
33284 NULL, NULL, 0, NULL
33285 }
33286 };/* Sentinel */
33287
33288 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33289 swig_empty_runtime_method_table);
33290 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33291 if (pointer && module) {
33292 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33293 }
33294 return type_list_handle;
33295 }
33296
33297 static swig_type_info **
33298 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33299 swig_type_info **type_pointer;
33300
33301 /* first check if module already created */
33302 type_pointer = SWIG_Python_GetTypeListHandle();
33303 if (type_pointer) {
33304 return type_pointer;
33305 } else {
33306 /* create a new module and variable */
33307 return SWIG_Python_SetTypeListHandle(type_list_handle);
33308 }
33309 }
33310
33311 #ifdef __cplusplus
33312 }
33313 #endif
33314
33315 /* -----------------------------------------------------------------------------*
33316 * Partial Init method
33317 * -----------------------------------------------------------------------------*/
33318
33319 #ifdef SWIG_LINK_RUNTIME
33320 #ifdef __cplusplus
33321 extern "C"
33322 #endif
33323 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33324 #endif
33325
33326 #ifdef __cplusplus
33327 extern "C"
33328 #endif
33329 SWIGEXPORT(void) SWIG_init(void) {
33330 static PyObject *SWIG_globals = 0;
33331 static int typeinit = 0;
33332 PyObject *m, *d;
33333 int i;
33334 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33335
33336 /* Fix SwigMethods to carry the callback ptrs when needed */
33337 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33338
33339 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33340 d = PyModule_GetDict(m);
33341
33342 if (!typeinit) {
33343 #ifdef SWIG_LINK_RUNTIME
33344 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33345 #else
33346 # ifndef SWIG_STATIC_RUNTIME
33347 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33348 # endif
33349 #endif
33350 for (i = 0; swig_types_initial[i]; i++) {
33351 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33352 }
33353 typeinit = 1;
33354 }
33355 SWIG_InstallConstants(d,swig_const_table);
33356
33357 {
33358 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33359 }
33360 {
33361 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33362 }
33363 {
33364 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33365 }
33366 {
33367 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33368 }
33369 {
33370 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33371 }
33372 {
33373 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33374 }
33375 {
33376 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33377 }
33378 {
33379 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33380 }
33381 {
33382 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33383 }
33384 {
33385 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33386 }
33387 {
33388 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33389 }
33390 {
33391 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33392 }
33393 {
33394 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33413 }
33414 {
33415 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33416 }
33417 {
33418 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33419 }
33420 {
33421 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33422 }
33423 {
33424 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33425 }
33426 {
33427 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33428 }
33429 {
33430 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33431 }
33432 {
33433 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33629 }
33630 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33631 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33632 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33633 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33634 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33635 {
33636 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33646 }
33647 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33648
33649 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33650
33651 {
33652 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33683 }
33684 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33685 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33686 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33687 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33688 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33689 {
33690 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33781 }
33782 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33783 {
33784 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33797 }
33798
33799 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33800
33801 {
33802 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33821 }
33822 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33823 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33824 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33825 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33826 {
33827 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33828 }
33829 {
33830 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33831 }
33832 {
33833 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33834 }
33835 {
33836 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33837 }
33838 {
33839 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33840 }
33841 {
33842 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33843 }
33844 {
33845 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33846 }
33847 {
33848 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33849 }
33850 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33851 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33852 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33853 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33854 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33855 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33856 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33857 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33858 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33859 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33860 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33861 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33862 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33863 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33864 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33865 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33866 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33867 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33868 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33869 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33870 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33871 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33872 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33873 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33874 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33875 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33876 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33877 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33878 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33879 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33880 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33881 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33882 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33883 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33884 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33885 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33886 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33887 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33888 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33889 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33890 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33891 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33892 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33893 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33894 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33895 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33896 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33897 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33898 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33899 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33900 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33901 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33902 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33903 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33904 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33905 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33906
33907 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33908
33909 {
33910 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33935 }
33936 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33937 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33938 {
33939 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33940 }
33941 {
33942 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33943 }
33944 {
33945 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33946 }
33947 {
33948 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33949 }
33950 {
33951 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33976 }
33977 {
33978 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33985 }
33986 {
33987 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33988 }
33989 {
33990 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33991 }
33992 {
33993 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33994 }
33995 {
33996 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33997 }
33998 {
33999 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34000 }
34001 {
34002 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34003 }
34004 {
34005 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34006 }
34007 {
34008 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34009 }
34010 {
34011 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34012 }
34013 {
34014 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34129 }
34130 {
34131 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34132 }
34133 {
34134 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34135 }
34136 {
34137 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34138 }
34139 {
34140 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34141 }
34142 {
34143 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34144 }
34145 {
34146 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34147 }
34148 {
34149 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34150 }
34151 {
34152 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34153 }
34154 {
34155 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34156 }
34157 {
34158 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34159 }
34160 {
34161 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34162 }
34163 {
34164 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34165 }
34166 {
34167 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34168 }
34169 {
34170 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34171 }
34172 {
34173 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34174 }
34175 {
34176 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34177 }
34178 {
34179 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34180 }
34181 {
34182 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34183 }
34184 {
34185 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34186 }
34187 {
34188 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34189 }
34190 {
34191 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34192 }
34193 {
34194 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34195 }
34196 {
34197 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34198 }
34199 {
34200 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34201 }
34202 {
34203 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34204 }
34205 {
34206 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34207 }
34208 {
34209 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34210 }
34211 {
34212 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34213 }
34214 {
34215 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34216 }
34217 {
34218 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34219 }
34220 {
34221 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34222 }
34223 {
34224 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34225 }
34226 {
34227 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34228 }
34229 {
34230 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34231 }
34232 {
34233 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34234 }
34235 {
34236 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34237 }
34238 {
34239 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34240 }
34241 {
34242 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34243 }
34244 {
34245 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34246 }
34247 {
34248 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34249 }
34250 {
34251 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34252 }
34253 {
34254 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34255 }
34256 {
34257 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34258 }
34259 {
34260 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34261 }
34262 {
34263 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34264 }
34265 {
34266 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34267 }
34268 {
34269 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34297 }
34298 {
34299 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34300 }
34301 {
34302 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34303 }
34304 {
34305 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34306 }
34307 {
34308 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34309 }
34310 {
34311 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34312 }
34313 {
34314 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34315 }
34316 {
34317 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34318 }
34319 {
34320 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34321 }
34322 {
34323 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34324 }
34325 {
34326 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34327 }
34328 {
34329 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34330 }
34331 {
34332 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34333 }
34334 {
34335 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34336 }
34337 {
34338 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34339 }
34340 {
34341 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34342 }
34343 {
34344 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34345 }
34346 {
34347 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34348 }
34349 {
34350 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34351 }
34352 {
34353 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34354 }
34355 {
34356 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34357 }
34358 {
34359 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34360 }
34361 {
34362 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34363 }
34364 {
34365 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34366 }
34367 {
34368 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34369 }
34370 {
34371 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34372 }
34373 {
34374 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34375 }
34376 {
34377 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34378 }
34379 {
34380 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34381 }
34382 {
34383 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34384 }
34385 {
34386 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34387 }
34388 {
34389 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34390 }
34391 {
34392 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34393 }
34394 {
34395 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34396 }
34397 {
34398 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34399 }
34400 {
34401 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34402 }
34403 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34404 {
34405 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34406 }
34407 {
34408 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34409 }
34410 {
34411 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34412 }
34413 {
34414 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34415 }
34416 {
34417 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34418 }
34419 {
34420 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34421 }
34422 {
34423 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34424 }
34425 {
34426 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34439 }
34440 {
34441 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34442 }
34443 {
34444 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34445 }
34446 {
34447 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34448 }
34449 {
34450 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34451 }
34452 {
34453 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34454 }
34455 {
34456 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34457 }
34458 {
34459 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34460 }
34461 {
34462 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34463 }
34464 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34465 {
34466 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34467 }
34468 {
34469 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34470 }
34471 {
34472 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34473 }
34474 {
34475 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34476 }
34477 {
34478 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34479 }
34480 {
34481 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34482 }
34483 {
34484 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34485 }
34486 {
34487 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34488 }
34489 {
34490 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34491 }
34492 {
34493 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34494 }
34495 {
34496 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34497 }
34498 {
34499 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34500 }
34501
34502 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34503 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34504 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34505 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34506
34507 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34508 }
34509
wxWidgets (Impactor)