]> 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
bug fixes for using wxTransientPopupWindow and wxDP_ALLOWNONE support from Andreas...
[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_wxClipboardLocker swig_types[22]
1364 #define SWIGTYPE_p_wxIcon swig_types[23]
1365 #define SWIGTYPE_p_wxLogStderr swig_types[24]
1366 #define SWIGTYPE_p_wxLogTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxBusyCursor swig_types[27]
1369 #define SWIGTYPE_p_wxBitmapDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxTextDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyTextDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxFileDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxURLDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxMetafileDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxSound swig_types[37]
1379 #define SWIGTYPE_p_wxTimerRunner swig_types[38]
1380 #define SWIGTYPE_p_wxLogWindow swig_types[39]
1381 #define SWIGTYPE_p_wxTimeSpan swig_types[40]
1382 #define SWIGTYPE_p_wxArrayString swig_types[41]
1383 #define SWIGTYPE_p_wxWindowDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxToolTip swig_types[44]
1386 #define SWIGTYPE_p_wxDataObjectComposite swig_types[45]
1387 #define SWIGTYPE_p_wxFileConfig swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxVideoMode swig_types[48]
1390 #define SWIGTYPE_p_wxDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxDuplexMode swig_types[51]
1393 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
1394 #define SWIGTYPE_p_wxRect swig_types[53]
1395 #define SWIGTYPE_p_char swig_types[54]
1396 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[55]
1397 #define SWIGTYPE_p_wxStandardPaths swig_types[56]
1398 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
1399 #define SWIGTYPE_p_wxFrame swig_types[58]
1400 #define SWIGTYPE_p_wxTimer swig_types[59]
1401 #define SWIGTYPE_p_wxPaperSize swig_types[60]
1402 #define SWIGTYPE_p_wxMimeTypesManager swig_types[61]
1403 #define SWIGTYPE_p_wxPyArtProvider swig_types[62]
1404 #define SWIGTYPE_p_wxPyTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxJoystick swig_types[65]
1407 #define SWIGTYPE_p_wxSystemOptions swig_types[66]
1408 #define SWIGTYPE_p_wxPoint swig_types[67]
1409 #define SWIGTYPE_p_wxJoystickEvent swig_types[68]
1410 #define SWIGTYPE_p_wxCursor swig_types[69]
1411 #define SWIGTYPE_p_wxObject swig_types[70]
1412 #define SWIGTYPE_p_wxOutputStream swig_types[71]
1413 #define SWIGTYPE_p_wxDateTime swig_types[72]
1414 #define SWIGTYPE_p_wxPyDropSource swig_types[73]
1415 #define SWIGTYPE_p_unsigned_long swig_types[74]
1416 #define SWIGTYPE_p_wxKillError swig_types[75]
1417 #define SWIGTYPE_p_wxWindow swig_types[76]
1418 #define SWIGTYPE_p_wxString swig_types[77]
1419 #define SWIGTYPE_p_wxPyProcess swig_types[78]
1420 #define SWIGTYPE_p_wxBitmap swig_types[79]
1421 #define SWIGTYPE_p_wxConfig swig_types[80]
1422 #define SWIGTYPE_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_char swig_types[83]
1425 #define SWIGTYPE_p_wxChar swig_types[84]
1426 #define SWIGTYPE_p_wxBusyInfo swig_types[85]
1427 #define SWIGTYPE_p_wxPyDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxProcessEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPyLog swig_types[90]
1432 #define SWIGTYPE_p_wxLogNull swig_types[91]
1433 #define SWIGTYPE_p_wxColour swig_types[92]
1434 #define SWIGTYPE_p_wxPyTimer swig_types[93]
1435 #define SWIGTYPE_p_wxConfigPathChanger swig_types[94]
1436 #define SWIGTYPE_p_wxDateSpan swig_types[95]
1437 static swig_type_info *swig_types[97];
1438
1439 /* -------- TYPES TABLE (END) -------- */
1440
1441
1442 /*-----------------------------------------------
1443 @(target):= _misc_.so
1444 ------------------------------------------------*/
1445 #define SWIG_init init_misc_
1446
1447 #define SWIG_name "_misc_"
1448
1449 #include "wx/wxPython/wxPython.h"
1450 #include "wx/wxPython/pyclasses.h"
1451 #include "wx/wxPython/pyistream.h"
1452
1453 static const wxString wxPyEmptyString(wxEmptyString);
1454
1455
1456
1457 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1458 #define SWIG_From_int PyInt_FromLong
1459 /*@@*/
1460
1461
1462 #include <limits.h>
1463
1464
1465 SWIGINTERN int
1466 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1467 const char *errmsg)
1468 {
1469 if (value < min_value) {
1470 if (errmsg) {
1471 PyErr_Format(PyExc_OverflowError,
1472 "value %ld is less than '%s' minimum %ld",
1473 value, errmsg, min_value);
1474 }
1475 return 0;
1476 } else if (value > max_value) {
1477 if (errmsg) {
1478 PyErr_Format(PyExc_OverflowError,
1479 "value %ld is greater than '%s' maximum %ld",
1480 value, errmsg, max_value);
1481 }
1482 return 0;
1483 }
1484 return 1;
1485 }
1486
1487
1488 SWIGINTERN int
1489 SWIG_AsVal_long(PyObject* obj, long* val)
1490 {
1491 if (PyNumber_Check(obj)) {
1492 if (val) *val = PyInt_AsLong(obj);
1493 return 1;
1494 }
1495 else {
1496 SWIG_type_error("number", obj);
1497 }
1498 return 0;
1499 }
1500
1501
1502 #if INT_MAX != LONG_MAX
1503 SWIGINTERN int
1504 SWIG_AsVal_int(PyObject *obj, int *val)
1505 {
1506 const char* errmsg = val ? "int" : (char*)0;
1507 long v;
1508 if (SWIG_AsVal_long(obj, &v)) {
1509 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1510 if (val) *val = (int)(v);
1511 return 1;
1512 } else {
1513 return 0;
1514 }
1515 } else {
1516 PyErr_Clear();
1517 }
1518 if (val) {
1519 SWIG_type_error(errmsg, obj);
1520 }
1521 return 0;
1522 }
1523 #else
1524 SWIGINTERNSHORT int
1525 SWIG_AsVal_int(PyObject *obj, int *val)
1526 {
1527 return SWIG_AsVal_long(obj,(long*)val);
1528 }
1529 #endif
1530
1531
1532 SWIGINTERNSHORT int
1533 SWIG_As_int(PyObject* obj)
1534 {
1535 int v;
1536 if (!SWIG_AsVal_int(obj, &v)) {
1537 /*
1538 this is needed to make valgrind/purify happier.
1539 */
1540 memset((void*)&v, 0, sizeof(int));
1541 }
1542 return v;
1543 }
1544
1545
1546 SWIGINTERNSHORT int
1547 SWIG_Check_int(PyObject* obj)
1548 {
1549 return SWIG_AsVal_int(obj, (int*)0);
1550 }
1551
1552 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1553
1554 #include <wx/stockitem.h>
1555
1556 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1557 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1558 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1559
1560 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1561 #define SWIG_From_long PyInt_FromLong
1562 /*@@*/
1563
1564
1565 SWIGINTERNSHORT long
1566 SWIG_As_long(PyObject* obj)
1567 {
1568 long v;
1569 if (!SWIG_AsVal_long(obj, &v)) {
1570 /*
1571 this is needed to make valgrind/purify happier.
1572 */
1573 memset((void*)&v, 0, sizeof(long));
1574 }
1575 return v;
1576 }
1577
1578
1579 SWIGINTERNSHORT int
1580 SWIG_Check_long(PyObject* obj)
1581 {
1582 return SWIG_AsVal_long(obj, (long*)0);
1583 }
1584
1585
1586 SWIGINTERN int
1587 SWIG_AsVal_bool(PyObject *obj, bool *val)
1588 {
1589 if (obj == Py_True) {
1590 if (val) *val = true;
1591 return 1;
1592 }
1593 if (obj == Py_False) {
1594 if (val) *val = false;
1595 return 1;
1596 }
1597 int res = 0;
1598 if (SWIG_AsVal_int(obj, &res)) {
1599 if (val) *val = res ? true : false;
1600 return 1;
1601 } else {
1602 PyErr_Clear();
1603 }
1604 if (val) {
1605 SWIG_type_error("bool", obj);
1606 }
1607 return 0;
1608 }
1609
1610
1611 SWIGINTERNSHORT bool
1612 SWIG_As_bool(PyObject* obj)
1613 {
1614 bool v;
1615 if (!SWIG_AsVal_bool(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(bool));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_bool(PyObject* obj)
1627 {
1628 return SWIG_AsVal_bool(obj, (bool*)0);
1629 }
1630
1631
1632 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1633 PyObject* o2;
1634 PyObject* o3;
1635
1636 if (!target) {
1637 target = o;
1638 } else if (target == Py_None) {
1639 Py_DECREF(Py_None);
1640 target = o;
1641 } else {
1642 if (!PyTuple_Check(target)) {
1643 o2 = target;
1644 target = PyTuple_New(1);
1645 PyTuple_SetItem(target, 0, o2);
1646 }
1647 o3 = PyTuple_New(1);
1648 PyTuple_SetItem(o3, 0, o);
1649
1650 o2 = target;
1651 target = PySequence_Concat(o2, o3);
1652 Py_DECREF(o2);
1653 Py_DECREF(o3);
1654 }
1655 return target;
1656 }
1657
1658
1659
1660 SWIGINTERN int
1661 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1662 {
1663 long v = 0;
1664 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1665 SWIG_type_error("unsigned number", obj);
1666 }
1667 else if (val)
1668 *val = (unsigned long)v;
1669 return 1;
1670 }
1671
1672
1673 SWIGINTERNSHORT unsigned long
1674 SWIG_As_unsigned_SS_long(PyObject* obj)
1675 {
1676 unsigned long v;
1677 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1678 /*
1679 this is needed to make valgrind/purify happier.
1680 */
1681 memset((void*)&v, 0, sizeof(unsigned long));
1682 }
1683 return v;
1684 }
1685
1686
1687 SWIGINTERNSHORT int
1688 SWIG_Check_unsigned_SS_long(PyObject* obj)
1689 {
1690 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1691 }
1692
1693
1694 SWIGINTERNSHORT PyObject*
1695 SWIG_From_unsigned_SS_long(unsigned long value)
1696 {
1697 return (value > LONG_MAX) ?
1698 PyLong_FromUnsignedLong(value)
1699 : PyInt_FromLong((long)(value));
1700 }
1701
1702
1703 bool wxThread_IsMain() {
1704 #ifdef WXP_WITH_THREAD
1705 return wxThread::IsMain();
1706 #else
1707 return true;
1708 #endif
1709 }
1710
1711 static void wxCaret_Destroy(wxCaret *self){
1712 delete self;
1713 }
1714
1715 #include <wx/snglinst.h>
1716
1717
1718 #include <wx/tipdlg.h>
1719
1720
1721 class wxPyTipProvider : public wxTipProvider {
1722 public:
1723 wxPyTipProvider(size_t currentTip)
1724 : wxTipProvider(currentTip) {}
1725
1726 DEC_PYCALLBACK_STRING__pure(GetTip);
1727 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1728 PYPRIVATE;
1729 };
1730
1731 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1732 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1733
1734
1735 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1736
1737 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1738
1739 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1740 : wxTimer(owner, id)
1741 {
1742 if (owner == NULL) SetOwner(this);
1743 }
1744
1745
1746 void wxPyTimer::Notify() {
1747 bool found;
1748 bool blocked = wxPyBeginBlockThreads();
1749 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1750 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1751 wxPyEndBlockThreads(blocked);
1752 if (! found)
1753 wxTimer::Notify();
1754 }
1755 void wxPyTimer::base_Notify() {
1756 wxTimer::Notify();
1757 }
1758
1759
1760
1761 SWIGINTERN PyObject *
1762 SWIG_FromCharPtr(const char* cptr)
1763 {
1764 if (cptr) {
1765 size_t size = strlen(cptr);
1766 if (size > INT_MAX) {
1767 return SWIG_NewPointerObj((char*)(cptr),
1768 SWIG_TypeQuery("char *"), 0);
1769 } else {
1770 if (size != 0) {
1771 return PyString_FromStringAndSize(cptr, size);
1772 } else {
1773 return PyString_FromString(cptr);
1774 }
1775 }
1776 }
1777 Py_INCREF(Py_None);
1778 return Py_None;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_CheckUnsignedLongInRange(unsigned long value,
1784 unsigned long max_value,
1785 const char *errmsg)
1786 {
1787 if (value > max_value) {
1788 if (errmsg) {
1789 PyErr_Format(PyExc_OverflowError,
1790 "value %lu is greater than '%s' minimum %lu",
1791 value, errmsg, max_value);
1792 }
1793 return 0;
1794 }
1795 return 1;
1796 }
1797
1798
1799 #if UINT_MAX != ULONG_MAX
1800 SWIGINTERN int
1801 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1802 {
1803 const char* errmsg = val ? "unsigned int" : (char*)0;
1804 unsigned long v;
1805 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1806 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1807 if (val) *val = (unsigned int)(v);
1808 return 1;
1809 }
1810 } else {
1811 PyErr_Clear();
1812 }
1813 if (val) {
1814 SWIG_type_error(errmsg, obj);
1815 }
1816 return 0;
1817 }
1818 #else
1819 SWIGINTERNSHORT unsigned int
1820 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1821 {
1822 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1823 }
1824 #endif
1825
1826
1827 SWIGINTERNSHORT unsigned int
1828 SWIG_As_unsigned_SS_int(PyObject* obj)
1829 {
1830 unsigned int v;
1831 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1832 /*
1833 this is needed to make valgrind/purify happier.
1834 */
1835 memset((void*)&v, 0, sizeof(unsigned int));
1836 }
1837 return v;
1838 }
1839
1840
1841 SWIGINTERNSHORT int
1842 SWIG_Check_unsigned_SS_int(PyObject* obj)
1843 {
1844 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1845 }
1846
1847 static wxString Log_TimeStamp(){
1848 wxString msg;
1849 wxLog::TimeStamp(&msg);
1850 return msg;
1851 }
1852 static void wxLog_Destroy(wxLog *self){ delete self; }
1853 // Make somce wrappers that double any % signs so they are 'escaped'
1854 void wxPyLogFatalError(const wxString& msg)
1855 {
1856 wxString m(msg);
1857 m.Replace(wxT("%"), wxT("%%"));
1858 wxLogFatalError(m);
1859 }
1860
1861 void wxPyLogError(const wxString& msg)
1862 {
1863 wxString m(msg);
1864 m.Replace(wxT("%"), wxT("%%"));
1865 wxLogError(m);
1866 }
1867
1868 void wxPyLogWarning(const wxString& msg)
1869 {
1870 wxString m(msg);
1871 m.Replace(wxT("%"), wxT("%%"));
1872 wxLogWarning(m);
1873 }
1874
1875 void wxPyLogMessage(const wxString& msg)
1876 {
1877 wxString m(msg);
1878 m.Replace(wxT("%"), wxT("%%"));
1879 wxLogMessage(m);
1880 }
1881
1882 void wxPyLogInfo(const wxString& msg)
1883 {
1884 wxString m(msg);
1885 m.Replace(wxT("%"), wxT("%%"));
1886 wxLogInfo(m);
1887 }
1888
1889 void wxPyLogDebug(const wxString& msg)
1890 {
1891 wxString m(msg);
1892 m.Replace(wxT("%"), wxT("%%"));
1893 wxLogDebug(m);
1894 }
1895
1896 void wxPyLogVerbose(const wxString& msg)
1897 {
1898 wxString m(msg);
1899 m.Replace(wxT("%"), wxT("%%"));
1900 wxLogVerbose(m);
1901 }
1902
1903 void wxPyLogStatus(const wxString& msg)
1904 {
1905 wxString m(msg);
1906 m.Replace(wxT("%"), wxT("%%"));
1907 wxLogStatus(m);
1908 }
1909
1910 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1911 {
1912 wxString m(msg);
1913 m.Replace(wxT("%"), wxT("%%"));
1914 wxLogStatus(pFrame, m);
1915 }
1916
1917 void wxPyLogSysError(const wxString& msg)
1918 {
1919 wxString m(msg);
1920 m.Replace(wxT("%"), wxT("%%"));
1921 wxLogSysError(m);
1922 }
1923
1924 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1925 {
1926 wxString m(msg);
1927 m.Replace(wxT("%"), wxT("%%"));
1928 wxLogGeneric(level, m);
1929 }
1930
1931 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1932 {
1933 wxString m(msg);
1934 m.Replace(wxT("%"), wxT("%%"));
1935 wxLogTrace(mask, m);
1936 }
1937
1938 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1939 {
1940 wxString m(msg);
1941 m.Replace(wxT("%"), wxT("%%"));
1942 wxLogTrace(mask, m);
1943 }
1944
1945
1946
1947 // A wxLog class that can be derived from in wxPython
1948 class wxPyLog : public wxLog {
1949 public:
1950 wxPyLog() : wxLog() {}
1951
1952 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1953 bool found;
1954 bool blocked = wxPyBeginBlockThreads();
1955 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1956 PyObject* s = wx2PyString(szString);
1957 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1958 Py_DECREF(s);
1959 }
1960 wxPyEndBlockThreads(blocked);
1961 if (! found)
1962 wxLog::DoLog(level, szString, t);
1963 }
1964
1965 virtual void DoLogString(const wxChar *szString, time_t t) {
1966 bool found;
1967 bool blocked = wxPyBeginBlockThreads();
1968 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1969 PyObject* s = wx2PyString(szString);
1970 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1971 Py_DECREF(s);
1972 }
1973 wxPyEndBlockThreads(blocked);
1974 if (! found)
1975 wxLog::DoLogString(szString, t);
1976 }
1977
1978 PYPRIVATE;
1979 };
1980
1981
1982
1983
1984 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1985
1986
1987 #include <wx/joystick.h>
1988
1989
1990 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
1991 // A C++ stub class for wxJoystick for platforms that don't have it.
1992 class wxJoystick : public wxObject {
1993 public:
1994 wxJoystick(int joystick = wxJOYSTICK1) {
1995 bool blocked = wxPyBeginBlockThreads();
1996 PyErr_SetString(PyExc_NotImplementedError,
1997 "wxJoystick is not available on this platform.");
1998 wxPyEndBlockThreads(blocked);
1999 }
2000 wxPoint GetPosition() { return wxPoint(-1,-1); }
2001 int GetZPosition() { return -1; }
2002 int GetButtonState() { return -1; }
2003 int GetPOVPosition() { return -1; }
2004 int GetPOVCTSPosition() { return -1; }
2005 int GetRudderPosition() { return -1; }
2006 int GetUPosition() { return -1; }
2007 int GetVPosition() { return -1; }
2008 int GetMovementThreshold() { return -1; }
2009 void SetMovementThreshold(int threshold) {}
2010
2011 bool IsOk(void) { return false; }
2012 int GetNumberJoysticks() { return -1; }
2013 int GetManufacturerId() { return -1; }
2014 int GetProductId() { return -1; }
2015 wxString GetProductName() { return wxEmptyString; }
2016 int GetXMin() { return -1; }
2017 int GetYMin() { return -1; }
2018 int GetZMin() { return -1; }
2019 int GetXMax() { return -1; }
2020 int GetYMax() { return -1; }
2021 int GetZMax() { return -1; }
2022 int GetNumberButtons() { return -1; }
2023 int GetNumberAxes() { return -1; }
2024 int GetMaxButtons() { return -1; }
2025 int GetMaxAxes() { return -1; }
2026 int GetPollingMin() { return -1; }
2027 int GetPollingMax() { return -1; }
2028 int GetRudderMin() { return -1; }
2029 int GetRudderMax() { return -1; }
2030 int GetUMin() { return -1; }
2031 int GetUMax() { return -1; }
2032 int GetVMin() { return -1; }
2033 int GetVMax() { return -1; }
2034
2035 bool HasRudder() { return false; }
2036 bool HasZ() { return false; }
2037 bool HasU() { return false; }
2038 bool HasV() { return false; }
2039 bool HasPOV() { return false; }
2040 bool HasPOV4Dir() { return false; }
2041 bool HasPOVCTS() { return false; }
2042
2043 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2044 bool ReleaseCapture() { return false; }
2045 };
2046 #endif
2047
2048
2049 #include <wx/sound.h>
2050
2051
2052 #if !wxUSE_SOUND
2053 // A C++ stub class for wxWave for platforms that don't have it.
2054 class wxSound : public wxObject
2055 {
2056 public:
2057 wxSound() {
2058 bool blocked = wxPyBeginBlockThreads();
2059 PyErr_SetString(PyExc_NotImplementedError,
2060 "wxSound is not available on this platform.");
2061 wxPyEndBlockThreads(blocked);
2062 }
2063 wxSound(const wxString&/*, bool*/) {
2064 bool blocked = wxPyBeginBlockThreads();
2065 PyErr_SetString(PyExc_NotImplementedError,
2066 "wxSound is not available on this platform.");
2067 wxPyEndBlockThreads(blocked);
2068 }
2069 wxSound(int, const wxByte*) {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075
2076 ~wxSound() {};
2077
2078 bool Create(const wxString&/*, bool*/) { return false; }
2079 bool Create(int, const wxByte*) { return false; };
2080 bool IsOk() { return false; };
2081 bool Play(unsigned) const { return false; }
2082 static bool Play(const wxString&, unsigned) { return false; }
2083 static void Stop() {}
2084 };
2085
2086 #endif
2087
2088 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2089 if (fileName.Length() == 0)
2090 return new wxSound;
2091 else
2092 return new wxSound(fileName);
2093 }
2094 static wxSound *new_wxSound(PyObject *data){
2095 unsigned char* buffer; int size;
2096 wxSound *sound = NULL;
2097
2098 bool blocked = wxPyBeginBlockThreads();
2099 if (!PyArg_Parse(data, "t#", &buffer, &size))
2100 goto done;
2101 sound = new wxSound(size, buffer);
2102 done:
2103 wxPyEndBlockThreads(blocked);
2104 return sound;
2105 }
2106 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2107 #ifndef __WXMAC__
2108 unsigned char* buffer;
2109 int size;
2110 bool rv = false;
2111
2112 bool blocked = wxPyBeginBlockThreads();
2113 if (!PyArg_Parse(data, "t#", &buffer, &size))
2114 goto done;
2115 rv = self->Create(size, buffer);
2116 done:
2117 wxPyEndBlockThreads(blocked);
2118 return rv;
2119 #else
2120 bool blocked = wxPyBeginBlockThreads();
2121 PyErr_SetString(PyExc_NotImplementedError,
2122 "Create from data is not available on this platform.");
2123 wxPyEndBlockThreads(blocked);
2124 return false;
2125 #endif
2126 }
2127
2128 #include <wx/mimetype.h>
2129
2130 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2131 wxString str;
2132 if (self->GetMimeType(&str))
2133 return wx2PyString(str);
2134 else
2135 RETURN_NONE();
2136 }
2137 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2138 wxArrayString arr;
2139 if (self->GetMimeTypes(arr))
2140 return wxArrayString2PyList_helper(arr);
2141 else
2142 RETURN_NONE();
2143 }
2144 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2145 wxArrayString arr;
2146 if (self->GetExtensions(arr))
2147 return wxArrayString2PyList_helper(arr);
2148 else
2149 RETURN_NONE();
2150 }
2151 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2152 wxIconLocation loc;
2153 if (self->GetIcon(&loc))
2154 return new wxIcon(loc);
2155 else
2156 return NULL;
2157 }
2158 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2159 wxIconLocation loc;
2160 if (self->GetIcon(&loc)) {
2161 wxString iconFile = loc.GetFileName();
2162 int iconIndex = -1;
2163
2164 iconIndex = loc.GetIndex();
2165
2166 // Make a tuple and put the values in it
2167 bool blocked = wxPyBeginBlockThreads();
2168 PyObject* tuple = PyTuple_New(3);
2169 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2170 wxT("wxIcon"), true));
2171 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2172 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2173 wxPyEndBlockThreads(blocked);
2174 return tuple;
2175 }
2176 else
2177 RETURN_NONE();
2178 }
2179 static PyObject *wxFileType_GetDescription(wxFileType *self){
2180 wxString str;
2181 if (self->GetDescription(&str))
2182 return wx2PyString(str);
2183 else
2184 RETURN_NONE();
2185 }
2186 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2187 wxString str;
2188 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2189 return wx2PyString(str);
2190 else
2191 RETURN_NONE();
2192 }
2193 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2194 wxString str;
2195 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2196 return wx2PyString(str);
2197 else
2198 RETURN_NONE();
2199 }
2200 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2201 wxArrayString verbs;
2202 wxArrayString commands;
2203 if (self->GetAllCommands(&verbs, &commands,
2204 wxFileType::MessageParameters(filename, mimetype))) {
2205 bool blocked = wxPyBeginBlockThreads();
2206 PyObject* tuple = PyTuple_New(2);
2207 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2208 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2209 wxPyEndBlockThreads(blocked);
2210 return tuple;
2211 }
2212 else
2213 RETURN_NONE();
2214 }
2215 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2216 return wxFileType::ExpandCommand(command,
2217 wxFileType::MessageParameters(filename, mimetype));
2218 }
2219 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2220 wxArrayString arr;
2221 self->EnumAllFileTypes(arr);
2222 return wxArrayString2PyList_helper(arr);
2223 }
2224
2225 #include <wx/artprov.h>
2226
2227 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2228 static const wxString wxPyART_MENU(wxART_MENU);
2229 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2230 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2231 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2232 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2233 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2234 static const wxString wxPyART_OTHER(wxART_OTHER);
2235 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2236 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2237 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2238 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2239 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2240 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2241 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2242 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2243 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2244 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2245 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2246 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2247 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2248 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2249 static const wxString wxPyART_PRINT(wxART_PRINT);
2250 static const wxString wxPyART_HELP(wxART_HELP);
2251 static const wxString wxPyART_TIP(wxART_TIP);
2252 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2253 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2254 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2255 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2256 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2257 static const wxString wxPyART_CDROM(wxART_CDROM);
2258 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2259 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2260 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2261 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2262 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2263 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2264 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2265 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2266 static const wxString wxPyART_ERROR(wxART_ERROR);
2267 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2268 static const wxString wxPyART_WARNING(wxART_WARNING);
2269 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2270 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2271 // Python aware wxArtProvider
2272 class wxPyArtProvider : public wxArtProvider {
2273 public:
2274
2275 virtual wxBitmap CreateBitmap(const wxArtID& id,
2276 const wxArtClient& client,
2277 const wxSize& size) {
2278 wxBitmap rval = wxNullBitmap;
2279 bool blocked = wxPyBeginBlockThreads();
2280 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2281 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2282 PyObject* ro;
2283 wxBitmap* ptr;
2284 PyObject* s1, *s2;
2285 s1 = wx2PyString(id);
2286 s2 = wx2PyString(client);
2287 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2288 Py_DECREF(so);
2289 Py_DECREF(s1);
2290 Py_DECREF(s2);
2291 if (ro) {
2292 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2293 rval = *ptr;
2294 Py_DECREF(ro);
2295 }
2296 }
2297 wxPyEndBlockThreads(blocked);
2298 return rval;
2299 }
2300
2301 PYPRIVATE;
2302 };
2303
2304 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2305
2306
2307
2308 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2309 PyObject* ret = PyTuple_New(3);
2310 if (ret) {
2311 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2312 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2313 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2314 }
2315 return ret;
2316 }
2317
2318 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2319 bool cont;
2320 long index = 0;
2321 wxString value;
2322
2323 cont = self->GetFirstGroup(value, index);
2324 return __EnumerationHelper(cont, value, index);
2325 }
2326 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2327 bool cont;
2328 wxString value;
2329
2330 cont = self->GetNextGroup(value, index);
2331 return __EnumerationHelper(cont, value, index);
2332 }
2333 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2334 bool cont;
2335 long index = 0;
2336 wxString value;
2337
2338 cont = self->GetFirstEntry(value, index);
2339 return __EnumerationHelper(cont, value, index);
2340 }
2341 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2342 bool cont;
2343 wxString value;
2344
2345 cont = self->GetNextEntry(value, index);
2346 return __EnumerationHelper(cont, value, index);
2347 }
2348 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2349 long rv;
2350 self->Read(key, &rv, defaultVal);
2351 return rv;
2352 }
2353
2354 SWIGINTERN int
2355 SWIG_AsVal_double(PyObject *obj, double* val)
2356 {
2357 if (PyNumber_Check(obj)) {
2358 if (val) *val = PyFloat_AsDouble(obj);
2359 return 1;
2360 }
2361 else {
2362 SWIG_type_error("number", obj);
2363 }
2364 return 0;
2365 }
2366
2367
2368 SWIGINTERNSHORT double
2369 SWIG_As_double(PyObject* obj)
2370 {
2371 double v;
2372 if (!SWIG_AsVal_double(obj, &v)) {
2373 /*
2374 this is needed to make valgrind/purify happier.
2375 */
2376 memset((void*)&v, 0, sizeof(double));
2377 }
2378 return v;
2379 }
2380
2381
2382 SWIGINTERNSHORT int
2383 SWIG_Check_double(PyObject* obj)
2384 {
2385 return SWIG_AsVal_double(obj, (double*)0);
2386 }
2387
2388 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2389 double rv;
2390 self->Read(key, &rv, defaultVal);
2391 return rv;
2392 }
2393
2394 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2395 #define SWIG_From_double PyFloat_FromDouble
2396 /*@@*/
2397
2398 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2399 bool rv;
2400 self->Read(key, &rv, defaultVal);
2401 return rv;
2402 }
2403
2404 #include <wx/datetime.h>
2405
2406 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2407 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2408
2409 #define LOCAL_TZ wxDateTime::Local
2410
2411
2412 #if UINT_MAX < LONG_MAX
2413 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2414 #define SWIG_From_unsigned_SS_int SWIG_From_long
2415 /*@@*/
2416 #else
2417 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2418 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2419 /*@@*/
2420 #endif
2421
2422 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2423 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2424 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2425 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2426 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2427 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2428 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2429 return (*self < *other);
2430 }
2431 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2432 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2433 return (*self <= *other);
2434 }
2435 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2436 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2437 return (*self > *other);
2438 }
2439 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2440 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2441 return (*self >= *other);
2442 }
2443 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2444 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2445 return (*self == *other);
2446 }
2447 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2448 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2449 return (*self != *other);
2450 }
2451 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2452 const wxChar* rv;
2453 const wxChar* _date = date;
2454 rv = self->ParseRfc822Date(_date);
2455 if (rv == NULL) return -1;
2456 return rv - _date;
2457 }
2458 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2459 const wxChar* rv;
2460 const wxChar* _date = date;
2461 rv = self->ParseFormat(_date, format, dateDef);
2462 if (rv == NULL) return -1;
2463 return rv - _date;
2464 }
2465 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2466 const wxChar* rv;
2467 const wxChar* _datetime = datetime;
2468 rv = self->ParseDateTime(_datetime);
2469 if (rv == NULL) return -1;
2470 return rv - _datetime;
2471 }
2472 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2473 const wxChar* rv;
2474 const wxChar* _date = date;
2475 rv = self->ParseDate(_date);
2476 if (rv == NULL) return -1;
2477 return rv - _date;
2478 }
2479 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2480 const wxChar* rv;
2481 const wxChar* _time = time;
2482 rv = self->ParseTime(_time);
2483 if (rv == NULL) return -1;
2484 return rv - _time;
2485 }
2486 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2487 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2488 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2489 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2490 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2491 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2492 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2493 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2494 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2495 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2496 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2497 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2498 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2499 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2500 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2501 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2502
2503 #include <wx/dataobj.h>
2504
2505 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2506 size_t count = self->GetFormatCount(dir);
2507 wxDataFormat* formats = new wxDataFormat[count];
2508 self->GetAllFormats(formats, dir);
2509
2510 bool blocked = wxPyBeginBlockThreads();
2511 PyObject* list = PyList_New(count);
2512 for (size_t i=0; i<count; i++) {
2513 wxDataFormat* format = new wxDataFormat(formats[i]);
2514 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2515 PyList_Append(list, obj);
2516 Py_DECREF(obj);
2517 }
2518 wxPyEndBlockThreads(blocked);
2519 delete [] formats;
2520 return list;
2521 }
2522 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2523 PyObject* rval = NULL;
2524 size_t size = self->GetDataSize(format);
2525 bool blocked = wxPyBeginBlockThreads();
2526 if (size) {
2527 char* buf = new char[size];
2528 if (self->GetDataHere(format, buf))
2529 rval = PyString_FromStringAndSize(buf, size);
2530 delete [] buf;
2531 }
2532 if (! rval) {
2533 rval = Py_None;
2534 Py_INCREF(rval);
2535 }
2536 wxPyEndBlockThreads(blocked);
2537 return rval;
2538 }
2539 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2540 bool rval;
2541 bool blocked = wxPyBeginBlockThreads();
2542 if (PyString_Check(data)) {
2543 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2544 }
2545 else {
2546 // raise a TypeError if not a string
2547 PyErr_SetString(PyExc_TypeError, "String expected.");
2548 rval = false;
2549 }
2550 wxPyEndBlockThreads(blocked);
2551 return rval;
2552 }
2553 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2554 PyObject* rval = NULL;
2555 size_t size = self->GetDataSize();
2556 bool blocked = wxPyBeginBlockThreads();
2557 if (size) {
2558 char* buf = new char[size];
2559 if (self->GetDataHere(buf))
2560 rval = PyString_FromStringAndSize(buf, size);
2561 delete [] buf;
2562 }
2563 if (! rval) {
2564 rval = Py_None;
2565 Py_INCREF(rval);
2566 }
2567 wxPyEndBlockThreads(blocked);
2568 return rval;
2569 }
2570 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2571 bool rval;
2572 bool blocked = wxPyBeginBlockThreads();
2573 if (PyString_Check(data)) {
2574 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2575 }
2576 else {
2577 // raise a TypeError if not a string
2578 PyErr_SetString(PyExc_TypeError, "String expected.");
2579 rval = false;
2580 }
2581 wxPyEndBlockThreads(blocked);
2582 return rval;
2583 }
2584 // Create a new class for wxPython to use
2585 class wxPyDataObjectSimple : public wxDataObjectSimple {
2586 public:
2587 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2588 : wxDataObjectSimple(format) {}
2589
2590 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2591 bool GetDataHere(void *buf) const;
2592 bool SetData(size_t len, const void *buf) const;
2593 PYPRIVATE;
2594 };
2595
2596 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2597
2598 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2599 // We need to get the data for this object and write it to buf. I think
2600 // the best way to do this for wxPython is to have the Python method
2601 // return either a string or None and then act appropriately with the
2602 // C++ version.
2603
2604 bool rval = false;
2605 bool blocked = wxPyBeginBlockThreads();
2606 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2607 PyObject* ro;
2608 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2609 if (ro) {
2610 rval = (ro != Py_None && PyString_Check(ro));
2611 if (rval)
2612 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2613 Py_DECREF(ro);
2614 }
2615 }
2616 wxPyEndBlockThreads(blocked);
2617 return rval;
2618 }
2619
2620 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2621 // For this one we simply need to make a string from buf and len
2622 // and send it to the Python method.
2623 bool rval = false;
2624 bool blocked = wxPyBeginBlockThreads();
2625 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2626 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2627 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2628 Py_DECREF(data);
2629 }
2630 wxPyEndBlockThreads(blocked);
2631 return rval;
2632 }
2633
2634 // Create a new class for wxPython to use
2635 class wxPyTextDataObject : public wxTextDataObject {
2636 public:
2637 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2638 : wxTextDataObject(text) {}
2639
2640 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2641 DEC_PYCALLBACK_STRING__const(GetText);
2642 DEC_PYCALLBACK__STRING(SetText);
2643 PYPRIVATE;
2644 };
2645
2646 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2647 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2648 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2649
2650
2651 // Create a new class for wxPython to use
2652 class wxPyBitmapDataObject : public wxBitmapDataObject {
2653 public:
2654 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2655 : wxBitmapDataObject(bitmap) {}
2656
2657 wxBitmap GetBitmap() const;
2658 void SetBitmap(const wxBitmap& bitmap);
2659 PYPRIVATE;
2660 };
2661
2662 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2663 wxBitmap* rval = &wxNullBitmap;
2664 bool blocked = wxPyBeginBlockThreads();
2665 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2666 PyObject* ro;
2667 wxBitmap* ptr;
2668 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2669 if (ro) {
2670 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2671 rval = ptr;
2672 Py_DECREF(ro);
2673 }
2674 }
2675 wxPyEndBlockThreads(blocked);
2676 return *rval;
2677 }
2678
2679 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2680 bool blocked = wxPyBeginBlockThreads();
2681 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2682 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2683 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2684 Py_DECREF(bo);
2685 }
2686 wxPyEndBlockThreads(blocked);
2687 }
2688
2689 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2690 return new wxCustomDataObject(wxDataFormat(formatName));
2691 }
2692 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2693 bool rval;
2694 bool blocked = wxPyBeginBlockThreads();
2695 if (PyString_Check(data)) {
2696 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2697 }
2698 else {
2699 // raise a TypeError if not a string
2700 PyErr_SetString(PyExc_TypeError, "String expected.");
2701 rval = false;
2702 }
2703 wxPyEndBlockThreads(blocked);
2704 return rval;
2705 }
2706 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2707 PyObject* obj;
2708 bool blocked = wxPyBeginBlockThreads();
2709 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2710 wxPyEndBlockThreads(blocked);
2711 return obj;
2712 }
2713
2714 #include <wx/metafile.h>
2715
2716
2717 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2718
2719
2720 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2721 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2722 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2723 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2724 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2725
2726
2727 class wxPyTextDropTarget : public wxTextDropTarget {
2728 public:
2729 wxPyTextDropTarget() {}
2730
2731 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2732
2733 DEC_PYCALLBACK__(OnLeave);
2734 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2735 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2736 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2737 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2738
2739 PYPRIVATE;
2740 };
2741
2742 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2743 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2744 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2745 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2746 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2747 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2748
2749
2750
2751 class wxPyFileDropTarget : public wxFileDropTarget {
2752 public:
2753 wxPyFileDropTarget() {}
2754
2755 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2756
2757 DEC_PYCALLBACK__(OnLeave);
2758 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2759 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2760 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2761 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2762
2763 PYPRIVATE;
2764 };
2765
2766 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2767 const wxArrayString& filenames) {
2768 bool rval = false;
2769 bool blocked = wxPyBeginBlockThreads();
2770 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2771 PyObject* list = wxArrayString2PyList_helper(filenames);
2772 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2773 Py_DECREF(list);
2774 }
2775 wxPyEndBlockThreads(blocked);
2776 return rval;
2777 }
2778
2779
2780
2781 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2782 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2783 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2784 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2785 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2786
2787
2788
2789
2790 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2791
2792 #include <wx/display.h>
2793
2794 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2795 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2796
2797 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2798 #if !wxUSE_DISPLAY
2799 #include <wx/dynarray.h>
2800 #include <wx/vidmode.h>
2801
2802 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2803 #include "wx/arrimpl.cpp"
2804 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2805 const wxVideoMode wxDefaultVideoMode;
2806
2807 class wxDisplay
2808 {
2809 public:
2810 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2811 ~wxDisplay() {}
2812
2813 static size_t GetCount()
2814 { wxPyRaiseNotImplemented(); return 0; }
2815
2816 static int GetFromPoint(const wxPoint& pt)
2817 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2818 static int GetFromWindow(wxWindow *window)
2819 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2820
2821 virtual bool IsOk() const { return false; }
2822 virtual wxRect GetGeometry() const { wxRect r; return r; }
2823 virtual wxString GetName() const { return wxEmptyString; }
2824 bool IsPrimary() const { return false; }
2825
2826 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2827 { wxArrayVideoModes a; return a; }
2828
2829 virtual wxVideoMode GetCurrentMode() const
2830 { return wxDefaultVideoMode; }
2831
2832 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2833 { return false; }
2834
2835 void ResetMode() {}
2836 };
2837 #endif
2838
2839 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2840 PyObject* pyList = NULL;
2841 wxArrayVideoModes arr = self->GetModes(mode);
2842 bool blocked = wxPyBeginBlockThreads();
2843 pyList = PyList_New(0);
2844 for (int i=0; i < arr.GetCount(); i++) {
2845 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2846 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2847 PyList_Append(pyList, pyObj);
2848 Py_DECREF(pyObj);
2849 }
2850 wxPyEndBlockThreads(blocked);
2851 return pyList;
2852 }
2853
2854 #include <wx/stdpaths.h>
2855
2856 static wxStandardPaths *StandardPaths_Get(){
2857 return (wxStandardPaths*) &wxStandardPaths::Get();
2858 }
2859 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2860 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2861 #ifdef __cplusplus
2862 extern "C" {
2863 #endif
2864 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2865 PyObject *resultobj;
2866 wxSystemColour arg1 ;
2867 wxColour result;
2868 PyObject * obj0 = 0 ;
2869 char *kwnames[] = {
2870 (char *) "index", NULL
2871 };
2872
2873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2874 {
2875 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2876 if (SWIG_arg_fail(1)) SWIG_fail;
2877 }
2878 {
2879 if (!wxPyCheckForApp()) SWIG_fail;
2880 PyThreadState* __tstate = wxPyBeginAllowThreads();
2881 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2882
2883 wxPyEndAllowThreads(__tstate);
2884 if (PyErr_Occurred()) SWIG_fail;
2885 }
2886 {
2887 wxColour * resultptr;
2888 resultptr = new wxColour((wxColour &)(result));
2889 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2890 }
2891 return resultobj;
2892 fail:
2893 return NULL;
2894 }
2895
2896
2897 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2898 PyObject *resultobj;
2899 wxSystemFont arg1 ;
2900 wxFont result;
2901 PyObject * obj0 = 0 ;
2902 char *kwnames[] = {
2903 (char *) "index", NULL
2904 };
2905
2906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2907 {
2908 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2909 if (SWIG_arg_fail(1)) SWIG_fail;
2910 }
2911 {
2912 if (!wxPyCheckForApp()) SWIG_fail;
2913 PyThreadState* __tstate = wxPyBeginAllowThreads();
2914 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2915
2916 wxPyEndAllowThreads(__tstate);
2917 if (PyErr_Occurred()) SWIG_fail;
2918 }
2919 {
2920 wxFont * resultptr;
2921 resultptr = new wxFont((wxFont &)(result));
2922 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2923 }
2924 return resultobj;
2925 fail:
2926 return NULL;
2927 }
2928
2929
2930 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2931 PyObject *resultobj;
2932 wxSystemMetric arg1 ;
2933 int result;
2934 PyObject * obj0 = 0 ;
2935 char *kwnames[] = {
2936 (char *) "index", NULL
2937 };
2938
2939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2940 {
2941 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2942 if (SWIG_arg_fail(1)) SWIG_fail;
2943 }
2944 {
2945 if (!wxPyCheckForApp()) SWIG_fail;
2946 PyThreadState* __tstate = wxPyBeginAllowThreads();
2947 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2948
2949 wxPyEndAllowThreads(__tstate);
2950 if (PyErr_Occurred()) SWIG_fail;
2951 }
2952 {
2953 resultobj = SWIG_From_int((int)(result));
2954 }
2955 return resultobj;
2956 fail:
2957 return NULL;
2958 }
2959
2960
2961 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2962 PyObject *resultobj;
2963 wxSystemFeature arg1 ;
2964 bool result;
2965 PyObject * obj0 = 0 ;
2966 char *kwnames[] = {
2967 (char *) "index", NULL
2968 };
2969
2970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2971 {
2972 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2973 if (SWIG_arg_fail(1)) SWIG_fail;
2974 }
2975 {
2976 if (!wxPyCheckForApp()) SWIG_fail;
2977 PyThreadState* __tstate = wxPyBeginAllowThreads();
2978 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2979
2980 wxPyEndAllowThreads(__tstate);
2981 if (PyErr_Occurred()) SWIG_fail;
2982 }
2983 {
2984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2985 }
2986 return resultobj;
2987 fail:
2988 return NULL;
2989 }
2990
2991
2992 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
2993 PyObject *resultobj;
2994 wxSystemScreenType result;
2995 char *kwnames[] = {
2996 NULL
2997 };
2998
2999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3000 {
3001 if (!wxPyCheckForApp()) SWIG_fail;
3002 PyThreadState* __tstate = wxPyBeginAllowThreads();
3003 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3004
3005 wxPyEndAllowThreads(__tstate);
3006 if (PyErr_Occurred()) SWIG_fail;
3007 }
3008 resultobj = SWIG_From_int((result));
3009 return resultobj;
3010 fail:
3011 return NULL;
3012 }
3013
3014
3015 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3016 PyObject *resultobj;
3017 wxSystemScreenType arg1 ;
3018 PyObject * obj0 = 0 ;
3019 char *kwnames[] = {
3020 (char *) "screen", NULL
3021 };
3022
3023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3024 {
3025 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3026 if (SWIG_arg_fail(1)) SWIG_fail;
3027 }
3028 {
3029 if (!wxPyCheckForApp()) SWIG_fail;
3030 PyThreadState* __tstate = wxPyBeginAllowThreads();
3031 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3032
3033 wxPyEndAllowThreads(__tstate);
3034 if (PyErr_Occurred()) SWIG_fail;
3035 }
3036 Py_INCREF(Py_None); resultobj = Py_None;
3037 return resultobj;
3038 fail:
3039 return NULL;
3040 }
3041
3042
3043 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3044 PyObject *obj;
3045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3046 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3047 Py_INCREF(obj);
3048 return Py_BuildValue((char *)"");
3049 }
3050 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3051 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3052 return 1;
3053 }
3054
3055
3056 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3057 PyObject *pyobj;
3058
3059 {
3060 #if wxUSE_UNICODE
3061 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3062 #else
3063 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3064 #endif
3065 }
3066 return pyobj;
3067 }
3068
3069
3070 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3071 PyObject *resultobj;
3072 wxSystemOptions *result;
3073 char *kwnames[] = {
3074 NULL
3075 };
3076
3077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3078 {
3079 PyThreadState* __tstate = wxPyBeginAllowThreads();
3080 result = (wxSystemOptions *)new wxSystemOptions();
3081
3082 wxPyEndAllowThreads(__tstate);
3083 if (PyErr_Occurred()) SWIG_fail;
3084 }
3085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3086 return resultobj;
3087 fail:
3088 return NULL;
3089 }
3090
3091
3092 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3093 PyObject *resultobj;
3094 wxString *arg1 = 0 ;
3095 wxString *arg2 = 0 ;
3096 bool temp1 = false ;
3097 bool temp2 = false ;
3098 PyObject * obj0 = 0 ;
3099 PyObject * obj1 = 0 ;
3100 char *kwnames[] = {
3101 (char *) "name",(char *) "value", NULL
3102 };
3103
3104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3105 {
3106 arg1 = wxString_in_helper(obj0);
3107 if (arg1 == NULL) SWIG_fail;
3108 temp1 = true;
3109 }
3110 {
3111 arg2 = wxString_in_helper(obj1);
3112 if (arg2 == NULL) SWIG_fail;
3113 temp2 = true;
3114 }
3115 {
3116 PyThreadState* __tstate = wxPyBeginAllowThreads();
3117 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3118
3119 wxPyEndAllowThreads(__tstate);
3120 if (PyErr_Occurred()) SWIG_fail;
3121 }
3122 Py_INCREF(Py_None); resultobj = Py_None;
3123 {
3124 if (temp1)
3125 delete arg1;
3126 }
3127 {
3128 if (temp2)
3129 delete arg2;
3130 }
3131 return resultobj;
3132 fail:
3133 {
3134 if (temp1)
3135 delete arg1;
3136 }
3137 {
3138 if (temp2)
3139 delete arg2;
3140 }
3141 return NULL;
3142 }
3143
3144
3145 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3146 PyObject *resultobj;
3147 wxString *arg1 = 0 ;
3148 int arg2 ;
3149 bool temp1 = false ;
3150 PyObject * obj0 = 0 ;
3151 PyObject * obj1 = 0 ;
3152 char *kwnames[] = {
3153 (char *) "name",(char *) "value", NULL
3154 };
3155
3156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3157 {
3158 arg1 = wxString_in_helper(obj0);
3159 if (arg1 == NULL) SWIG_fail;
3160 temp1 = true;
3161 }
3162 {
3163 arg2 = (int)(SWIG_As_int(obj1));
3164 if (SWIG_arg_fail(2)) SWIG_fail;
3165 }
3166 {
3167 PyThreadState* __tstate = wxPyBeginAllowThreads();
3168 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3169
3170 wxPyEndAllowThreads(__tstate);
3171 if (PyErr_Occurred()) SWIG_fail;
3172 }
3173 Py_INCREF(Py_None); resultobj = Py_None;
3174 {
3175 if (temp1)
3176 delete arg1;
3177 }
3178 return resultobj;
3179 fail:
3180 {
3181 if (temp1)
3182 delete arg1;
3183 }
3184 return NULL;
3185 }
3186
3187
3188 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3189 PyObject *resultobj;
3190 wxString *arg1 = 0 ;
3191 wxString result;
3192 bool temp1 = false ;
3193 PyObject * obj0 = 0 ;
3194 char *kwnames[] = {
3195 (char *) "name", NULL
3196 };
3197
3198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3199 {
3200 arg1 = wxString_in_helper(obj0);
3201 if (arg1 == NULL) SWIG_fail;
3202 temp1 = true;
3203 }
3204 {
3205 PyThreadState* __tstate = wxPyBeginAllowThreads();
3206 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3207
3208 wxPyEndAllowThreads(__tstate);
3209 if (PyErr_Occurred()) SWIG_fail;
3210 }
3211 {
3212 #if wxUSE_UNICODE
3213 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3214 #else
3215 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3216 #endif
3217 }
3218 {
3219 if (temp1)
3220 delete arg1;
3221 }
3222 return resultobj;
3223 fail:
3224 {
3225 if (temp1)
3226 delete arg1;
3227 }
3228 return NULL;
3229 }
3230
3231
3232 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3233 PyObject *resultobj;
3234 wxString *arg1 = 0 ;
3235 int result;
3236 bool temp1 = false ;
3237 PyObject * obj0 = 0 ;
3238 char *kwnames[] = {
3239 (char *) "name", NULL
3240 };
3241
3242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3243 {
3244 arg1 = wxString_in_helper(obj0);
3245 if (arg1 == NULL) SWIG_fail;
3246 temp1 = true;
3247 }
3248 {
3249 PyThreadState* __tstate = wxPyBeginAllowThreads();
3250 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3251
3252 wxPyEndAllowThreads(__tstate);
3253 if (PyErr_Occurred()) SWIG_fail;
3254 }
3255 {
3256 resultobj = SWIG_From_int((int)(result));
3257 }
3258 {
3259 if (temp1)
3260 delete arg1;
3261 }
3262 return resultobj;
3263 fail:
3264 {
3265 if (temp1)
3266 delete arg1;
3267 }
3268 return NULL;
3269 }
3270
3271
3272 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3273 PyObject *resultobj;
3274 wxString *arg1 = 0 ;
3275 bool result;
3276 bool temp1 = false ;
3277 PyObject * obj0 = 0 ;
3278 char *kwnames[] = {
3279 (char *) "name", NULL
3280 };
3281
3282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3283 {
3284 arg1 = wxString_in_helper(obj0);
3285 if (arg1 == NULL) SWIG_fail;
3286 temp1 = true;
3287 }
3288 {
3289 PyThreadState* __tstate = wxPyBeginAllowThreads();
3290 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3291
3292 wxPyEndAllowThreads(__tstate);
3293 if (PyErr_Occurred()) SWIG_fail;
3294 }
3295 {
3296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3297 }
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 * SystemOptions_swigregister(PyObject *, PyObject *args) {
3313 PyObject *obj;
3314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3315 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3316 Py_INCREF(obj);
3317 return Py_BuildValue((char *)"");
3318 }
3319 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3320 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3321 return 1;
3322 }
3323
3324
3325 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3326 PyObject *pyobj;
3327
3328 {
3329 #if wxUSE_UNICODE
3330 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3331 #else
3332 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3333 #endif
3334 }
3335 return pyobj;
3336 }
3337
3338
3339 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3340 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3341 return 1;
3342 }
3343
3344
3345 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3346 PyObject *pyobj;
3347
3348 {
3349 #if wxUSE_UNICODE
3350 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3351 #else
3352 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3353 #endif
3354 }
3355 return pyobj;
3356 }
3357
3358
3359 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3360 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3361 return 1;
3362 }
3363
3364
3365 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3366 PyObject *pyobj;
3367
3368 {
3369 #if wxUSE_UNICODE
3370 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3371 #else
3372 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3373 #endif
3374 }
3375 return pyobj;
3376 }
3377
3378
3379 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3380 PyObject *resultobj;
3381 long result;
3382 char *kwnames[] = {
3383 NULL
3384 };
3385
3386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3387 {
3388 PyThreadState* __tstate = wxPyBeginAllowThreads();
3389 result = (long)wxNewId();
3390
3391 wxPyEndAllowThreads(__tstate);
3392 if (PyErr_Occurred()) SWIG_fail;
3393 }
3394 {
3395 resultobj = SWIG_From_long((long)(result));
3396 }
3397 return resultobj;
3398 fail:
3399 return NULL;
3400 }
3401
3402
3403 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3404 PyObject *resultobj;
3405 long arg1 ;
3406 PyObject * obj0 = 0 ;
3407 char *kwnames[] = {
3408 (char *) "id", NULL
3409 };
3410
3411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3412 {
3413 arg1 = (long)(SWIG_As_long(obj0));
3414 if (SWIG_arg_fail(1)) SWIG_fail;
3415 }
3416 {
3417 PyThreadState* __tstate = wxPyBeginAllowThreads();
3418 wxRegisterId(arg1);
3419
3420 wxPyEndAllowThreads(__tstate);
3421 if (PyErr_Occurred()) SWIG_fail;
3422 }
3423 Py_INCREF(Py_None); resultobj = Py_None;
3424 return resultobj;
3425 fail:
3426 return NULL;
3427 }
3428
3429
3430 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3431 PyObject *resultobj;
3432 long result;
3433 char *kwnames[] = {
3434 NULL
3435 };
3436
3437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3438 {
3439 PyThreadState* __tstate = wxPyBeginAllowThreads();
3440 result = (long)wxGetCurrentId();
3441
3442 wxPyEndAllowThreads(__tstate);
3443 if (PyErr_Occurred()) SWIG_fail;
3444 }
3445 {
3446 resultobj = SWIG_From_long((long)(result));
3447 }
3448 return resultobj;
3449 fail:
3450 return NULL;
3451 }
3452
3453
3454 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3455 PyObject *resultobj;
3456 int arg1 ;
3457 bool result;
3458 PyObject * obj0 = 0 ;
3459 char *kwnames[] = {
3460 (char *) "id", NULL
3461 };
3462
3463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3464 {
3465 arg1 = (int)(SWIG_As_int(obj0));
3466 if (SWIG_arg_fail(1)) SWIG_fail;
3467 }
3468 {
3469 PyThreadState* __tstate = wxPyBeginAllowThreads();
3470 result = (bool)wxIsStockID(arg1);
3471
3472 wxPyEndAllowThreads(__tstate);
3473 if (PyErr_Occurred()) SWIG_fail;
3474 }
3475 {
3476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3477 }
3478 return resultobj;
3479 fail:
3480 return NULL;
3481 }
3482
3483
3484 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3485 PyObject *resultobj;
3486 int arg1 ;
3487 wxString *arg2 = 0 ;
3488 bool result;
3489 bool temp2 = false ;
3490 PyObject * obj0 = 0 ;
3491 PyObject * obj1 = 0 ;
3492 char *kwnames[] = {
3493 (char *) "id",(char *) "label", NULL
3494 };
3495
3496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3497 {
3498 arg1 = (int)(SWIG_As_int(obj0));
3499 if (SWIG_arg_fail(1)) SWIG_fail;
3500 }
3501 {
3502 arg2 = wxString_in_helper(obj1);
3503 if (arg2 == NULL) SWIG_fail;
3504 temp2 = true;
3505 }
3506 {
3507 PyThreadState* __tstate = wxPyBeginAllowThreads();
3508 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3509
3510 wxPyEndAllowThreads(__tstate);
3511 if (PyErr_Occurred()) SWIG_fail;
3512 }
3513 {
3514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3515 }
3516 {
3517 if (temp2)
3518 delete arg2;
3519 }
3520 return resultobj;
3521 fail:
3522 {
3523 if (temp2)
3524 delete arg2;
3525 }
3526 return NULL;
3527 }
3528
3529
3530 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3531 PyObject *resultobj;
3532 int arg1 ;
3533 bool arg2 = (bool) true ;
3534 wxString arg3 = (wxString) wxPyEmptyString ;
3535 wxString result;
3536 PyObject * obj0 = 0 ;
3537 PyObject * obj1 = 0 ;
3538 PyObject * obj2 = 0 ;
3539 char *kwnames[] = {
3540 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3541 };
3542
3543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3544 {
3545 arg1 = (int)(SWIG_As_int(obj0));
3546 if (SWIG_arg_fail(1)) SWIG_fail;
3547 }
3548 if (obj1) {
3549 {
3550 arg2 = (bool)(SWIG_As_bool(obj1));
3551 if (SWIG_arg_fail(2)) SWIG_fail;
3552 }
3553 }
3554 if (obj2) {
3555 {
3556 wxString* sptr = wxString_in_helper(obj2);
3557 if (sptr == NULL) SWIG_fail;
3558 arg3 = *sptr;
3559 delete sptr;
3560 }
3561 }
3562 {
3563 PyThreadState* __tstate = wxPyBeginAllowThreads();
3564 result = wxGetStockLabel(arg1,arg2,arg3);
3565
3566 wxPyEndAllowThreads(__tstate);
3567 if (PyErr_Occurred()) SWIG_fail;
3568 }
3569 {
3570 #if wxUSE_UNICODE
3571 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3572 #else
3573 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3574 #endif
3575 }
3576 return resultobj;
3577 fail:
3578 return NULL;
3579 }
3580
3581
3582 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3583 PyObject *resultobj;
3584 char *kwnames[] = {
3585 NULL
3586 };
3587
3588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3589 {
3590 if (!wxPyCheckForApp()) SWIG_fail;
3591 PyThreadState* __tstate = wxPyBeginAllowThreads();
3592 wxBell();
3593
3594 wxPyEndAllowThreads(__tstate);
3595 if (PyErr_Occurred()) SWIG_fail;
3596 }
3597 Py_INCREF(Py_None); resultobj = Py_None;
3598 return resultobj;
3599 fail:
3600 return NULL;
3601 }
3602
3603
3604 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3605 PyObject *resultobj;
3606 char *kwnames[] = {
3607 NULL
3608 };
3609
3610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3611 {
3612 if (!wxPyCheckForApp()) SWIG_fail;
3613 PyThreadState* __tstate = wxPyBeginAllowThreads();
3614 wxEndBusyCursor();
3615
3616 wxPyEndAllowThreads(__tstate);
3617 if (PyErr_Occurred()) SWIG_fail;
3618 }
3619 Py_INCREF(Py_None); resultobj = Py_None;
3620 return resultobj;
3621 fail:
3622 return NULL;
3623 }
3624
3625
3626 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3627 PyObject *resultobj;
3628 bool arg1 = (bool) true ;
3629 long result;
3630 PyObject * obj0 = 0 ;
3631 char *kwnames[] = {
3632 (char *) "resetTimer", NULL
3633 };
3634
3635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3636 if (obj0) {
3637 {
3638 arg1 = (bool)(SWIG_As_bool(obj0));
3639 if (SWIG_arg_fail(1)) SWIG_fail;
3640 }
3641 }
3642 {
3643 PyThreadState* __tstate = wxPyBeginAllowThreads();
3644 result = (long)wxGetElapsedTime(arg1);
3645
3646 wxPyEndAllowThreads(__tstate);
3647 if (PyErr_Occurred()) SWIG_fail;
3648 }
3649 {
3650 resultobj = SWIG_From_long((long)(result));
3651 }
3652 return resultobj;
3653 fail:
3654 return NULL;
3655 }
3656
3657
3658 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3659 PyObject *resultobj;
3660 int *arg1 = (int *) 0 ;
3661 int *arg2 = (int *) 0 ;
3662 int temp1 ;
3663 int res1 = 0 ;
3664 int temp2 ;
3665 int res2 = 0 ;
3666 char *kwnames[] = {
3667 NULL
3668 };
3669
3670 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3671 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3673 {
3674 if (!wxPyCheckForApp()) SWIG_fail;
3675 PyThreadState* __tstate = wxPyBeginAllowThreads();
3676 wxGetMousePosition(arg1,arg2);
3677
3678 wxPyEndAllowThreads(__tstate);
3679 if (PyErr_Occurred()) SWIG_fail;
3680 }
3681 Py_INCREF(Py_None); resultobj = Py_None;
3682 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3683 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3684 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3685 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3686 return resultobj;
3687 fail:
3688 return NULL;
3689 }
3690
3691
3692 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3693 PyObject *resultobj;
3694 bool result;
3695 char *kwnames[] = {
3696 NULL
3697 };
3698
3699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3700 {
3701 PyThreadState* __tstate = wxPyBeginAllowThreads();
3702 result = (bool)wxIsBusy();
3703
3704 wxPyEndAllowThreads(__tstate);
3705 if (PyErr_Occurred()) SWIG_fail;
3706 }
3707 {
3708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3709 }
3710 return resultobj;
3711 fail:
3712 return NULL;
3713 }
3714
3715
3716 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3717 PyObject *resultobj;
3718 wxString result;
3719 char *kwnames[] = {
3720 NULL
3721 };
3722
3723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3724 {
3725 PyThreadState* __tstate = wxPyBeginAllowThreads();
3726 result = wxNow();
3727
3728 wxPyEndAllowThreads(__tstate);
3729 if (PyErr_Occurred()) SWIG_fail;
3730 }
3731 {
3732 #if wxUSE_UNICODE
3733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3734 #else
3735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3736 #endif
3737 }
3738 return resultobj;
3739 fail:
3740 return NULL;
3741 }
3742
3743
3744 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3745 PyObject *resultobj;
3746 wxString const &arg1_defvalue = wxPyEmptyString ;
3747 wxString *arg1 = (wxString *) &arg1_defvalue ;
3748 bool result;
3749 bool temp1 = false ;
3750 PyObject * obj0 = 0 ;
3751 char *kwnames[] = {
3752 (char *) "command", NULL
3753 };
3754
3755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3756 if (obj0) {
3757 {
3758 arg1 = wxString_in_helper(obj0);
3759 if (arg1 == NULL) SWIG_fail;
3760 temp1 = true;
3761 }
3762 }
3763 {
3764 PyThreadState* __tstate = wxPyBeginAllowThreads();
3765 result = (bool)wxShell((wxString const &)*arg1);
3766
3767 wxPyEndAllowThreads(__tstate);
3768 if (PyErr_Occurred()) SWIG_fail;
3769 }
3770 {
3771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3772 }
3773 {
3774 if (temp1)
3775 delete arg1;
3776 }
3777 return resultobj;
3778 fail:
3779 {
3780 if (temp1)
3781 delete arg1;
3782 }
3783 return NULL;
3784 }
3785
3786
3787 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3788 PyObject *resultobj;
3789 char *kwnames[] = {
3790 NULL
3791 };
3792
3793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3794 {
3795 PyThreadState* __tstate = wxPyBeginAllowThreads();
3796 wxStartTimer();
3797
3798 wxPyEndAllowThreads(__tstate);
3799 if (PyErr_Occurred()) SWIG_fail;
3800 }
3801 Py_INCREF(Py_None); resultobj = Py_None;
3802 return resultobj;
3803 fail:
3804 return NULL;
3805 }
3806
3807
3808 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3809 PyObject *resultobj;
3810 int *arg1 = (int *) 0 ;
3811 int *arg2 = (int *) 0 ;
3812 int result;
3813 int temp1 ;
3814 int res1 = 0 ;
3815 int temp2 ;
3816 int res2 = 0 ;
3817 char *kwnames[] = {
3818 NULL
3819 };
3820
3821 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3822 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3824 {
3825 PyThreadState* __tstate = wxPyBeginAllowThreads();
3826 result = (int)wxGetOsVersion(arg1,arg2);
3827
3828 wxPyEndAllowThreads(__tstate);
3829 if (PyErr_Occurred()) SWIG_fail;
3830 }
3831 {
3832 resultobj = SWIG_From_int((int)(result));
3833 }
3834 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3835 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3836 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3837 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3838 return resultobj;
3839 fail:
3840 return NULL;
3841 }
3842
3843
3844 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3845 PyObject *resultobj;
3846 wxString result;
3847 char *kwnames[] = {
3848 NULL
3849 };
3850
3851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3852 {
3853 PyThreadState* __tstate = wxPyBeginAllowThreads();
3854 result = wxGetOsDescription();
3855
3856 wxPyEndAllowThreads(__tstate);
3857 if (PyErr_Occurred()) SWIG_fail;
3858 }
3859 {
3860 #if wxUSE_UNICODE
3861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3862 #else
3863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3864 #endif
3865 }
3866 return resultobj;
3867 fail:
3868 return NULL;
3869 }
3870
3871
3872 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3873 PyObject *resultobj;
3874 long result;
3875 char *kwnames[] = {
3876 NULL
3877 };
3878
3879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3880 {
3881 PyThreadState* __tstate = wxPyBeginAllowThreads();
3882 result = (long)wxGetFreeMemory();
3883
3884 wxPyEndAllowThreads(__tstate);
3885 if (PyErr_Occurred()) SWIG_fail;
3886 }
3887 {
3888 resultobj = SWIG_From_long((long)(result));
3889 }
3890 return resultobj;
3891 fail:
3892 return NULL;
3893 }
3894
3895
3896 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3897 PyObject *resultobj;
3898 wxShutdownFlags arg1 ;
3899 bool result;
3900 PyObject * obj0 = 0 ;
3901 char *kwnames[] = {
3902 (char *) "wFlags", NULL
3903 };
3904
3905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3906 {
3907 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3908 if (SWIG_arg_fail(1)) SWIG_fail;
3909 }
3910 {
3911 if (!wxPyCheckForApp()) SWIG_fail;
3912 PyThreadState* __tstate = wxPyBeginAllowThreads();
3913 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3914
3915 wxPyEndAllowThreads(__tstate);
3916 if (PyErr_Occurred()) SWIG_fail;
3917 }
3918 {
3919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3920 }
3921 return resultobj;
3922 fail:
3923 return NULL;
3924 }
3925
3926
3927 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3928 PyObject *resultobj;
3929 int arg1 ;
3930 PyObject * obj0 = 0 ;
3931 char *kwnames[] = {
3932 (char *) "secs", NULL
3933 };
3934
3935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3936 {
3937 arg1 = (int)(SWIG_As_int(obj0));
3938 if (SWIG_arg_fail(1)) SWIG_fail;
3939 }
3940 {
3941 PyThreadState* __tstate = wxPyBeginAllowThreads();
3942 wxSleep(arg1);
3943
3944 wxPyEndAllowThreads(__tstate);
3945 if (PyErr_Occurred()) SWIG_fail;
3946 }
3947 Py_INCREF(Py_None); resultobj = Py_None;
3948 return resultobj;
3949 fail:
3950 return NULL;
3951 }
3952
3953
3954 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3955 PyObject *resultobj;
3956 unsigned long arg1 ;
3957 PyObject * obj0 = 0 ;
3958 char *kwnames[] = {
3959 (char *) "milliseconds", NULL
3960 };
3961
3962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3963 {
3964 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3965 if (SWIG_arg_fail(1)) SWIG_fail;
3966 }
3967 {
3968 PyThreadState* __tstate = wxPyBeginAllowThreads();
3969 wxMilliSleep(arg1);
3970
3971 wxPyEndAllowThreads(__tstate);
3972 if (PyErr_Occurred()) SWIG_fail;
3973 }
3974 Py_INCREF(Py_None); resultobj = Py_None;
3975 return resultobj;
3976 fail:
3977 return NULL;
3978 }
3979
3980
3981 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3982 PyObject *resultobj;
3983 unsigned long arg1 ;
3984 PyObject * obj0 = 0 ;
3985 char *kwnames[] = {
3986 (char *) "microseconds", NULL
3987 };
3988
3989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
3990 {
3991 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3992 if (SWIG_arg_fail(1)) SWIG_fail;
3993 }
3994 {
3995 PyThreadState* __tstate = wxPyBeginAllowThreads();
3996 wxMicroSleep(arg1);
3997
3998 wxPyEndAllowThreads(__tstate);
3999 if (PyErr_Occurred()) SWIG_fail;
4000 }
4001 Py_INCREF(Py_None); resultobj = Py_None;
4002 return resultobj;
4003 fail:
4004 return NULL;
4005 }
4006
4007
4008 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4009 PyObject *resultobj;
4010 bool arg1 ;
4011 PyObject * obj0 = 0 ;
4012 char *kwnames[] = {
4013 (char *) "enable", NULL
4014 };
4015
4016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4017 {
4018 arg1 = (bool)(SWIG_As_bool(obj0));
4019 if (SWIG_arg_fail(1)) SWIG_fail;
4020 }
4021 {
4022 PyThreadState* __tstate = wxPyBeginAllowThreads();
4023 wxEnableTopLevelWindows(arg1);
4024
4025 wxPyEndAllowThreads(__tstate);
4026 if (PyErr_Occurred()) SWIG_fail;
4027 }
4028 Py_INCREF(Py_None); resultobj = Py_None;
4029 return resultobj;
4030 fail:
4031 return NULL;
4032 }
4033
4034
4035 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4036 PyObject *resultobj;
4037 wxString *arg1 = 0 ;
4038 wxString result;
4039 bool temp1 = false ;
4040 PyObject * obj0 = 0 ;
4041 char *kwnames[] = {
4042 (char *) "in", NULL
4043 };
4044
4045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4046 {
4047 arg1 = wxString_in_helper(obj0);
4048 if (arg1 == NULL) SWIG_fail;
4049 temp1 = true;
4050 }
4051 {
4052 PyThreadState* __tstate = wxPyBeginAllowThreads();
4053 result = wxStripMenuCodes((wxString const &)*arg1);
4054
4055 wxPyEndAllowThreads(__tstate);
4056 if (PyErr_Occurred()) SWIG_fail;
4057 }
4058 {
4059 #if wxUSE_UNICODE
4060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4061 #else
4062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4063 #endif
4064 }
4065 {
4066 if (temp1)
4067 delete arg1;
4068 }
4069 return resultobj;
4070 fail:
4071 {
4072 if (temp1)
4073 delete arg1;
4074 }
4075 return NULL;
4076 }
4077
4078
4079 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4080 PyObject *resultobj;
4081 wxString result;
4082 char *kwnames[] = {
4083 NULL
4084 };
4085
4086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4087 {
4088 PyThreadState* __tstate = wxPyBeginAllowThreads();
4089 result = wxGetEmailAddress();
4090
4091 wxPyEndAllowThreads(__tstate);
4092 if (PyErr_Occurred()) SWIG_fail;
4093 }
4094 {
4095 #if wxUSE_UNICODE
4096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4097 #else
4098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4099 #endif
4100 }
4101 return resultobj;
4102 fail:
4103 return NULL;
4104 }
4105
4106
4107 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4108 PyObject *resultobj;
4109 wxString result;
4110 char *kwnames[] = {
4111 NULL
4112 };
4113
4114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4115 {
4116 PyThreadState* __tstate = wxPyBeginAllowThreads();
4117 result = wxGetHostName();
4118
4119 wxPyEndAllowThreads(__tstate);
4120 if (PyErr_Occurred()) SWIG_fail;
4121 }
4122 {
4123 #if wxUSE_UNICODE
4124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4125 #else
4126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4127 #endif
4128 }
4129 return resultobj;
4130 fail:
4131 return NULL;
4132 }
4133
4134
4135 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4136 PyObject *resultobj;
4137 wxString result;
4138 char *kwnames[] = {
4139 NULL
4140 };
4141
4142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4143 {
4144 PyThreadState* __tstate = wxPyBeginAllowThreads();
4145 result = wxGetFullHostName();
4146
4147 wxPyEndAllowThreads(__tstate);
4148 if (PyErr_Occurred()) SWIG_fail;
4149 }
4150 {
4151 #if wxUSE_UNICODE
4152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4153 #else
4154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4155 #endif
4156 }
4157 return resultobj;
4158 fail:
4159 return NULL;
4160 }
4161
4162
4163 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4164 PyObject *resultobj;
4165 wxString result;
4166 char *kwnames[] = {
4167 NULL
4168 };
4169
4170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4171 {
4172 PyThreadState* __tstate = wxPyBeginAllowThreads();
4173 result = wxGetUserId();
4174
4175 wxPyEndAllowThreads(__tstate);
4176 if (PyErr_Occurred()) SWIG_fail;
4177 }
4178 {
4179 #if wxUSE_UNICODE
4180 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4181 #else
4182 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4183 #endif
4184 }
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4192 PyObject *resultobj;
4193 wxString result;
4194 char *kwnames[] = {
4195 NULL
4196 };
4197
4198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4199 {
4200 PyThreadState* __tstate = wxPyBeginAllowThreads();
4201 result = wxGetUserName();
4202
4203 wxPyEndAllowThreads(__tstate);
4204 if (PyErr_Occurred()) SWIG_fail;
4205 }
4206 {
4207 #if wxUSE_UNICODE
4208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4209 #else
4210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4211 #endif
4212 }
4213 return resultobj;
4214 fail:
4215 return NULL;
4216 }
4217
4218
4219 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4220 PyObject *resultobj;
4221 wxString result;
4222 char *kwnames[] = {
4223 NULL
4224 };
4225
4226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4227 {
4228 PyThreadState* __tstate = wxPyBeginAllowThreads();
4229 result = wxGetHomeDir();
4230
4231 wxPyEndAllowThreads(__tstate);
4232 if (PyErr_Occurred()) SWIG_fail;
4233 }
4234 {
4235 #if wxUSE_UNICODE
4236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4237 #else
4238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4239 #endif
4240 }
4241 return resultobj;
4242 fail:
4243 return NULL;
4244 }
4245
4246
4247 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4248 PyObject *resultobj;
4249 wxString const &arg1_defvalue = wxPyEmptyString ;
4250 wxString *arg1 = (wxString *) &arg1_defvalue ;
4251 wxString result;
4252 bool temp1 = false ;
4253 PyObject * obj0 = 0 ;
4254 char *kwnames[] = {
4255 (char *) "user", NULL
4256 };
4257
4258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4259 if (obj0) {
4260 {
4261 arg1 = wxString_in_helper(obj0);
4262 if (arg1 == NULL) SWIG_fail;
4263 temp1 = true;
4264 }
4265 }
4266 {
4267 PyThreadState* __tstate = wxPyBeginAllowThreads();
4268 result = wxGetUserHome((wxString const &)*arg1);
4269
4270 wxPyEndAllowThreads(__tstate);
4271 if (PyErr_Occurred()) SWIG_fail;
4272 }
4273 {
4274 #if wxUSE_UNICODE
4275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4276 #else
4277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4278 #endif
4279 }
4280 {
4281 if (temp1)
4282 delete arg1;
4283 }
4284 return resultobj;
4285 fail:
4286 {
4287 if (temp1)
4288 delete arg1;
4289 }
4290 return NULL;
4291 }
4292
4293
4294 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4295 PyObject *resultobj;
4296 unsigned long result;
4297 char *kwnames[] = {
4298 NULL
4299 };
4300
4301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4302 {
4303 PyThreadState* __tstate = wxPyBeginAllowThreads();
4304 result = (unsigned long)wxGetProcessId();
4305
4306 wxPyEndAllowThreads(__tstate);
4307 if (PyErr_Occurred()) SWIG_fail;
4308 }
4309 {
4310 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4311 }
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj;
4320 char *kwnames[] = {
4321 NULL
4322 };
4323
4324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4325 {
4326 PyThreadState* __tstate = wxPyBeginAllowThreads();
4327 wxTrap();
4328
4329 wxPyEndAllowThreads(__tstate);
4330 if (PyErr_Occurred()) SWIG_fail;
4331 }
4332 Py_INCREF(Py_None); resultobj = Py_None;
4333 return resultobj;
4334 fail:
4335 return NULL;
4336 }
4337
4338
4339 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4340 PyObject *resultobj;
4341 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4342 wxString *arg1 = (wxString *) &arg1_defvalue ;
4343 wxString const &arg2_defvalue = wxPyEmptyString ;
4344 wxString *arg2 = (wxString *) &arg2_defvalue ;
4345 wxString const &arg3_defvalue = wxPyEmptyString ;
4346 wxString *arg3 = (wxString *) &arg3_defvalue ;
4347 wxString const &arg4_defvalue = wxPyEmptyString ;
4348 wxString *arg4 = (wxString *) &arg4_defvalue ;
4349 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4350 wxString *arg5 = (wxString *) &arg5_defvalue ;
4351 int arg6 = (int) 0 ;
4352 wxWindow *arg7 = (wxWindow *) NULL ;
4353 int arg8 = (int) -1 ;
4354 int arg9 = (int) -1 ;
4355 wxString result;
4356 bool temp1 = false ;
4357 bool temp2 = false ;
4358 bool temp3 = false ;
4359 bool temp4 = false ;
4360 bool temp5 = false ;
4361 PyObject * obj0 = 0 ;
4362 PyObject * obj1 = 0 ;
4363 PyObject * obj2 = 0 ;
4364 PyObject * obj3 = 0 ;
4365 PyObject * obj4 = 0 ;
4366 PyObject * obj5 = 0 ;
4367 PyObject * obj6 = 0 ;
4368 PyObject * obj7 = 0 ;
4369 PyObject * obj8 = 0 ;
4370 char *kwnames[] = {
4371 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4372 };
4373
4374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4375 if (obj0) {
4376 {
4377 arg1 = wxString_in_helper(obj0);
4378 if (arg1 == NULL) SWIG_fail;
4379 temp1 = true;
4380 }
4381 }
4382 if (obj1) {
4383 {
4384 arg2 = wxString_in_helper(obj1);
4385 if (arg2 == NULL) SWIG_fail;
4386 temp2 = true;
4387 }
4388 }
4389 if (obj2) {
4390 {
4391 arg3 = wxString_in_helper(obj2);
4392 if (arg3 == NULL) SWIG_fail;
4393 temp3 = true;
4394 }
4395 }
4396 if (obj3) {
4397 {
4398 arg4 = wxString_in_helper(obj3);
4399 if (arg4 == NULL) SWIG_fail;
4400 temp4 = true;
4401 }
4402 }
4403 if (obj4) {
4404 {
4405 arg5 = wxString_in_helper(obj4);
4406 if (arg5 == NULL) SWIG_fail;
4407 temp5 = true;
4408 }
4409 }
4410 if (obj5) {
4411 {
4412 arg6 = (int)(SWIG_As_int(obj5));
4413 if (SWIG_arg_fail(6)) SWIG_fail;
4414 }
4415 }
4416 if (obj6) {
4417 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4418 if (SWIG_arg_fail(7)) SWIG_fail;
4419 }
4420 if (obj7) {
4421 {
4422 arg8 = (int)(SWIG_As_int(obj7));
4423 if (SWIG_arg_fail(8)) SWIG_fail;
4424 }
4425 }
4426 if (obj8) {
4427 {
4428 arg9 = (int)(SWIG_As_int(obj8));
4429 if (SWIG_arg_fail(9)) SWIG_fail;
4430 }
4431 }
4432 {
4433 if (!wxPyCheckForApp()) SWIG_fail;
4434 PyThreadState* __tstate = wxPyBeginAllowThreads();
4435 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4436
4437 wxPyEndAllowThreads(__tstate);
4438 if (PyErr_Occurred()) SWIG_fail;
4439 }
4440 {
4441 #if wxUSE_UNICODE
4442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4443 #else
4444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4445 #endif
4446 }
4447 {
4448 if (temp1)
4449 delete arg1;
4450 }
4451 {
4452 if (temp2)
4453 delete arg2;
4454 }
4455 {
4456 if (temp3)
4457 delete arg3;
4458 }
4459 {
4460 if (temp4)
4461 delete arg4;
4462 }
4463 {
4464 if (temp5)
4465 delete arg5;
4466 }
4467 return resultobj;
4468 fail:
4469 {
4470 if (temp1)
4471 delete arg1;
4472 }
4473 {
4474 if (temp2)
4475 delete arg2;
4476 }
4477 {
4478 if (temp3)
4479 delete arg3;
4480 }
4481 {
4482 if (temp4)
4483 delete arg4;
4484 }
4485 {
4486 if (temp5)
4487 delete arg5;
4488 }
4489 return NULL;
4490 }
4491
4492
4493 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4494 PyObject *resultobj;
4495 wxString *arg1 = 0 ;
4496 wxString *arg2 = 0 ;
4497 wxString const &arg3_defvalue = wxPyEmptyString ;
4498 wxString *arg3 = (wxString *) &arg3_defvalue ;
4499 wxWindow *arg4 = (wxWindow *) NULL ;
4500 wxString result;
4501 bool temp1 = false ;
4502 bool temp2 = false ;
4503 bool temp3 = false ;
4504 PyObject * obj0 = 0 ;
4505 PyObject * obj1 = 0 ;
4506 PyObject * obj2 = 0 ;
4507 PyObject * obj3 = 0 ;
4508 char *kwnames[] = {
4509 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4510 };
4511
4512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4513 {
4514 arg1 = wxString_in_helper(obj0);
4515 if (arg1 == NULL) SWIG_fail;
4516 temp1 = true;
4517 }
4518 {
4519 arg2 = wxString_in_helper(obj1);
4520 if (arg2 == NULL) SWIG_fail;
4521 temp2 = true;
4522 }
4523 if (obj2) {
4524 {
4525 arg3 = wxString_in_helper(obj2);
4526 if (arg3 == NULL) SWIG_fail;
4527 temp3 = true;
4528 }
4529 }
4530 if (obj3) {
4531 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4532 if (SWIG_arg_fail(4)) SWIG_fail;
4533 }
4534 {
4535 if (!wxPyCheckForApp()) SWIG_fail;
4536 PyThreadState* __tstate = wxPyBeginAllowThreads();
4537 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4538
4539 wxPyEndAllowThreads(__tstate);
4540 if (PyErr_Occurred()) SWIG_fail;
4541 }
4542 {
4543 #if wxUSE_UNICODE
4544 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4545 #else
4546 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4547 #endif
4548 }
4549 {
4550 if (temp1)
4551 delete arg1;
4552 }
4553 {
4554 if (temp2)
4555 delete arg2;
4556 }
4557 {
4558 if (temp3)
4559 delete arg3;
4560 }
4561 return resultobj;
4562 fail:
4563 {
4564 if (temp1)
4565 delete arg1;
4566 }
4567 {
4568 if (temp2)
4569 delete arg2;
4570 }
4571 {
4572 if (temp3)
4573 delete arg3;
4574 }
4575 return NULL;
4576 }
4577
4578
4579 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4580 PyObject *resultobj;
4581 wxString *arg1 = 0 ;
4582 wxString *arg2 = 0 ;
4583 wxString const &arg3_defvalue = wxPyEmptyString ;
4584 wxString *arg3 = (wxString *) &arg3_defvalue ;
4585 wxWindow *arg4 = (wxWindow *) NULL ;
4586 wxString result;
4587 bool temp1 = false ;
4588 bool temp2 = false ;
4589 bool temp3 = false ;
4590 PyObject * obj0 = 0 ;
4591 PyObject * obj1 = 0 ;
4592 PyObject * obj2 = 0 ;
4593 PyObject * obj3 = 0 ;
4594 char *kwnames[] = {
4595 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4596 };
4597
4598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4599 {
4600 arg1 = wxString_in_helper(obj0);
4601 if (arg1 == NULL) SWIG_fail;
4602 temp1 = true;
4603 }
4604 {
4605 arg2 = wxString_in_helper(obj1);
4606 if (arg2 == NULL) SWIG_fail;
4607 temp2 = true;
4608 }
4609 if (obj2) {
4610 {
4611 arg3 = wxString_in_helper(obj2);
4612 if (arg3 == NULL) SWIG_fail;
4613 temp3 = true;
4614 }
4615 }
4616 if (obj3) {
4617 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4618 if (SWIG_arg_fail(4)) SWIG_fail;
4619 }
4620 {
4621 if (!wxPyCheckForApp()) SWIG_fail;
4622 PyThreadState* __tstate = wxPyBeginAllowThreads();
4623 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4624
4625 wxPyEndAllowThreads(__tstate);
4626 if (PyErr_Occurred()) SWIG_fail;
4627 }
4628 {
4629 #if wxUSE_UNICODE
4630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4631 #else
4632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4633 #endif
4634 }
4635 {
4636 if (temp1)
4637 delete arg1;
4638 }
4639 {
4640 if (temp2)
4641 delete arg2;
4642 }
4643 {
4644 if (temp3)
4645 delete arg3;
4646 }
4647 return resultobj;
4648 fail:
4649 {
4650 if (temp1)
4651 delete arg1;
4652 }
4653 {
4654 if (temp2)
4655 delete arg2;
4656 }
4657 {
4658 if (temp3)
4659 delete arg3;
4660 }
4661 return NULL;
4662 }
4663
4664
4665 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4666 PyObject *resultobj;
4667 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4668 wxString *arg1 = (wxString *) &arg1_defvalue ;
4669 wxString const &arg2_defvalue = wxPyEmptyString ;
4670 wxString *arg2 = (wxString *) &arg2_defvalue ;
4671 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4672 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4673 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4674 wxWindow *arg5 = (wxWindow *) NULL ;
4675 wxString result;
4676 bool temp1 = false ;
4677 bool temp2 = false ;
4678 wxPoint temp4 ;
4679 PyObject * obj0 = 0 ;
4680 PyObject * obj1 = 0 ;
4681 PyObject * obj2 = 0 ;
4682 PyObject * obj3 = 0 ;
4683 PyObject * obj4 = 0 ;
4684 char *kwnames[] = {
4685 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4686 };
4687
4688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4689 if (obj0) {
4690 {
4691 arg1 = wxString_in_helper(obj0);
4692 if (arg1 == NULL) SWIG_fail;
4693 temp1 = true;
4694 }
4695 }
4696 if (obj1) {
4697 {
4698 arg2 = wxString_in_helper(obj1);
4699 if (arg2 == NULL) SWIG_fail;
4700 temp2 = true;
4701 }
4702 }
4703 if (obj2) {
4704 {
4705 arg3 = (long)(SWIG_As_long(obj2));
4706 if (SWIG_arg_fail(3)) SWIG_fail;
4707 }
4708 }
4709 if (obj3) {
4710 {
4711 arg4 = &temp4;
4712 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4713 }
4714 }
4715 if (obj4) {
4716 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4717 if (SWIG_arg_fail(5)) SWIG_fail;
4718 }
4719 {
4720 if (!wxPyCheckForApp()) SWIG_fail;
4721 PyThreadState* __tstate = wxPyBeginAllowThreads();
4722 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4723
4724 wxPyEndAllowThreads(__tstate);
4725 if (PyErr_Occurred()) SWIG_fail;
4726 }
4727 {
4728 #if wxUSE_UNICODE
4729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4730 #else
4731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4732 #endif
4733 }
4734 {
4735 if (temp1)
4736 delete arg1;
4737 }
4738 {
4739 if (temp2)
4740 delete arg2;
4741 }
4742 return resultobj;
4743 fail:
4744 {
4745 if (temp1)
4746 delete arg1;
4747 }
4748 {
4749 if (temp2)
4750 delete arg2;
4751 }
4752 return NULL;
4753 }
4754
4755
4756 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4757 PyObject *resultobj;
4758 wxString *arg1 = 0 ;
4759 wxString const &arg2_defvalue = wxPyEmptyString ;
4760 wxString *arg2 = (wxString *) &arg2_defvalue ;
4761 wxString const &arg3_defvalue = wxPyEmptyString ;
4762 wxString *arg3 = (wxString *) &arg3_defvalue ;
4763 wxWindow *arg4 = (wxWindow *) NULL ;
4764 int arg5 = (int) -1 ;
4765 int arg6 = (int) -1 ;
4766 bool arg7 = (bool) true ;
4767 wxString result;
4768 bool temp1 = false ;
4769 bool temp2 = false ;
4770 bool temp3 = false ;
4771 PyObject * obj0 = 0 ;
4772 PyObject * obj1 = 0 ;
4773 PyObject * obj2 = 0 ;
4774 PyObject * obj3 = 0 ;
4775 PyObject * obj4 = 0 ;
4776 PyObject * obj5 = 0 ;
4777 PyObject * obj6 = 0 ;
4778 char *kwnames[] = {
4779 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4780 };
4781
4782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4783 {
4784 arg1 = wxString_in_helper(obj0);
4785 if (arg1 == NULL) SWIG_fail;
4786 temp1 = true;
4787 }
4788 if (obj1) {
4789 {
4790 arg2 = wxString_in_helper(obj1);
4791 if (arg2 == NULL) SWIG_fail;
4792 temp2 = true;
4793 }
4794 }
4795 if (obj2) {
4796 {
4797 arg3 = wxString_in_helper(obj2);
4798 if (arg3 == NULL) SWIG_fail;
4799 temp3 = true;
4800 }
4801 }
4802 if (obj3) {
4803 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4804 if (SWIG_arg_fail(4)) SWIG_fail;
4805 }
4806 if (obj4) {
4807 {
4808 arg5 = (int)(SWIG_As_int(obj4));
4809 if (SWIG_arg_fail(5)) SWIG_fail;
4810 }
4811 }
4812 if (obj5) {
4813 {
4814 arg6 = (int)(SWIG_As_int(obj5));
4815 if (SWIG_arg_fail(6)) SWIG_fail;
4816 }
4817 }
4818 if (obj6) {
4819 {
4820 arg7 = (bool)(SWIG_As_bool(obj6));
4821 if (SWIG_arg_fail(7)) SWIG_fail;
4822 }
4823 }
4824 {
4825 if (!wxPyCheckForApp()) SWIG_fail;
4826 PyThreadState* __tstate = wxPyBeginAllowThreads();
4827 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4828
4829 wxPyEndAllowThreads(__tstate);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 {
4833 #if wxUSE_UNICODE
4834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4835 #else
4836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4837 #endif
4838 }
4839 {
4840 if (temp1)
4841 delete arg1;
4842 }
4843 {
4844 if (temp2)
4845 delete arg2;
4846 }
4847 {
4848 if (temp3)
4849 delete arg3;
4850 }
4851 return resultobj;
4852 fail:
4853 {
4854 if (temp1)
4855 delete arg1;
4856 }
4857 {
4858 if (temp2)
4859 delete arg2;
4860 }
4861 {
4862 if (temp3)
4863 delete arg3;
4864 }
4865 return NULL;
4866 }
4867
4868
4869 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4870 PyObject *resultobj;
4871 wxString *arg1 = 0 ;
4872 wxString const &arg2_defvalue = wxPyEmptyString ;
4873 wxString *arg2 = (wxString *) &arg2_defvalue ;
4874 wxString const &arg3_defvalue = wxPyEmptyString ;
4875 wxString *arg3 = (wxString *) &arg3_defvalue ;
4876 wxWindow *arg4 = (wxWindow *) NULL ;
4877 wxString result;
4878 bool temp1 = false ;
4879 bool temp2 = false ;
4880 bool temp3 = false ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 PyObject * obj2 = 0 ;
4884 PyObject * obj3 = 0 ;
4885 char *kwnames[] = {
4886 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4887 };
4888
4889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4890 {
4891 arg1 = wxString_in_helper(obj0);
4892 if (arg1 == NULL) SWIG_fail;
4893 temp1 = true;
4894 }
4895 if (obj1) {
4896 {
4897 arg2 = wxString_in_helper(obj1);
4898 if (arg2 == NULL) SWIG_fail;
4899 temp2 = true;
4900 }
4901 }
4902 if (obj2) {
4903 {
4904 arg3 = wxString_in_helper(obj2);
4905 if (arg3 == NULL) SWIG_fail;
4906 temp3 = true;
4907 }
4908 }
4909 if (obj3) {
4910 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4911 if (SWIG_arg_fail(4)) SWIG_fail;
4912 }
4913 {
4914 if (!wxPyCheckForApp()) SWIG_fail;
4915 PyThreadState* __tstate = wxPyBeginAllowThreads();
4916 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4917
4918 wxPyEndAllowThreads(__tstate);
4919 if (PyErr_Occurred()) SWIG_fail;
4920 }
4921 {
4922 #if wxUSE_UNICODE
4923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4924 #else
4925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4926 #endif
4927 }
4928 {
4929 if (temp1)
4930 delete arg1;
4931 }
4932 {
4933 if (temp2)
4934 delete arg2;
4935 }
4936 {
4937 if (temp3)
4938 delete arg3;
4939 }
4940 return resultobj;
4941 fail:
4942 {
4943 if (temp1)
4944 delete arg1;
4945 }
4946 {
4947 if (temp2)
4948 delete arg2;
4949 }
4950 {
4951 if (temp3)
4952 delete arg3;
4953 }
4954 return NULL;
4955 }
4956
4957
4958 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4959 PyObject *resultobj;
4960 wxString *arg1 = 0 ;
4961 wxString *arg2 = 0 ;
4962 int arg3 ;
4963 wxString *arg4 = (wxString *) 0 ;
4964 wxWindow *arg5 = (wxWindow *) NULL ;
4965 int arg6 = (int) -1 ;
4966 int arg7 = (int) -1 ;
4967 bool arg8 = (bool) true ;
4968 int arg9 = (int) 150 ;
4969 int arg10 = (int) 200 ;
4970 wxString result;
4971 bool temp1 = false ;
4972 bool temp2 = false ;
4973 PyObject * obj0 = 0 ;
4974 PyObject * obj1 = 0 ;
4975 PyObject * obj2 = 0 ;
4976 PyObject * obj3 = 0 ;
4977 PyObject * obj4 = 0 ;
4978 PyObject * obj5 = 0 ;
4979 PyObject * obj6 = 0 ;
4980 PyObject * obj7 = 0 ;
4981 PyObject * obj8 = 0 ;
4982 char *kwnames[] = {
4983 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
4984 };
4985
4986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4987 {
4988 arg1 = wxString_in_helper(obj0);
4989 if (arg1 == NULL) SWIG_fail;
4990 temp1 = true;
4991 }
4992 {
4993 arg2 = wxString_in_helper(obj1);
4994 if (arg2 == NULL) SWIG_fail;
4995 temp2 = true;
4996 }
4997 {
4998 arg3 = PyList_Size(obj2);
4999 arg4 = wxString_LIST_helper(obj2);
5000 if (arg4 == NULL) SWIG_fail;
5001 }
5002 if (obj3) {
5003 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5004 if (SWIG_arg_fail(5)) SWIG_fail;
5005 }
5006 if (obj4) {
5007 {
5008 arg6 = (int)(SWIG_As_int(obj4));
5009 if (SWIG_arg_fail(6)) SWIG_fail;
5010 }
5011 }
5012 if (obj5) {
5013 {
5014 arg7 = (int)(SWIG_As_int(obj5));
5015 if (SWIG_arg_fail(7)) SWIG_fail;
5016 }
5017 }
5018 if (obj6) {
5019 {
5020 arg8 = (bool)(SWIG_As_bool(obj6));
5021 if (SWIG_arg_fail(8)) SWIG_fail;
5022 }
5023 }
5024 if (obj7) {
5025 {
5026 arg9 = (int)(SWIG_As_int(obj7));
5027 if (SWIG_arg_fail(9)) SWIG_fail;
5028 }
5029 }
5030 if (obj8) {
5031 {
5032 arg10 = (int)(SWIG_As_int(obj8));
5033 if (SWIG_arg_fail(10)) SWIG_fail;
5034 }
5035 }
5036 {
5037 if (!wxPyCheckForApp()) SWIG_fail;
5038 PyThreadState* __tstate = wxPyBeginAllowThreads();
5039 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5040
5041 wxPyEndAllowThreads(__tstate);
5042 if (PyErr_Occurred()) SWIG_fail;
5043 }
5044 {
5045 #if wxUSE_UNICODE
5046 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5047 #else
5048 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5049 #endif
5050 }
5051 {
5052 if (temp1)
5053 delete arg1;
5054 }
5055 {
5056 if (temp2)
5057 delete arg2;
5058 }
5059 {
5060 if (arg4) delete [] arg4;
5061 }
5062 return resultobj;
5063 fail:
5064 {
5065 if (temp1)
5066 delete arg1;
5067 }
5068 {
5069 if (temp2)
5070 delete arg2;
5071 }
5072 {
5073 if (arg4) delete [] arg4;
5074 }
5075 return NULL;
5076 }
5077
5078
5079 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5080 PyObject *resultobj;
5081 wxString *arg1 = 0 ;
5082 wxString *arg2 = 0 ;
5083 int arg3 ;
5084 wxString *arg4 = (wxString *) 0 ;
5085 wxWindow *arg5 = (wxWindow *) NULL ;
5086 int arg6 = (int) -1 ;
5087 int arg7 = (int) -1 ;
5088 bool arg8 = (bool) true ;
5089 int arg9 = (int) 150 ;
5090 int arg10 = (int) 200 ;
5091 int result;
5092 bool temp1 = false ;
5093 bool temp2 = false ;
5094 PyObject * obj0 = 0 ;
5095 PyObject * obj1 = 0 ;
5096 PyObject * obj2 = 0 ;
5097 PyObject * obj3 = 0 ;
5098 PyObject * obj4 = 0 ;
5099 PyObject * obj5 = 0 ;
5100 PyObject * obj6 = 0 ;
5101 PyObject * obj7 = 0 ;
5102 PyObject * obj8 = 0 ;
5103 char *kwnames[] = {
5104 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5105 };
5106
5107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5108 {
5109 arg1 = wxString_in_helper(obj0);
5110 if (arg1 == NULL) SWIG_fail;
5111 temp1 = true;
5112 }
5113 {
5114 arg2 = wxString_in_helper(obj1);
5115 if (arg2 == NULL) SWIG_fail;
5116 temp2 = true;
5117 }
5118 {
5119 arg3 = PyList_Size(obj2);
5120 arg4 = wxString_LIST_helper(obj2);
5121 if (arg4 == NULL) SWIG_fail;
5122 }
5123 if (obj3) {
5124 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(5)) SWIG_fail;
5126 }
5127 if (obj4) {
5128 {
5129 arg6 = (int)(SWIG_As_int(obj4));
5130 if (SWIG_arg_fail(6)) SWIG_fail;
5131 }
5132 }
5133 if (obj5) {
5134 {
5135 arg7 = (int)(SWIG_As_int(obj5));
5136 if (SWIG_arg_fail(7)) SWIG_fail;
5137 }
5138 }
5139 if (obj6) {
5140 {
5141 arg8 = (bool)(SWIG_As_bool(obj6));
5142 if (SWIG_arg_fail(8)) SWIG_fail;
5143 }
5144 }
5145 if (obj7) {
5146 {
5147 arg9 = (int)(SWIG_As_int(obj7));
5148 if (SWIG_arg_fail(9)) SWIG_fail;
5149 }
5150 }
5151 if (obj8) {
5152 {
5153 arg10 = (int)(SWIG_As_int(obj8));
5154 if (SWIG_arg_fail(10)) SWIG_fail;
5155 }
5156 }
5157 {
5158 if (!wxPyCheckForApp()) SWIG_fail;
5159 PyThreadState* __tstate = wxPyBeginAllowThreads();
5160 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5161
5162 wxPyEndAllowThreads(__tstate);
5163 if (PyErr_Occurred()) SWIG_fail;
5164 }
5165 {
5166 resultobj = SWIG_From_int((int)(result));
5167 }
5168 {
5169 if (temp1)
5170 delete arg1;
5171 }
5172 {
5173 if (temp2)
5174 delete arg2;
5175 }
5176 {
5177 if (arg4) delete [] arg4;
5178 }
5179 return resultobj;
5180 fail:
5181 {
5182 if (temp1)
5183 delete arg1;
5184 }
5185 {
5186 if (temp2)
5187 delete arg2;
5188 }
5189 {
5190 if (arg4) delete [] arg4;
5191 }
5192 return NULL;
5193 }
5194
5195
5196 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5197 PyObject *resultobj;
5198 wxString *arg1 = 0 ;
5199 wxString const &arg2_defvalue = wxPyEmptyString ;
5200 wxString *arg2 = (wxString *) &arg2_defvalue ;
5201 int arg3 = (int) wxOK|wxCENTRE ;
5202 wxWindow *arg4 = (wxWindow *) NULL ;
5203 int arg5 = (int) -1 ;
5204 int arg6 = (int) -1 ;
5205 int result;
5206 bool temp1 = false ;
5207 bool temp2 = false ;
5208 PyObject * obj0 = 0 ;
5209 PyObject * obj1 = 0 ;
5210 PyObject * obj2 = 0 ;
5211 PyObject * obj3 = 0 ;
5212 PyObject * obj4 = 0 ;
5213 PyObject * obj5 = 0 ;
5214 char *kwnames[] = {
5215 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5216 };
5217
5218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5219 {
5220 arg1 = wxString_in_helper(obj0);
5221 if (arg1 == NULL) SWIG_fail;
5222 temp1 = true;
5223 }
5224 if (obj1) {
5225 {
5226 arg2 = wxString_in_helper(obj1);
5227 if (arg2 == NULL) SWIG_fail;
5228 temp2 = true;
5229 }
5230 }
5231 if (obj2) {
5232 {
5233 arg3 = (int)(SWIG_As_int(obj2));
5234 if (SWIG_arg_fail(3)) SWIG_fail;
5235 }
5236 }
5237 if (obj3) {
5238 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5239 if (SWIG_arg_fail(4)) SWIG_fail;
5240 }
5241 if (obj4) {
5242 {
5243 arg5 = (int)(SWIG_As_int(obj4));
5244 if (SWIG_arg_fail(5)) SWIG_fail;
5245 }
5246 }
5247 if (obj5) {
5248 {
5249 arg6 = (int)(SWIG_As_int(obj5));
5250 if (SWIG_arg_fail(6)) SWIG_fail;
5251 }
5252 }
5253 {
5254 if (!wxPyCheckForApp()) SWIG_fail;
5255 PyThreadState* __tstate = wxPyBeginAllowThreads();
5256 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5257
5258 wxPyEndAllowThreads(__tstate);
5259 if (PyErr_Occurred()) SWIG_fail;
5260 }
5261 {
5262 resultobj = SWIG_From_int((int)(result));
5263 }
5264 {
5265 if (temp1)
5266 delete arg1;
5267 }
5268 {
5269 if (temp2)
5270 delete arg2;
5271 }
5272 return resultobj;
5273 fail:
5274 {
5275 if (temp1)
5276 delete arg1;
5277 }
5278 {
5279 if (temp2)
5280 delete arg2;
5281 }
5282 return NULL;
5283 }
5284
5285
5286 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5287 PyObject *resultobj;
5288 wxString *arg1 = 0 ;
5289 wxString *arg2 = 0 ;
5290 wxString *arg3 = 0 ;
5291 long arg4 ;
5292 long arg5 = (long) 0 ;
5293 long arg6 = (long) 100 ;
5294 wxWindow *arg7 = (wxWindow *) NULL ;
5295 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5296 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5297 long result;
5298 bool temp1 = false ;
5299 bool temp2 = false ;
5300 bool temp3 = false ;
5301 wxPoint temp8 ;
5302 PyObject * obj0 = 0 ;
5303 PyObject * obj1 = 0 ;
5304 PyObject * obj2 = 0 ;
5305 PyObject * obj3 = 0 ;
5306 PyObject * obj4 = 0 ;
5307 PyObject * obj5 = 0 ;
5308 PyObject * obj6 = 0 ;
5309 PyObject * obj7 = 0 ;
5310 char *kwnames[] = {
5311 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5312 };
5313
5314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5315 {
5316 arg1 = wxString_in_helper(obj0);
5317 if (arg1 == NULL) SWIG_fail;
5318 temp1 = true;
5319 }
5320 {
5321 arg2 = wxString_in_helper(obj1);
5322 if (arg2 == NULL) SWIG_fail;
5323 temp2 = true;
5324 }
5325 {
5326 arg3 = wxString_in_helper(obj2);
5327 if (arg3 == NULL) SWIG_fail;
5328 temp3 = true;
5329 }
5330 {
5331 arg4 = (long)(SWIG_As_long(obj3));
5332 if (SWIG_arg_fail(4)) SWIG_fail;
5333 }
5334 if (obj4) {
5335 {
5336 arg5 = (long)(SWIG_As_long(obj4));
5337 if (SWIG_arg_fail(5)) SWIG_fail;
5338 }
5339 }
5340 if (obj5) {
5341 {
5342 arg6 = (long)(SWIG_As_long(obj5));
5343 if (SWIG_arg_fail(6)) SWIG_fail;
5344 }
5345 }
5346 if (obj6) {
5347 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5348 if (SWIG_arg_fail(7)) SWIG_fail;
5349 }
5350 if (obj7) {
5351 {
5352 arg8 = &temp8;
5353 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5354 }
5355 }
5356 {
5357 if (!wxPyCheckForApp()) SWIG_fail;
5358 PyThreadState* __tstate = wxPyBeginAllowThreads();
5359 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5360
5361 wxPyEndAllowThreads(__tstate);
5362 if (PyErr_Occurred()) SWIG_fail;
5363 }
5364 {
5365 resultobj = SWIG_From_long((long)(result));
5366 }
5367 {
5368 if (temp1)
5369 delete arg1;
5370 }
5371 {
5372 if (temp2)
5373 delete arg2;
5374 }
5375 {
5376 if (temp3)
5377 delete arg3;
5378 }
5379 return resultobj;
5380 fail:
5381 {
5382 if (temp1)
5383 delete arg1;
5384 }
5385 {
5386 if (temp2)
5387 delete arg2;
5388 }
5389 {
5390 if (temp3)
5391 delete arg3;
5392 }
5393 return NULL;
5394 }
5395
5396
5397 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5398 PyObject *resultobj;
5399 bool result;
5400 char *kwnames[] = {
5401 NULL
5402 };
5403
5404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5405 {
5406 if (!wxPyCheckForApp()) SWIG_fail;
5407 PyThreadState* __tstate = wxPyBeginAllowThreads();
5408 result = (bool)wxColourDisplay();
5409
5410 wxPyEndAllowThreads(__tstate);
5411 if (PyErr_Occurred()) SWIG_fail;
5412 }
5413 {
5414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5415 }
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5423 PyObject *resultobj;
5424 int result;
5425 char *kwnames[] = {
5426 NULL
5427 };
5428
5429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5430 {
5431 if (!wxPyCheckForApp()) SWIG_fail;
5432 PyThreadState* __tstate = wxPyBeginAllowThreads();
5433 result = (int)wxDisplayDepth();
5434
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 {
5439 resultobj = SWIG_From_int((int)(result));
5440 }
5441 return resultobj;
5442 fail:
5443 return NULL;
5444 }
5445
5446
5447 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5448 PyObject *resultobj;
5449 int result;
5450 char *kwnames[] = {
5451 NULL
5452 };
5453
5454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5455 {
5456 if (!wxPyCheckForApp()) SWIG_fail;
5457 PyThreadState* __tstate = wxPyBeginAllowThreads();
5458 result = (int)wxGetDisplayDepth();
5459
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 {
5464 resultobj = SWIG_From_int((int)(result));
5465 }
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5473 PyObject *resultobj;
5474 int *arg1 = (int *) 0 ;
5475 int *arg2 = (int *) 0 ;
5476 int temp1 ;
5477 int res1 = 0 ;
5478 int temp2 ;
5479 int res2 = 0 ;
5480 char *kwnames[] = {
5481 NULL
5482 };
5483
5484 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5485 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5487 {
5488 if (!wxPyCheckForApp()) SWIG_fail;
5489 PyThreadState* __tstate = wxPyBeginAllowThreads();
5490 wxDisplaySize(arg1,arg2);
5491
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 Py_INCREF(Py_None); resultobj = Py_None;
5496 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5497 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5498 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5499 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj;
5508 wxSize result;
5509 char *kwnames[] = {
5510 NULL
5511 };
5512
5513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5514 {
5515 if (!wxPyCheckForApp()) SWIG_fail;
5516 PyThreadState* __tstate = wxPyBeginAllowThreads();
5517 result = wxGetDisplaySize();
5518
5519 wxPyEndAllowThreads(__tstate);
5520 if (PyErr_Occurred()) SWIG_fail;
5521 }
5522 {
5523 wxSize * resultptr;
5524 resultptr = new wxSize((wxSize &)(result));
5525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5526 }
5527 return resultobj;
5528 fail:
5529 return NULL;
5530 }
5531
5532
5533 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5534 PyObject *resultobj;
5535 int *arg1 = (int *) 0 ;
5536 int *arg2 = (int *) 0 ;
5537 int temp1 ;
5538 int res1 = 0 ;
5539 int temp2 ;
5540 int res2 = 0 ;
5541 char *kwnames[] = {
5542 NULL
5543 };
5544
5545 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5546 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5548 {
5549 if (!wxPyCheckForApp()) SWIG_fail;
5550 PyThreadState* __tstate = wxPyBeginAllowThreads();
5551 wxDisplaySizeMM(arg1,arg2);
5552
5553 wxPyEndAllowThreads(__tstate);
5554 if (PyErr_Occurred()) SWIG_fail;
5555 }
5556 Py_INCREF(Py_None); resultobj = Py_None;
5557 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5558 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5559 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5560 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5561 return resultobj;
5562 fail:
5563 return NULL;
5564 }
5565
5566
5567 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5568 PyObject *resultobj;
5569 wxSize result;
5570 char *kwnames[] = {
5571 NULL
5572 };
5573
5574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5575 {
5576 if (!wxPyCheckForApp()) SWIG_fail;
5577 PyThreadState* __tstate = wxPyBeginAllowThreads();
5578 result = wxGetDisplaySizeMM();
5579
5580 wxPyEndAllowThreads(__tstate);
5581 if (PyErr_Occurred()) SWIG_fail;
5582 }
5583 {
5584 wxSize * resultptr;
5585 resultptr = new wxSize((wxSize &)(result));
5586 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5587 }
5588 return resultobj;
5589 fail:
5590 return NULL;
5591 }
5592
5593
5594 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5595 PyObject *resultobj;
5596 int *arg1 = (int *) 0 ;
5597 int *arg2 = (int *) 0 ;
5598 int *arg3 = (int *) 0 ;
5599 int *arg4 = (int *) 0 ;
5600 int temp1 ;
5601 int res1 = 0 ;
5602 int temp2 ;
5603 int res2 = 0 ;
5604 int temp3 ;
5605 int res3 = 0 ;
5606 int temp4 ;
5607 int res4 = 0 ;
5608 char *kwnames[] = {
5609 NULL
5610 };
5611
5612 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5613 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5614 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5615 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5617 {
5618 if (!wxPyCheckForApp()) SWIG_fail;
5619 PyThreadState* __tstate = wxPyBeginAllowThreads();
5620 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5621
5622 wxPyEndAllowThreads(__tstate);
5623 if (PyErr_Occurred()) SWIG_fail;
5624 }
5625 Py_INCREF(Py_None); resultobj = Py_None;
5626 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5627 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5628 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5629 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5630 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5631 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5632 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5633 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5641 PyObject *resultobj;
5642 wxRect result;
5643 char *kwnames[] = {
5644 NULL
5645 };
5646
5647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5648 {
5649 if (!wxPyCheckForApp()) SWIG_fail;
5650 PyThreadState* __tstate = wxPyBeginAllowThreads();
5651 result = wxGetClientDisplayRect();
5652
5653 wxPyEndAllowThreads(__tstate);
5654 if (PyErr_Occurred()) SWIG_fail;
5655 }
5656 {
5657 wxRect * resultptr;
5658 resultptr = new wxRect((wxRect &)(result));
5659 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5660 }
5661 return resultobj;
5662 fail:
5663 return NULL;
5664 }
5665
5666
5667 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5668 PyObject *resultobj;
5669 wxCursor *arg1 = 0 ;
5670 PyObject * obj0 = 0 ;
5671 char *kwnames[] = {
5672 (char *) "cursor", NULL
5673 };
5674
5675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5676 {
5677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5678 if (SWIG_arg_fail(1)) SWIG_fail;
5679 if (arg1 == NULL) {
5680 SWIG_null_ref("wxCursor");
5681 }
5682 if (SWIG_arg_fail(1)) SWIG_fail;
5683 }
5684 {
5685 if (!wxPyCheckForApp()) SWIG_fail;
5686 PyThreadState* __tstate = wxPyBeginAllowThreads();
5687 wxSetCursor(*arg1);
5688
5689 wxPyEndAllowThreads(__tstate);
5690 if (PyErr_Occurred()) SWIG_fail;
5691 }
5692 Py_INCREF(Py_None); resultobj = Py_None;
5693 return resultobj;
5694 fail:
5695 return NULL;
5696 }
5697
5698
5699 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5700 PyObject *resultobj;
5701 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5702 PyObject * obj0 = 0 ;
5703 char *kwnames[] = {
5704 (char *) "cursor", NULL
5705 };
5706
5707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5708 if (obj0) {
5709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5710 if (SWIG_arg_fail(1)) SWIG_fail;
5711 }
5712 {
5713 if (!wxPyCheckForApp()) SWIG_fail;
5714 PyThreadState* __tstate = wxPyBeginAllowThreads();
5715 wxBeginBusyCursor(arg1);
5716
5717 wxPyEndAllowThreads(__tstate);
5718 if (PyErr_Occurred()) SWIG_fail;
5719 }
5720 Py_INCREF(Py_None); resultobj = Py_None;
5721 return resultobj;
5722 fail:
5723 return NULL;
5724 }
5725
5726
5727 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5728 PyObject *resultobj;
5729 wxWindow *result;
5730 char *kwnames[] = {
5731 NULL
5732 };
5733
5734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5735 {
5736 if (!wxPyCheckForApp()) SWIG_fail;
5737 PyThreadState* __tstate = wxPyBeginAllowThreads();
5738 result = (wxWindow *)wxGetActiveWindow();
5739
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 {
5744 resultobj = wxPyMake_wxObject(result, 0);
5745 }
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj;
5754 wxPoint *arg1 = 0 ;
5755 wxWindow *result;
5756 wxPoint temp1 ;
5757 PyObject * obj0 = 0 ;
5758 char *kwnames[] = {
5759 (char *) "pt", NULL
5760 };
5761
5762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5763 {
5764 arg1 = &temp1;
5765 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5766 }
5767 {
5768 if (!wxPyCheckForApp()) SWIG_fail;
5769 PyThreadState* __tstate = wxPyBeginAllowThreads();
5770 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5771
5772 wxPyEndAllowThreads(__tstate);
5773 if (PyErr_Occurred()) SWIG_fail;
5774 }
5775 {
5776 resultobj = wxPyMake_wxObject(result, 0);
5777 }
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj;
5786 wxPoint *arg1 = 0 ;
5787 wxWindow *result;
5788 wxPoint temp1 ;
5789 PyObject * obj0 = 0 ;
5790 char *kwnames[] = {
5791 (char *) "pt", NULL
5792 };
5793
5794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5795 {
5796 arg1 = &temp1;
5797 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5798 }
5799 {
5800 if (!wxPyCheckForApp()) SWIG_fail;
5801 PyThreadState* __tstate = wxPyBeginAllowThreads();
5802 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5803
5804 wxPyEndAllowThreads(__tstate);
5805 if (PyErr_Occurred()) SWIG_fail;
5806 }
5807 {
5808 resultobj = wxPyMake_wxObject(result, 0);
5809 }
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj;
5818 wxWindow *arg1 = (wxWindow *) 0 ;
5819 wxWindow *result;
5820 PyObject * obj0 = 0 ;
5821 char *kwnames[] = {
5822 (char *) "win", NULL
5823 };
5824
5825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5827 if (SWIG_arg_fail(1)) SWIG_fail;
5828 {
5829 if (!wxPyCheckForApp()) SWIG_fail;
5830 PyThreadState* __tstate = wxPyBeginAllowThreads();
5831 result = (wxWindow *)wxGetTopLevelParent(arg1);
5832
5833 wxPyEndAllowThreads(__tstate);
5834 if (PyErr_Occurred()) SWIG_fail;
5835 }
5836 {
5837 resultobj = wxPyMake_wxObject(result, 0);
5838 }
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj;
5847 wxKeyCode arg1 ;
5848 bool result;
5849 PyObject * obj0 = 0 ;
5850 char *kwnames[] = {
5851 (char *) "key", NULL
5852 };
5853
5854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5855 {
5856 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5857 if (SWIG_arg_fail(1)) SWIG_fail;
5858 }
5859 {
5860 if (!wxPyCheckForApp()) SWIG_fail;
5861 PyThreadState* __tstate = wxPyBeginAllowThreads();
5862 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5863
5864 wxPyEndAllowThreads(__tstate);
5865 if (PyErr_Occurred()) SWIG_fail;
5866 }
5867 {
5868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5869 }
5870 return resultobj;
5871 fail:
5872 return NULL;
5873 }
5874
5875
5876 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5877 PyObject *resultobj;
5878 char *kwnames[] = {
5879 NULL
5880 };
5881
5882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5883 {
5884 if (!wxPyCheckForApp()) SWIG_fail;
5885 PyThreadState* __tstate = wxPyBeginAllowThreads();
5886 wxWakeUpMainThread();
5887
5888 wxPyEndAllowThreads(__tstate);
5889 if (PyErr_Occurred()) SWIG_fail;
5890 }
5891 Py_INCREF(Py_None); resultobj = Py_None;
5892 return resultobj;
5893 fail:
5894 return NULL;
5895 }
5896
5897
5898 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5899 PyObject *resultobj;
5900 char *kwnames[] = {
5901 NULL
5902 };
5903
5904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5905 {
5906 if (!wxPyCheckForApp()) SWIG_fail;
5907 PyThreadState* __tstate = wxPyBeginAllowThreads();
5908 wxMutexGuiEnter();
5909
5910 wxPyEndAllowThreads(__tstate);
5911 if (PyErr_Occurred()) SWIG_fail;
5912 }
5913 Py_INCREF(Py_None); resultobj = Py_None;
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj;
5922 char *kwnames[] = {
5923 NULL
5924 };
5925
5926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5927 {
5928 if (!wxPyCheckForApp()) SWIG_fail;
5929 PyThreadState* __tstate = wxPyBeginAllowThreads();
5930 wxMutexGuiLeave();
5931
5932 wxPyEndAllowThreads(__tstate);
5933 if (PyErr_Occurred()) SWIG_fail;
5934 }
5935 Py_INCREF(Py_None); resultobj = Py_None;
5936 return resultobj;
5937 fail:
5938 return NULL;
5939 }
5940
5941
5942 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5943 PyObject *resultobj;
5944 wxMutexGuiLocker *result;
5945 char *kwnames[] = {
5946 NULL
5947 };
5948
5949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5950 {
5951 if (!wxPyCheckForApp()) SWIG_fail;
5952 PyThreadState* __tstate = wxPyBeginAllowThreads();
5953 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5954
5955 wxPyEndAllowThreads(__tstate);
5956 if (PyErr_Occurred()) SWIG_fail;
5957 }
5958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5959 return resultobj;
5960 fail:
5961 return NULL;
5962 }
5963
5964
5965 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5966 PyObject *resultobj;
5967 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5968 PyObject * obj0 = 0 ;
5969 char *kwnames[] = {
5970 (char *) "self", NULL
5971 };
5972
5973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5975 if (SWIG_arg_fail(1)) SWIG_fail;
5976 {
5977 PyThreadState* __tstate = wxPyBeginAllowThreads();
5978 delete arg1;
5979
5980 wxPyEndAllowThreads(__tstate);
5981 if (PyErr_Occurred()) SWIG_fail;
5982 }
5983 Py_INCREF(Py_None); resultobj = Py_None;
5984 return resultobj;
5985 fail:
5986 return NULL;
5987 }
5988
5989
5990 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
5991 PyObject *obj;
5992 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5993 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
5994 Py_INCREF(obj);
5995 return Py_BuildValue((char *)"");
5996 }
5997 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
5998 PyObject *resultobj;
5999 bool result;
6000 char *kwnames[] = {
6001 NULL
6002 };
6003
6004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6005 {
6006 PyThreadState* __tstate = wxPyBeginAllowThreads();
6007 result = (bool)wxThread_IsMain();
6008
6009 wxPyEndAllowThreads(__tstate);
6010 if (PyErr_Occurred()) SWIG_fail;
6011 }
6012 {
6013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6014 }
6015 return resultobj;
6016 fail:
6017 return NULL;
6018 }
6019
6020
6021 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6022 PyObject *resultobj;
6023 wxString *arg1 = 0 ;
6024 wxToolTip *result;
6025 bool temp1 = false ;
6026 PyObject * obj0 = 0 ;
6027 char *kwnames[] = {
6028 (char *) "tip", NULL
6029 };
6030
6031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6032 {
6033 arg1 = wxString_in_helper(obj0);
6034 if (arg1 == NULL) SWIG_fail;
6035 temp1 = true;
6036 }
6037 {
6038 if (!wxPyCheckForApp()) SWIG_fail;
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6041
6042 wxPyEndAllowThreads(__tstate);
6043 if (PyErr_Occurred()) SWIG_fail;
6044 }
6045 {
6046 resultobj = wxPyMake_wxObject(result, 1);
6047 }
6048 {
6049 if (temp1)
6050 delete arg1;
6051 }
6052 return resultobj;
6053 fail:
6054 {
6055 if (temp1)
6056 delete arg1;
6057 }
6058 return NULL;
6059 }
6060
6061
6062 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6063 PyObject *resultobj;
6064 wxToolTip *arg1 = (wxToolTip *) 0 ;
6065 wxString *arg2 = 0 ;
6066 bool temp2 = false ;
6067 PyObject * obj0 = 0 ;
6068 PyObject * obj1 = 0 ;
6069 char *kwnames[] = {
6070 (char *) "self",(char *) "tip", NULL
6071 };
6072
6073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6075 if (SWIG_arg_fail(1)) SWIG_fail;
6076 {
6077 arg2 = wxString_in_helper(obj1);
6078 if (arg2 == NULL) SWIG_fail;
6079 temp2 = true;
6080 }
6081 {
6082 PyThreadState* __tstate = wxPyBeginAllowThreads();
6083 (arg1)->SetTip((wxString const &)*arg2);
6084
6085 wxPyEndAllowThreads(__tstate);
6086 if (PyErr_Occurred()) SWIG_fail;
6087 }
6088 Py_INCREF(Py_None); resultobj = Py_None;
6089 {
6090 if (temp2)
6091 delete arg2;
6092 }
6093 return resultobj;
6094 fail:
6095 {
6096 if (temp2)
6097 delete arg2;
6098 }
6099 return NULL;
6100 }
6101
6102
6103 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6104 PyObject *resultobj;
6105 wxToolTip *arg1 = (wxToolTip *) 0 ;
6106 wxString result;
6107 PyObject * obj0 = 0 ;
6108 char *kwnames[] = {
6109 (char *) "self", NULL
6110 };
6111
6112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6114 if (SWIG_arg_fail(1)) SWIG_fail;
6115 {
6116 PyThreadState* __tstate = wxPyBeginAllowThreads();
6117 result = (arg1)->GetTip();
6118
6119 wxPyEndAllowThreads(__tstate);
6120 if (PyErr_Occurred()) SWIG_fail;
6121 }
6122 {
6123 #if wxUSE_UNICODE
6124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6125 #else
6126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6127 #endif
6128 }
6129 return resultobj;
6130 fail:
6131 return NULL;
6132 }
6133
6134
6135 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6136 PyObject *resultobj;
6137 wxToolTip *arg1 = (wxToolTip *) 0 ;
6138 wxWindow *result;
6139 PyObject * obj0 = 0 ;
6140 char *kwnames[] = {
6141 (char *) "self", NULL
6142 };
6143
6144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6146 if (SWIG_arg_fail(1)) SWIG_fail;
6147 {
6148 PyThreadState* __tstate = wxPyBeginAllowThreads();
6149 result = (wxWindow *)(arg1)->GetWindow();
6150
6151 wxPyEndAllowThreads(__tstate);
6152 if (PyErr_Occurred()) SWIG_fail;
6153 }
6154 {
6155 resultobj = wxPyMake_wxObject(result, 0);
6156 }
6157 return resultobj;
6158 fail:
6159 return NULL;
6160 }
6161
6162
6163 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6164 PyObject *resultobj;
6165 bool arg1 ;
6166 PyObject * obj0 = 0 ;
6167 char *kwnames[] = {
6168 (char *) "flag", NULL
6169 };
6170
6171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6172 {
6173 arg1 = (bool)(SWIG_As_bool(obj0));
6174 if (SWIG_arg_fail(1)) SWIG_fail;
6175 }
6176 {
6177 PyThreadState* __tstate = wxPyBeginAllowThreads();
6178 wxToolTip::Enable(arg1);
6179
6180 wxPyEndAllowThreads(__tstate);
6181 if (PyErr_Occurred()) SWIG_fail;
6182 }
6183 Py_INCREF(Py_None); resultobj = Py_None;
6184 return resultobj;
6185 fail:
6186 return NULL;
6187 }
6188
6189
6190 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6191 PyObject *resultobj;
6192 long arg1 ;
6193 PyObject * obj0 = 0 ;
6194 char *kwnames[] = {
6195 (char *) "milliseconds", NULL
6196 };
6197
6198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6199 {
6200 arg1 = (long)(SWIG_As_long(obj0));
6201 if (SWIG_arg_fail(1)) SWIG_fail;
6202 }
6203 {
6204 PyThreadState* __tstate = wxPyBeginAllowThreads();
6205 wxToolTip::SetDelay(arg1);
6206
6207 wxPyEndAllowThreads(__tstate);
6208 if (PyErr_Occurred()) SWIG_fail;
6209 }
6210 Py_INCREF(Py_None); resultobj = Py_None;
6211 return resultobj;
6212 fail:
6213 return NULL;
6214 }
6215
6216
6217 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6218 PyObject *obj;
6219 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6220 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6221 Py_INCREF(obj);
6222 return Py_BuildValue((char *)"");
6223 }
6224 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6225 PyObject *resultobj;
6226 wxWindow *arg1 = (wxWindow *) 0 ;
6227 wxSize *arg2 = 0 ;
6228 wxCaret *result;
6229 wxSize temp2 ;
6230 PyObject * obj0 = 0 ;
6231 PyObject * obj1 = 0 ;
6232 char *kwnames[] = {
6233 (char *) "window",(char *) "size", NULL
6234 };
6235
6236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6238 if (SWIG_arg_fail(1)) SWIG_fail;
6239 {
6240 arg2 = &temp2;
6241 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6242 }
6243 {
6244 if (!wxPyCheckForApp()) SWIG_fail;
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6247
6248 wxPyEndAllowThreads(__tstate);
6249 if (PyErr_Occurred()) SWIG_fail;
6250 }
6251 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6252 return resultobj;
6253 fail:
6254 return NULL;
6255 }
6256
6257
6258 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6259 PyObject *resultobj;
6260 wxCaret *arg1 = (wxCaret *) 0 ;
6261 PyObject * obj0 = 0 ;
6262 char *kwnames[] = {
6263 (char *) "self", NULL
6264 };
6265
6266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6268 if (SWIG_arg_fail(1)) SWIG_fail;
6269 {
6270 PyThreadState* __tstate = wxPyBeginAllowThreads();
6271 wxCaret_Destroy(arg1);
6272
6273 wxPyEndAllowThreads(__tstate);
6274 if (PyErr_Occurred()) SWIG_fail;
6275 }
6276 Py_INCREF(Py_None); resultobj = Py_None;
6277 return resultobj;
6278 fail:
6279 return NULL;
6280 }
6281
6282
6283 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6284 PyObject *resultobj;
6285 wxCaret *arg1 = (wxCaret *) 0 ;
6286 bool result;
6287 PyObject * obj0 = 0 ;
6288 char *kwnames[] = {
6289 (char *) "self", NULL
6290 };
6291
6292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6294 if (SWIG_arg_fail(1)) SWIG_fail;
6295 {
6296 PyThreadState* __tstate = wxPyBeginAllowThreads();
6297 result = (bool)(arg1)->IsOk();
6298
6299 wxPyEndAllowThreads(__tstate);
6300 if (PyErr_Occurred()) SWIG_fail;
6301 }
6302 {
6303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6304 }
6305 return resultobj;
6306 fail:
6307 return NULL;
6308 }
6309
6310
6311 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6312 PyObject *resultobj;
6313 wxCaret *arg1 = (wxCaret *) 0 ;
6314 bool result;
6315 PyObject * obj0 = 0 ;
6316 char *kwnames[] = {
6317 (char *) "self", NULL
6318 };
6319
6320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6322 if (SWIG_arg_fail(1)) SWIG_fail;
6323 {
6324 PyThreadState* __tstate = wxPyBeginAllowThreads();
6325 result = (bool)(arg1)->IsVisible();
6326
6327 wxPyEndAllowThreads(__tstate);
6328 if (PyErr_Occurred()) SWIG_fail;
6329 }
6330 {
6331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6332 }
6333 return resultobj;
6334 fail:
6335 return NULL;
6336 }
6337
6338
6339 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6340 PyObject *resultobj;
6341 wxCaret *arg1 = (wxCaret *) 0 ;
6342 wxPoint result;
6343 PyObject * obj0 = 0 ;
6344 char *kwnames[] = {
6345 (char *) "self", NULL
6346 };
6347
6348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6350 if (SWIG_arg_fail(1)) SWIG_fail;
6351 {
6352 PyThreadState* __tstate = wxPyBeginAllowThreads();
6353 result = (arg1)->GetPosition();
6354
6355 wxPyEndAllowThreads(__tstate);
6356 if (PyErr_Occurred()) SWIG_fail;
6357 }
6358 {
6359 wxPoint * resultptr;
6360 resultptr = new wxPoint((wxPoint &)(result));
6361 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6362 }
6363 return resultobj;
6364 fail:
6365 return NULL;
6366 }
6367
6368
6369 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6370 PyObject *resultobj;
6371 wxCaret *arg1 = (wxCaret *) 0 ;
6372 int *arg2 = (int *) 0 ;
6373 int *arg3 = (int *) 0 ;
6374 int temp2 ;
6375 int res2 = 0 ;
6376 int temp3 ;
6377 int res3 = 0 ;
6378 PyObject * obj0 = 0 ;
6379 char *kwnames[] = {
6380 (char *) "self", NULL
6381 };
6382
6383 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6384 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6387 if (SWIG_arg_fail(1)) SWIG_fail;
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 (arg1)->GetPosition(arg2,arg3);
6391
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 Py_INCREF(Py_None); resultobj = Py_None;
6396 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6397 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6398 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6399 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6400 return resultobj;
6401 fail:
6402 return NULL;
6403 }
6404
6405
6406 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6407 PyObject *resultobj;
6408 wxCaret *arg1 = (wxCaret *) 0 ;
6409 wxSize result;
6410 PyObject * obj0 = 0 ;
6411 char *kwnames[] = {
6412 (char *) "self", NULL
6413 };
6414
6415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6417 if (SWIG_arg_fail(1)) SWIG_fail;
6418 {
6419 PyThreadState* __tstate = wxPyBeginAllowThreads();
6420 result = (arg1)->GetSize();
6421
6422 wxPyEndAllowThreads(__tstate);
6423 if (PyErr_Occurred()) SWIG_fail;
6424 }
6425 {
6426 wxSize * resultptr;
6427 resultptr = new wxSize((wxSize &)(result));
6428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6429 }
6430 return resultobj;
6431 fail:
6432 return NULL;
6433 }
6434
6435
6436 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6437 PyObject *resultobj;
6438 wxCaret *arg1 = (wxCaret *) 0 ;
6439 int *arg2 = (int *) 0 ;
6440 int *arg3 = (int *) 0 ;
6441 int temp2 ;
6442 int res2 = 0 ;
6443 int temp3 ;
6444 int res3 = 0 ;
6445 PyObject * obj0 = 0 ;
6446 char *kwnames[] = {
6447 (char *) "self", NULL
6448 };
6449
6450 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6451 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6454 if (SWIG_arg_fail(1)) SWIG_fail;
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 (arg1)->GetSize(arg2,arg3);
6458
6459 wxPyEndAllowThreads(__tstate);
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 Py_INCREF(Py_None); resultobj = Py_None;
6463 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6464 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6465 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6466 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6467 return resultobj;
6468 fail:
6469 return NULL;
6470 }
6471
6472
6473 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6474 PyObject *resultobj;
6475 wxCaret *arg1 = (wxCaret *) 0 ;
6476 wxWindow *result;
6477 PyObject * obj0 = 0 ;
6478 char *kwnames[] = {
6479 (char *) "self", NULL
6480 };
6481
6482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6484 if (SWIG_arg_fail(1)) SWIG_fail;
6485 {
6486 PyThreadState* __tstate = wxPyBeginAllowThreads();
6487 result = (wxWindow *)(arg1)->GetWindow();
6488
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 {
6493 resultobj = wxPyMake_wxObject(result, 0);
6494 }
6495 return resultobj;
6496 fail:
6497 return NULL;
6498 }
6499
6500
6501 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6502 PyObject *resultobj;
6503 wxCaret *arg1 = (wxCaret *) 0 ;
6504 int arg2 ;
6505 int arg3 ;
6506 PyObject * obj0 = 0 ;
6507 PyObject * obj1 = 0 ;
6508 PyObject * obj2 = 0 ;
6509 char *kwnames[] = {
6510 (char *) "self",(char *) "x",(char *) "y", NULL
6511 };
6512
6513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6515 if (SWIG_arg_fail(1)) SWIG_fail;
6516 {
6517 arg2 = (int)(SWIG_As_int(obj1));
6518 if (SWIG_arg_fail(2)) SWIG_fail;
6519 }
6520 {
6521 arg3 = (int)(SWIG_As_int(obj2));
6522 if (SWIG_arg_fail(3)) SWIG_fail;
6523 }
6524 {
6525 PyThreadState* __tstate = wxPyBeginAllowThreads();
6526 (arg1)->Move(arg2,arg3);
6527
6528 wxPyEndAllowThreads(__tstate);
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 Py_INCREF(Py_None); resultobj = Py_None;
6532 return resultobj;
6533 fail:
6534 return NULL;
6535 }
6536
6537
6538 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6539 PyObject *resultobj;
6540 wxCaret *arg1 = (wxCaret *) 0 ;
6541 wxPoint *arg2 = 0 ;
6542 wxPoint temp2 ;
6543 PyObject * obj0 = 0 ;
6544 PyObject * obj1 = 0 ;
6545 char *kwnames[] = {
6546 (char *) "self",(char *) "pt", NULL
6547 };
6548
6549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
6554 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6555 }
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 (arg1)->Move((wxPoint const &)*arg2);
6559
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 Py_INCREF(Py_None); resultobj = Py_None;
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj;
6572 wxCaret *arg1 = (wxCaret *) 0 ;
6573 int arg2 ;
6574 int arg3 ;
6575 PyObject * obj0 = 0 ;
6576 PyObject * obj1 = 0 ;
6577 PyObject * obj2 = 0 ;
6578 char *kwnames[] = {
6579 (char *) "self",(char *) "width",(char *) "height", NULL
6580 };
6581
6582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6584 if (SWIG_arg_fail(1)) SWIG_fail;
6585 {
6586 arg2 = (int)(SWIG_As_int(obj1));
6587 if (SWIG_arg_fail(2)) SWIG_fail;
6588 }
6589 {
6590 arg3 = (int)(SWIG_As_int(obj2));
6591 if (SWIG_arg_fail(3)) SWIG_fail;
6592 }
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->SetSize(arg2,arg3);
6596
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 Py_INCREF(Py_None); resultobj = Py_None;
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6608 PyObject *resultobj;
6609 wxCaret *arg1 = (wxCaret *) 0 ;
6610 wxSize *arg2 = 0 ;
6611 wxSize temp2 ;
6612 PyObject * obj0 = 0 ;
6613 PyObject * obj1 = 0 ;
6614 char *kwnames[] = {
6615 (char *) "self",(char *) "size", NULL
6616 };
6617
6618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6620 if (SWIG_arg_fail(1)) SWIG_fail;
6621 {
6622 arg2 = &temp2;
6623 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6624 }
6625 {
6626 PyThreadState* __tstate = wxPyBeginAllowThreads();
6627 (arg1)->SetSize((wxSize const &)*arg2);
6628
6629 wxPyEndAllowThreads(__tstate);
6630 if (PyErr_Occurred()) SWIG_fail;
6631 }
6632 Py_INCREF(Py_None); resultobj = Py_None;
6633 return resultobj;
6634 fail:
6635 return NULL;
6636 }
6637
6638
6639 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6640 PyObject *resultobj;
6641 wxCaret *arg1 = (wxCaret *) 0 ;
6642 int arg2 = (int) true ;
6643 PyObject * obj0 = 0 ;
6644 PyObject * obj1 = 0 ;
6645 char *kwnames[] = {
6646 (char *) "self",(char *) "show", NULL
6647 };
6648
6649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6651 if (SWIG_arg_fail(1)) SWIG_fail;
6652 if (obj1) {
6653 {
6654 arg2 = (int)(SWIG_As_int(obj1));
6655 if (SWIG_arg_fail(2)) SWIG_fail;
6656 }
6657 }
6658 {
6659 PyThreadState* __tstate = wxPyBeginAllowThreads();
6660 (arg1)->Show(arg2);
6661
6662 wxPyEndAllowThreads(__tstate);
6663 if (PyErr_Occurred()) SWIG_fail;
6664 }
6665 Py_INCREF(Py_None); resultobj = Py_None;
6666 return resultobj;
6667 fail:
6668 return NULL;
6669 }
6670
6671
6672 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6673 PyObject *resultobj;
6674 wxCaret *arg1 = (wxCaret *) 0 ;
6675 PyObject * obj0 = 0 ;
6676 char *kwnames[] = {
6677 (char *) "self", NULL
6678 };
6679
6680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6682 if (SWIG_arg_fail(1)) SWIG_fail;
6683 {
6684 PyThreadState* __tstate = wxPyBeginAllowThreads();
6685 (arg1)->Hide();
6686
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 Py_INCREF(Py_None); resultobj = Py_None;
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6698 PyObject *resultobj;
6699 int result;
6700 char *kwnames[] = {
6701 NULL
6702 };
6703
6704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6705 {
6706 PyThreadState* __tstate = wxPyBeginAllowThreads();
6707 result = (int)wxCaret::GetBlinkTime();
6708
6709 wxPyEndAllowThreads(__tstate);
6710 if (PyErr_Occurred()) SWIG_fail;
6711 }
6712 {
6713 resultobj = SWIG_From_int((int)(result));
6714 }
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6722 PyObject *resultobj;
6723 int arg1 ;
6724 PyObject * obj0 = 0 ;
6725 char *kwnames[] = {
6726 (char *) "milliseconds", NULL
6727 };
6728
6729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6730 {
6731 arg1 = (int)(SWIG_As_int(obj0));
6732 if (SWIG_arg_fail(1)) SWIG_fail;
6733 }
6734 {
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 wxCaret::SetBlinkTime(arg1);
6737
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 Py_INCREF(Py_None); resultobj = Py_None;
6742 return resultobj;
6743 fail:
6744 return NULL;
6745 }
6746
6747
6748 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6749 PyObject *obj;
6750 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6751 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6752 Py_INCREF(obj);
6753 return Py_BuildValue((char *)"");
6754 }
6755 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6756 PyObject *resultobj;
6757 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6758 wxBusyCursor *result;
6759 PyObject * obj0 = 0 ;
6760 char *kwnames[] = {
6761 (char *) "cursor", NULL
6762 };
6763
6764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6765 if (obj0) {
6766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6767 if (SWIG_arg_fail(1)) SWIG_fail;
6768 }
6769 {
6770 if (!wxPyCheckForApp()) SWIG_fail;
6771 PyThreadState* __tstate = wxPyBeginAllowThreads();
6772 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6773
6774 wxPyEndAllowThreads(__tstate);
6775 if (PyErr_Occurred()) SWIG_fail;
6776 }
6777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6785 PyObject *resultobj;
6786 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6787 PyObject * obj0 = 0 ;
6788 char *kwnames[] = {
6789 (char *) "self", NULL
6790 };
6791
6792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6794 if (SWIG_arg_fail(1)) SWIG_fail;
6795 {
6796 PyThreadState* __tstate = wxPyBeginAllowThreads();
6797 delete arg1;
6798
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 Py_INCREF(Py_None); resultobj = Py_None;
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6810 PyObject *obj;
6811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6812 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6813 Py_INCREF(obj);
6814 return Py_BuildValue((char *)"");
6815 }
6816 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6817 PyObject *resultobj;
6818 wxWindow *arg1 = (wxWindow *) NULL ;
6819 wxWindowDisabler *result;
6820 PyObject * obj0 = 0 ;
6821 char *kwnames[] = {
6822 (char *) "winToSkip", NULL
6823 };
6824
6825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6826 if (obj0) {
6827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6828 if (SWIG_arg_fail(1)) SWIG_fail;
6829 }
6830 {
6831 if (!wxPyCheckForApp()) SWIG_fail;
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6834
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj;
6847 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6848 PyObject * obj0 = 0 ;
6849 char *kwnames[] = {
6850 (char *) "self", NULL
6851 };
6852
6853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6855 if (SWIG_arg_fail(1)) SWIG_fail;
6856 {
6857 PyThreadState* __tstate = wxPyBeginAllowThreads();
6858 delete arg1;
6859
6860 wxPyEndAllowThreads(__tstate);
6861 if (PyErr_Occurred()) SWIG_fail;
6862 }
6863 Py_INCREF(Py_None); resultobj = Py_None;
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6871 PyObject *obj;
6872 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6873 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6874 Py_INCREF(obj);
6875 return Py_BuildValue((char *)"");
6876 }
6877 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6878 PyObject *resultobj;
6879 wxString *arg1 = 0 ;
6880 wxBusyInfo *result;
6881 bool temp1 = false ;
6882 PyObject * obj0 = 0 ;
6883 char *kwnames[] = {
6884 (char *) "message", NULL
6885 };
6886
6887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6888 {
6889 arg1 = wxString_in_helper(obj0);
6890 if (arg1 == NULL) SWIG_fail;
6891 temp1 = true;
6892 }
6893 {
6894 if (!wxPyCheckForApp()) SWIG_fail;
6895 PyThreadState* __tstate = wxPyBeginAllowThreads();
6896 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6897
6898 wxPyEndAllowThreads(__tstate);
6899 if (PyErr_Occurred()) SWIG_fail;
6900 }
6901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6902 {
6903 if (temp1)
6904 delete arg1;
6905 }
6906 return resultobj;
6907 fail:
6908 {
6909 if (temp1)
6910 delete arg1;
6911 }
6912 return NULL;
6913 }
6914
6915
6916 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6917 PyObject *resultobj;
6918 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6919 PyObject * obj0 = 0 ;
6920 char *kwnames[] = {
6921 (char *) "self", NULL
6922 };
6923
6924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6926 if (SWIG_arg_fail(1)) SWIG_fail;
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 delete arg1;
6930
6931 wxPyEndAllowThreads(__tstate);
6932 if (PyErr_Occurred()) SWIG_fail;
6933 }
6934 Py_INCREF(Py_None); resultobj = Py_None;
6935 return resultobj;
6936 fail:
6937 return NULL;
6938 }
6939
6940
6941 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6942 PyObject *obj;
6943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6944 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6945 Py_INCREF(obj);
6946 return Py_BuildValue((char *)"");
6947 }
6948 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj;
6950 wxStopWatch *result;
6951 char *kwnames[] = {
6952 NULL
6953 };
6954
6955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6956 {
6957 PyThreadState* __tstate = wxPyBeginAllowThreads();
6958 result = (wxStopWatch *)new wxStopWatch();
6959
6960 wxPyEndAllowThreads(__tstate);
6961 if (PyErr_Occurred()) SWIG_fail;
6962 }
6963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6964 return resultobj;
6965 fail:
6966 return NULL;
6967 }
6968
6969
6970 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6971 PyObject *resultobj;
6972 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6973 long arg2 = (long) 0 ;
6974 PyObject * obj0 = 0 ;
6975 PyObject * obj1 = 0 ;
6976 char *kwnames[] = {
6977 (char *) "self",(char *) "t0", NULL
6978 };
6979
6980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
6981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6982 if (SWIG_arg_fail(1)) SWIG_fail;
6983 if (obj1) {
6984 {
6985 arg2 = (long)(SWIG_As_long(obj1));
6986 if (SWIG_arg_fail(2)) SWIG_fail;
6987 }
6988 }
6989 {
6990 PyThreadState* __tstate = wxPyBeginAllowThreads();
6991 (arg1)->Start(arg2);
6992
6993 wxPyEndAllowThreads(__tstate);
6994 if (PyErr_Occurred()) SWIG_fail;
6995 }
6996 Py_INCREF(Py_None); resultobj = Py_None;
6997 return resultobj;
6998 fail:
6999 return NULL;
7000 }
7001
7002
7003 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7004 PyObject *resultobj;
7005 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7006 PyObject * obj0 = 0 ;
7007 char *kwnames[] = {
7008 (char *) "self", NULL
7009 };
7010
7011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7013 if (SWIG_arg_fail(1)) SWIG_fail;
7014 {
7015 PyThreadState* __tstate = wxPyBeginAllowThreads();
7016 (arg1)->Pause();
7017
7018 wxPyEndAllowThreads(__tstate);
7019 if (PyErr_Occurred()) SWIG_fail;
7020 }
7021 Py_INCREF(Py_None); resultobj = Py_None;
7022 return resultobj;
7023 fail:
7024 return NULL;
7025 }
7026
7027
7028 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7029 PyObject *resultobj;
7030 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7031 PyObject * obj0 = 0 ;
7032 char *kwnames[] = {
7033 (char *) "self", NULL
7034 };
7035
7036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7038 if (SWIG_arg_fail(1)) SWIG_fail;
7039 {
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 (arg1)->Resume();
7042
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 Py_INCREF(Py_None); resultobj = Py_None;
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7054 PyObject *resultobj;
7055 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7056 long result;
7057 PyObject * obj0 = 0 ;
7058 char *kwnames[] = {
7059 (char *) "self", NULL
7060 };
7061
7062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7064 if (SWIG_arg_fail(1)) SWIG_fail;
7065 {
7066 PyThreadState* __tstate = wxPyBeginAllowThreads();
7067 result = (long)((wxStopWatch const *)arg1)->Time();
7068
7069 wxPyEndAllowThreads(__tstate);
7070 if (PyErr_Occurred()) SWIG_fail;
7071 }
7072 {
7073 resultobj = SWIG_From_long((long)(result));
7074 }
7075 return resultobj;
7076 fail:
7077 return NULL;
7078 }
7079
7080
7081 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7082 PyObject *obj;
7083 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7084 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7085 Py_INCREF(obj);
7086 return Py_BuildValue((char *)"");
7087 }
7088 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7089 PyObject *resultobj;
7090 int arg1 = (int) 9 ;
7091 int arg2 = (int) wxID_FILE1 ;
7092 wxFileHistory *result;
7093 PyObject * obj0 = 0 ;
7094 PyObject * obj1 = 0 ;
7095 char *kwnames[] = {
7096 (char *) "maxFiles",(char *) "idBase", NULL
7097 };
7098
7099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7100 if (obj0) {
7101 {
7102 arg1 = (int)(SWIG_As_int(obj0));
7103 if (SWIG_arg_fail(1)) SWIG_fail;
7104 }
7105 }
7106 if (obj1) {
7107 {
7108 arg2 = (int)(SWIG_As_int(obj1));
7109 if (SWIG_arg_fail(2)) SWIG_fail;
7110 }
7111 }
7112 {
7113 PyThreadState* __tstate = wxPyBeginAllowThreads();
7114 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7115
7116 wxPyEndAllowThreads(__tstate);
7117 if (PyErr_Occurred()) SWIG_fail;
7118 }
7119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7120 return resultobj;
7121 fail:
7122 return NULL;
7123 }
7124
7125
7126 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7127 PyObject *resultobj;
7128 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7129 PyObject * obj0 = 0 ;
7130 char *kwnames[] = {
7131 (char *) "self", NULL
7132 };
7133
7134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7136 if (SWIG_arg_fail(1)) SWIG_fail;
7137 {
7138 PyThreadState* __tstate = wxPyBeginAllowThreads();
7139 delete arg1;
7140
7141 wxPyEndAllowThreads(__tstate);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 Py_INCREF(Py_None); resultobj = Py_None;
7145 return resultobj;
7146 fail:
7147 return NULL;
7148 }
7149
7150
7151 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7152 PyObject *resultobj;
7153 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7154 wxString *arg2 = 0 ;
7155 bool temp2 = false ;
7156 PyObject * obj0 = 0 ;
7157 PyObject * obj1 = 0 ;
7158 char *kwnames[] = {
7159 (char *) "self",(char *) "file", NULL
7160 };
7161
7162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7164 if (SWIG_arg_fail(1)) SWIG_fail;
7165 {
7166 arg2 = wxString_in_helper(obj1);
7167 if (arg2 == NULL) SWIG_fail;
7168 temp2 = true;
7169 }
7170 {
7171 PyThreadState* __tstate = wxPyBeginAllowThreads();
7172 (arg1)->AddFileToHistory((wxString const &)*arg2);
7173
7174 wxPyEndAllowThreads(__tstate);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 Py_INCREF(Py_None); resultobj = Py_None;
7178 {
7179 if (temp2)
7180 delete arg2;
7181 }
7182 return resultobj;
7183 fail:
7184 {
7185 if (temp2)
7186 delete arg2;
7187 }
7188 return NULL;
7189 }
7190
7191
7192 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7193 PyObject *resultobj;
7194 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7195 int arg2 ;
7196 PyObject * obj0 = 0 ;
7197 PyObject * obj1 = 0 ;
7198 char *kwnames[] = {
7199 (char *) "self",(char *) "i", NULL
7200 };
7201
7202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7204 if (SWIG_arg_fail(1)) SWIG_fail;
7205 {
7206 arg2 = (int)(SWIG_As_int(obj1));
7207 if (SWIG_arg_fail(2)) SWIG_fail;
7208 }
7209 {
7210 PyThreadState* __tstate = wxPyBeginAllowThreads();
7211 (arg1)->RemoveFileFromHistory(arg2);
7212
7213 wxPyEndAllowThreads(__tstate);
7214 if (PyErr_Occurred()) SWIG_fail;
7215 }
7216 Py_INCREF(Py_None); resultobj = Py_None;
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7224 PyObject *resultobj;
7225 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7226 int result;
7227 PyObject * obj0 = 0 ;
7228 char *kwnames[] = {
7229 (char *) "self", NULL
7230 };
7231
7232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7234 if (SWIG_arg_fail(1)) SWIG_fail;
7235 {
7236 PyThreadState* __tstate = wxPyBeginAllowThreads();
7237 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7238
7239 wxPyEndAllowThreads(__tstate);
7240 if (PyErr_Occurred()) SWIG_fail;
7241 }
7242 {
7243 resultobj = SWIG_From_int((int)(result));
7244 }
7245 return resultobj;
7246 fail:
7247 return NULL;
7248 }
7249
7250
7251 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7252 PyObject *resultobj;
7253 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7254 wxMenu *arg2 = (wxMenu *) 0 ;
7255 PyObject * obj0 = 0 ;
7256 PyObject * obj1 = 0 ;
7257 char *kwnames[] = {
7258 (char *) "self",(char *) "menu", NULL
7259 };
7260
7261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7263 if (SWIG_arg_fail(1)) SWIG_fail;
7264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7265 if (SWIG_arg_fail(2)) SWIG_fail;
7266 {
7267 PyThreadState* __tstate = wxPyBeginAllowThreads();
7268 (arg1)->UseMenu(arg2);
7269
7270 wxPyEndAllowThreads(__tstate);
7271 if (PyErr_Occurred()) SWIG_fail;
7272 }
7273 Py_INCREF(Py_None); resultobj = Py_None;
7274 return resultobj;
7275 fail:
7276 return NULL;
7277 }
7278
7279
7280 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7281 PyObject *resultobj;
7282 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7283 wxMenu *arg2 = (wxMenu *) 0 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 char *kwnames[] = {
7287 (char *) "self",(char *) "menu", NULL
7288 };
7289
7290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7292 if (SWIG_arg_fail(1)) SWIG_fail;
7293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7294 if (SWIG_arg_fail(2)) SWIG_fail;
7295 {
7296 PyThreadState* __tstate = wxPyBeginAllowThreads();
7297 (arg1)->RemoveMenu(arg2);
7298
7299 wxPyEndAllowThreads(__tstate);
7300 if (PyErr_Occurred()) SWIG_fail;
7301 }
7302 Py_INCREF(Py_None); resultobj = Py_None;
7303 return resultobj;
7304 fail:
7305 return NULL;
7306 }
7307
7308
7309 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7310 PyObject *resultobj;
7311 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7312 wxConfigBase *arg2 = 0 ;
7313 PyObject * obj0 = 0 ;
7314 PyObject * obj1 = 0 ;
7315 char *kwnames[] = {
7316 (char *) "self",(char *) "config", NULL
7317 };
7318
7319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7321 if (SWIG_arg_fail(1)) SWIG_fail;
7322 {
7323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7324 if (SWIG_arg_fail(2)) SWIG_fail;
7325 if (arg2 == NULL) {
7326 SWIG_null_ref("wxConfigBase");
7327 }
7328 if (SWIG_arg_fail(2)) SWIG_fail;
7329 }
7330 {
7331 PyThreadState* __tstate = wxPyBeginAllowThreads();
7332 (arg1)->Load(*arg2);
7333
7334 wxPyEndAllowThreads(__tstate);
7335 if (PyErr_Occurred()) SWIG_fail;
7336 }
7337 Py_INCREF(Py_None); resultobj = Py_None;
7338 return resultobj;
7339 fail:
7340 return NULL;
7341 }
7342
7343
7344 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7345 PyObject *resultobj;
7346 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7347 wxConfigBase *arg2 = 0 ;
7348 PyObject * obj0 = 0 ;
7349 PyObject * obj1 = 0 ;
7350 char *kwnames[] = {
7351 (char *) "self",(char *) "config", NULL
7352 };
7353
7354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7356 if (SWIG_arg_fail(1)) SWIG_fail;
7357 {
7358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7359 if (SWIG_arg_fail(2)) SWIG_fail;
7360 if (arg2 == NULL) {
7361 SWIG_null_ref("wxConfigBase");
7362 }
7363 if (SWIG_arg_fail(2)) SWIG_fail;
7364 }
7365 {
7366 PyThreadState* __tstate = wxPyBeginAllowThreads();
7367 (arg1)->Save(*arg2);
7368
7369 wxPyEndAllowThreads(__tstate);
7370 if (PyErr_Occurred()) SWIG_fail;
7371 }
7372 Py_INCREF(Py_None); resultobj = Py_None;
7373 return resultobj;
7374 fail:
7375 return NULL;
7376 }
7377
7378
7379 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7380 PyObject *resultobj;
7381 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7382 PyObject * obj0 = 0 ;
7383 char *kwnames[] = {
7384 (char *) "self", NULL
7385 };
7386
7387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7389 if (SWIG_arg_fail(1)) SWIG_fail;
7390 {
7391 PyThreadState* __tstate = wxPyBeginAllowThreads();
7392 (arg1)->AddFilesToMenu();
7393
7394 wxPyEndAllowThreads(__tstate);
7395 if (PyErr_Occurred()) SWIG_fail;
7396 }
7397 Py_INCREF(Py_None); resultobj = Py_None;
7398 return resultobj;
7399 fail:
7400 return NULL;
7401 }
7402
7403
7404 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7405 PyObject *resultobj;
7406 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7407 wxMenu *arg2 = (wxMenu *) 0 ;
7408 PyObject * obj0 = 0 ;
7409 PyObject * obj1 = 0 ;
7410 char *kwnames[] = {
7411 (char *) "self",(char *) "menu", NULL
7412 };
7413
7414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7416 if (SWIG_arg_fail(1)) SWIG_fail;
7417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7418 if (SWIG_arg_fail(2)) SWIG_fail;
7419 {
7420 PyThreadState* __tstate = wxPyBeginAllowThreads();
7421 (arg1)->AddFilesToMenu(arg2);
7422
7423 wxPyEndAllowThreads(__tstate);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 Py_INCREF(Py_None); resultobj = Py_None;
7427 return resultobj;
7428 fail:
7429 return NULL;
7430 }
7431
7432
7433 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7434 PyObject *resultobj;
7435 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7436 int arg2 ;
7437 wxString result;
7438 PyObject * obj0 = 0 ;
7439 PyObject * obj1 = 0 ;
7440 char *kwnames[] = {
7441 (char *) "self",(char *) "i", NULL
7442 };
7443
7444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7446 if (SWIG_arg_fail(1)) SWIG_fail;
7447 {
7448 arg2 = (int)(SWIG_As_int(obj1));
7449 if (SWIG_arg_fail(2)) SWIG_fail;
7450 }
7451 {
7452 PyThreadState* __tstate = wxPyBeginAllowThreads();
7453 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7454
7455 wxPyEndAllowThreads(__tstate);
7456 if (PyErr_Occurred()) SWIG_fail;
7457 }
7458 {
7459 #if wxUSE_UNICODE
7460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7461 #else
7462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7463 #endif
7464 }
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7472 PyObject *resultobj;
7473 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7474 int result;
7475 PyObject * obj0 = 0 ;
7476 char *kwnames[] = {
7477 (char *) "self", NULL
7478 };
7479
7480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7482 if (SWIG_arg_fail(1)) SWIG_fail;
7483 {
7484 PyThreadState* __tstate = wxPyBeginAllowThreads();
7485 result = (int)((wxFileHistory const *)arg1)->GetCount();
7486
7487 wxPyEndAllowThreads(__tstate);
7488 if (PyErr_Occurred()) SWIG_fail;
7489 }
7490 {
7491 resultobj = SWIG_From_int((int)(result));
7492 }
7493 return resultobj;
7494 fail:
7495 return NULL;
7496 }
7497
7498
7499 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7500 PyObject *obj;
7501 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7502 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7503 Py_INCREF(obj);
7504 return Py_BuildValue((char *)"");
7505 }
7506 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7507 PyObject *resultobj;
7508 wxString *arg1 = 0 ;
7509 wxString const &arg2_defvalue = wxPyEmptyString ;
7510 wxString *arg2 = (wxString *) &arg2_defvalue ;
7511 wxSingleInstanceChecker *result;
7512 bool temp1 = false ;
7513 bool temp2 = false ;
7514 PyObject * obj0 = 0 ;
7515 PyObject * obj1 = 0 ;
7516 char *kwnames[] = {
7517 (char *) "name",(char *) "path", NULL
7518 };
7519
7520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7521 {
7522 arg1 = wxString_in_helper(obj0);
7523 if (arg1 == NULL) SWIG_fail;
7524 temp1 = true;
7525 }
7526 if (obj1) {
7527 {
7528 arg2 = wxString_in_helper(obj1);
7529 if (arg2 == NULL) SWIG_fail;
7530 temp2 = true;
7531 }
7532 }
7533 {
7534 PyThreadState* __tstate = wxPyBeginAllowThreads();
7535 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7536
7537 wxPyEndAllowThreads(__tstate);
7538 if (PyErr_Occurred()) SWIG_fail;
7539 }
7540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7541 {
7542 if (temp1)
7543 delete arg1;
7544 }
7545 {
7546 if (temp2)
7547 delete arg2;
7548 }
7549 return resultobj;
7550 fail:
7551 {
7552 if (temp1)
7553 delete arg1;
7554 }
7555 {
7556 if (temp2)
7557 delete arg2;
7558 }
7559 return NULL;
7560 }
7561
7562
7563 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7564 PyObject *resultobj;
7565 wxSingleInstanceChecker *result;
7566 char *kwnames[] = {
7567 NULL
7568 };
7569
7570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7574
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj;
7587 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7588 PyObject * obj0 = 0 ;
7589 char *kwnames[] = {
7590 (char *) "self", NULL
7591 };
7592
7593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7595 if (SWIG_arg_fail(1)) SWIG_fail;
7596 {
7597 PyThreadState* __tstate = wxPyBeginAllowThreads();
7598 delete arg1;
7599
7600 wxPyEndAllowThreads(__tstate);
7601 if (PyErr_Occurred()) SWIG_fail;
7602 }
7603 Py_INCREF(Py_None); resultobj = Py_None;
7604 return resultobj;
7605 fail:
7606 return NULL;
7607 }
7608
7609
7610 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7611 PyObject *resultobj;
7612 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7613 wxString *arg2 = 0 ;
7614 wxString const &arg3_defvalue = wxPyEmptyString ;
7615 wxString *arg3 = (wxString *) &arg3_defvalue ;
7616 bool result;
7617 bool temp2 = false ;
7618 bool temp3 = false ;
7619 PyObject * obj0 = 0 ;
7620 PyObject * obj1 = 0 ;
7621 PyObject * obj2 = 0 ;
7622 char *kwnames[] = {
7623 (char *) "self",(char *) "name",(char *) "path", NULL
7624 };
7625
7626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7628 if (SWIG_arg_fail(1)) SWIG_fail;
7629 {
7630 arg2 = wxString_in_helper(obj1);
7631 if (arg2 == NULL) SWIG_fail;
7632 temp2 = true;
7633 }
7634 if (obj2) {
7635 {
7636 arg3 = wxString_in_helper(obj2);
7637 if (arg3 == NULL) SWIG_fail;
7638 temp3 = true;
7639 }
7640 }
7641 {
7642 PyThreadState* __tstate = wxPyBeginAllowThreads();
7643 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7644
7645 wxPyEndAllowThreads(__tstate);
7646 if (PyErr_Occurred()) SWIG_fail;
7647 }
7648 {
7649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7650 }
7651 {
7652 if (temp2)
7653 delete arg2;
7654 }
7655 {
7656 if (temp3)
7657 delete arg3;
7658 }
7659 return resultobj;
7660 fail:
7661 {
7662 if (temp2)
7663 delete arg2;
7664 }
7665 {
7666 if (temp3)
7667 delete arg3;
7668 }
7669 return NULL;
7670 }
7671
7672
7673 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7674 PyObject *resultobj;
7675 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7676 bool result;
7677 PyObject * obj0 = 0 ;
7678 char *kwnames[] = {
7679 (char *) "self", NULL
7680 };
7681
7682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7684 if (SWIG_arg_fail(1)) SWIG_fail;
7685 {
7686 PyThreadState* __tstate = wxPyBeginAllowThreads();
7687 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7688
7689 wxPyEndAllowThreads(__tstate);
7690 if (PyErr_Occurred()) SWIG_fail;
7691 }
7692 {
7693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7694 }
7695 return resultobj;
7696 fail:
7697 return NULL;
7698 }
7699
7700
7701 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7702 PyObject *obj;
7703 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7704 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7705 Py_INCREF(obj);
7706 return Py_BuildValue((char *)"");
7707 }
7708 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj;
7710 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7711 PyObject * obj0 = 0 ;
7712 char *kwnames[] = {
7713 (char *) "self", NULL
7714 };
7715
7716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7718 if (SWIG_arg_fail(1)) SWIG_fail;
7719 {
7720 PyThreadState* __tstate = wxPyBeginAllowThreads();
7721 delete arg1;
7722
7723 wxPyEndAllowThreads(__tstate);
7724 if (PyErr_Occurred()) SWIG_fail;
7725 }
7726 Py_INCREF(Py_None); resultobj = Py_None;
7727 return resultobj;
7728 fail:
7729 return NULL;
7730 }
7731
7732
7733 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7734 PyObject *resultobj;
7735 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7736 wxString result;
7737 PyObject * obj0 = 0 ;
7738 char *kwnames[] = {
7739 (char *) "self", NULL
7740 };
7741
7742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7744 if (SWIG_arg_fail(1)) SWIG_fail;
7745 {
7746 PyThreadState* __tstate = wxPyBeginAllowThreads();
7747 result = (arg1)->GetTip();
7748
7749 wxPyEndAllowThreads(__tstate);
7750 if (PyErr_Occurred()) SWIG_fail;
7751 }
7752 {
7753 #if wxUSE_UNICODE
7754 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7755 #else
7756 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7757 #endif
7758 }
7759 return resultobj;
7760 fail:
7761 return NULL;
7762 }
7763
7764
7765 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7766 PyObject *resultobj;
7767 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7768 size_t result;
7769 PyObject * obj0 = 0 ;
7770 char *kwnames[] = {
7771 (char *) "self", NULL
7772 };
7773
7774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7776 if (SWIG_arg_fail(1)) SWIG_fail;
7777 {
7778 PyThreadState* __tstate = wxPyBeginAllowThreads();
7779 result = (size_t)(arg1)->GetCurrentTip();
7780
7781 wxPyEndAllowThreads(__tstate);
7782 if (PyErr_Occurred()) SWIG_fail;
7783 }
7784 {
7785 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7786 }
7787 return resultobj;
7788 fail:
7789 return NULL;
7790 }
7791
7792
7793 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7794 PyObject *resultobj;
7795 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7796 wxString *arg2 = 0 ;
7797 wxString result;
7798 bool temp2 = false ;
7799 PyObject * obj0 = 0 ;
7800 PyObject * obj1 = 0 ;
7801 char *kwnames[] = {
7802 (char *) "self",(char *) "tip", NULL
7803 };
7804
7805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7807 if (SWIG_arg_fail(1)) SWIG_fail;
7808 {
7809 arg2 = wxString_in_helper(obj1);
7810 if (arg2 == NULL) SWIG_fail;
7811 temp2 = true;
7812 }
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7816
7817 wxPyEndAllowThreads(__tstate);
7818 if (PyErr_Occurred()) SWIG_fail;
7819 }
7820 {
7821 #if wxUSE_UNICODE
7822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7823 #else
7824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7825 #endif
7826 }
7827 {
7828 if (temp2)
7829 delete arg2;
7830 }
7831 return resultobj;
7832 fail:
7833 {
7834 if (temp2)
7835 delete arg2;
7836 }
7837 return NULL;
7838 }
7839
7840
7841 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7842 PyObject *obj;
7843 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7844 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7845 Py_INCREF(obj);
7846 return Py_BuildValue((char *)"");
7847 }
7848 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7849 PyObject *resultobj;
7850 size_t arg1 ;
7851 wxPyTipProvider *result;
7852 PyObject * obj0 = 0 ;
7853 char *kwnames[] = {
7854 (char *) "currentTip", NULL
7855 };
7856
7857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7858 {
7859 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7860 if (SWIG_arg_fail(1)) SWIG_fail;
7861 }
7862 {
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7865
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7870 return resultobj;
7871 fail:
7872 return NULL;
7873 }
7874
7875
7876 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7877 PyObject *resultobj;
7878 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7879 PyObject *arg2 = (PyObject *) 0 ;
7880 PyObject *arg3 = (PyObject *) 0 ;
7881 PyObject * obj0 = 0 ;
7882 PyObject * obj1 = 0 ;
7883 PyObject * obj2 = 0 ;
7884 char *kwnames[] = {
7885 (char *) "self",(char *) "self",(char *) "_class", NULL
7886 };
7887
7888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7890 if (SWIG_arg_fail(1)) SWIG_fail;
7891 arg2 = obj1;
7892 arg3 = obj2;
7893 {
7894 PyThreadState* __tstate = wxPyBeginAllowThreads();
7895 (arg1)->_setCallbackInfo(arg2,arg3);
7896
7897 wxPyEndAllowThreads(__tstate);
7898 if (PyErr_Occurred()) SWIG_fail;
7899 }
7900 Py_INCREF(Py_None); resultobj = Py_None;
7901 return resultobj;
7902 fail:
7903 return NULL;
7904 }
7905
7906
7907 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7908 PyObject *obj;
7909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7910 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7911 Py_INCREF(obj);
7912 return Py_BuildValue((char *)"");
7913 }
7914 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7915 PyObject *resultobj;
7916 wxWindow *arg1 = (wxWindow *) 0 ;
7917 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7918 bool arg3 = (bool) true ;
7919 bool result;
7920 PyObject * obj0 = 0 ;
7921 PyObject * obj1 = 0 ;
7922 PyObject * obj2 = 0 ;
7923 char *kwnames[] = {
7924 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7925 };
7926
7927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7929 if (SWIG_arg_fail(1)) SWIG_fail;
7930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7931 if (SWIG_arg_fail(2)) SWIG_fail;
7932 if (obj2) {
7933 {
7934 arg3 = (bool)(SWIG_As_bool(obj2));
7935 if (SWIG_arg_fail(3)) SWIG_fail;
7936 }
7937 }
7938 {
7939 if (!wxPyCheckForApp()) SWIG_fail;
7940 PyThreadState* __tstate = wxPyBeginAllowThreads();
7941 result = (bool)wxShowTip(arg1,arg2,arg3);
7942
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 {
7947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7948 }
7949 return resultobj;
7950 fail:
7951 return NULL;
7952 }
7953
7954
7955 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7956 PyObject *resultobj;
7957 wxString *arg1 = 0 ;
7958 size_t arg2 ;
7959 wxTipProvider *result;
7960 bool temp1 = false ;
7961 PyObject * obj0 = 0 ;
7962 PyObject * obj1 = 0 ;
7963 char *kwnames[] = {
7964 (char *) "filename",(char *) "currentTip", NULL
7965 };
7966
7967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7968 {
7969 arg1 = wxString_in_helper(obj0);
7970 if (arg1 == NULL) SWIG_fail;
7971 temp1 = true;
7972 }
7973 {
7974 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7975 if (SWIG_arg_fail(2)) SWIG_fail;
7976 }
7977 {
7978 if (!wxPyCheckForApp()) SWIG_fail;
7979 PyThreadState* __tstate = wxPyBeginAllowThreads();
7980 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
7981
7982 wxPyEndAllowThreads(__tstate);
7983 if (PyErr_Occurred()) SWIG_fail;
7984 }
7985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
7986 {
7987 if (temp1)
7988 delete arg1;
7989 }
7990 return resultobj;
7991 fail:
7992 {
7993 if (temp1)
7994 delete arg1;
7995 }
7996 return NULL;
7997 }
7998
7999
8000 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8001 PyObject *resultobj;
8002 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8003 int arg2 = (int) -1 ;
8004 wxPyTimer *result;
8005 PyObject * obj0 = 0 ;
8006 PyObject * obj1 = 0 ;
8007 char *kwnames[] = {
8008 (char *) "owner",(char *) "id", NULL
8009 };
8010
8011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8012 if (obj0) {
8013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8014 if (SWIG_arg_fail(1)) SWIG_fail;
8015 }
8016 if (obj1) {
8017 {
8018 arg2 = (int)(SWIG_As_int(obj1));
8019 if (SWIG_arg_fail(2)) SWIG_fail;
8020 }
8021 }
8022 {
8023 if (!wxPyCheckForApp()) SWIG_fail;
8024 PyThreadState* __tstate = wxPyBeginAllowThreads();
8025 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8026
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8038 PyObject *resultobj;
8039 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8040 PyObject * obj0 = 0 ;
8041 char *kwnames[] = {
8042 (char *) "self", NULL
8043 };
8044
8045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8047 if (SWIG_arg_fail(1)) SWIG_fail;
8048 {
8049 PyThreadState* __tstate = wxPyBeginAllowThreads();
8050 delete arg1;
8051
8052 wxPyEndAllowThreads(__tstate);
8053 if (PyErr_Occurred()) SWIG_fail;
8054 }
8055 Py_INCREF(Py_None); resultobj = Py_None;
8056 return resultobj;
8057 fail:
8058 return NULL;
8059 }
8060
8061
8062 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8063 PyObject *resultobj;
8064 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8065 PyObject *arg2 = (PyObject *) 0 ;
8066 PyObject *arg3 = (PyObject *) 0 ;
8067 int arg4 = (int) 1 ;
8068 PyObject * obj0 = 0 ;
8069 PyObject * obj1 = 0 ;
8070 PyObject * obj2 = 0 ;
8071 PyObject * obj3 = 0 ;
8072 char *kwnames[] = {
8073 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8074 };
8075
8076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8078 if (SWIG_arg_fail(1)) SWIG_fail;
8079 arg2 = obj1;
8080 arg3 = obj2;
8081 if (obj3) {
8082 {
8083 arg4 = (int)(SWIG_As_int(obj3));
8084 if (SWIG_arg_fail(4)) SWIG_fail;
8085 }
8086 }
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8090
8091 wxPyEndAllowThreads(__tstate);
8092 if (PyErr_Occurred()) SWIG_fail;
8093 }
8094 Py_INCREF(Py_None); resultobj = Py_None;
8095 return resultobj;
8096 fail:
8097 return NULL;
8098 }
8099
8100
8101 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8102 PyObject *resultobj;
8103 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8104 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8105 int arg3 = (int) -1 ;
8106 PyObject * obj0 = 0 ;
8107 PyObject * obj1 = 0 ;
8108 PyObject * obj2 = 0 ;
8109 char *kwnames[] = {
8110 (char *) "self",(char *) "owner",(char *) "id", NULL
8111 };
8112
8113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8115 if (SWIG_arg_fail(1)) SWIG_fail;
8116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8117 if (SWIG_arg_fail(2)) SWIG_fail;
8118 if (obj2) {
8119 {
8120 arg3 = (int)(SWIG_As_int(obj2));
8121 if (SWIG_arg_fail(3)) SWIG_fail;
8122 }
8123 }
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 (arg1)->SetOwner(arg2,arg3);
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 Py_INCREF(Py_None); resultobj = Py_None;
8132 return resultobj;
8133 fail:
8134 return NULL;
8135 }
8136
8137
8138 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8139 PyObject *resultobj;
8140 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8141 wxEvtHandler *result;
8142 PyObject * obj0 = 0 ;
8143 char *kwnames[] = {
8144 (char *) "self", NULL
8145 };
8146
8147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8149 if (SWIG_arg_fail(1)) SWIG_fail;
8150 {
8151 PyThreadState* __tstate = wxPyBeginAllowThreads();
8152 result = (wxEvtHandler *)(arg1)->GetOwner();
8153
8154 wxPyEndAllowThreads(__tstate);
8155 if (PyErr_Occurred()) SWIG_fail;
8156 }
8157 {
8158 resultobj = wxPyMake_wxObject(result, 0);
8159 }
8160 return resultobj;
8161 fail:
8162 return NULL;
8163 }
8164
8165
8166 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8167 PyObject *resultobj;
8168 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8169 int arg2 = (int) -1 ;
8170 bool arg3 = (bool) false ;
8171 bool result;
8172 PyObject * obj0 = 0 ;
8173 PyObject * obj1 = 0 ;
8174 PyObject * obj2 = 0 ;
8175 char *kwnames[] = {
8176 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8177 };
8178
8179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8181 if (SWIG_arg_fail(1)) SWIG_fail;
8182 if (obj1) {
8183 {
8184 arg2 = (int)(SWIG_As_int(obj1));
8185 if (SWIG_arg_fail(2)) SWIG_fail;
8186 }
8187 }
8188 if (obj2) {
8189 {
8190 arg3 = (bool)(SWIG_As_bool(obj2));
8191 if (SWIG_arg_fail(3)) SWIG_fail;
8192 }
8193 }
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (bool)(arg1)->Start(arg2,arg3);
8197
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 {
8202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8203 }
8204 return resultobj;
8205 fail:
8206 return NULL;
8207 }
8208
8209
8210 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8211 PyObject *resultobj;
8212 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8213 PyObject * obj0 = 0 ;
8214 char *kwnames[] = {
8215 (char *) "self", NULL
8216 };
8217
8218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8220 if (SWIG_arg_fail(1)) SWIG_fail;
8221 {
8222 PyThreadState* __tstate = wxPyBeginAllowThreads();
8223 (arg1)->Stop();
8224
8225 wxPyEndAllowThreads(__tstate);
8226 if (PyErr_Occurred()) SWIG_fail;
8227 }
8228 Py_INCREF(Py_None); resultobj = Py_None;
8229 return resultobj;
8230 fail:
8231 return NULL;
8232 }
8233
8234
8235 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8236 PyObject *resultobj;
8237 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8238 bool result;
8239 PyObject * obj0 = 0 ;
8240 char *kwnames[] = {
8241 (char *) "self", NULL
8242 };
8243
8244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8246 if (SWIG_arg_fail(1)) SWIG_fail;
8247 {
8248 PyThreadState* __tstate = wxPyBeginAllowThreads();
8249 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8250
8251 wxPyEndAllowThreads(__tstate);
8252 if (PyErr_Occurred()) SWIG_fail;
8253 }
8254 {
8255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8256 }
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj;
8265 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8266 int result;
8267 PyObject * obj0 = 0 ;
8268 char *kwnames[] = {
8269 (char *) "self", NULL
8270 };
8271
8272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8274 if (SWIG_arg_fail(1)) SWIG_fail;
8275 {
8276 PyThreadState* __tstate = wxPyBeginAllowThreads();
8277 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8278
8279 wxPyEndAllowThreads(__tstate);
8280 if (PyErr_Occurred()) SWIG_fail;
8281 }
8282 {
8283 resultobj = SWIG_From_int((int)(result));
8284 }
8285 return resultobj;
8286 fail:
8287 return NULL;
8288 }
8289
8290
8291 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8292 PyObject *resultobj;
8293 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8294 bool result;
8295 PyObject * obj0 = 0 ;
8296 char *kwnames[] = {
8297 (char *) "self", NULL
8298 };
8299
8300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8302 if (SWIG_arg_fail(1)) SWIG_fail;
8303 {
8304 PyThreadState* __tstate = wxPyBeginAllowThreads();
8305 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8306
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 {
8311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8312 }
8313 return resultobj;
8314 fail:
8315 return NULL;
8316 }
8317
8318
8319 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8320 PyObject *resultobj;
8321 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8322 int result;
8323 PyObject * obj0 = 0 ;
8324 char *kwnames[] = {
8325 (char *) "self", NULL
8326 };
8327
8328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8330 if (SWIG_arg_fail(1)) SWIG_fail;
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 result = (int)((wxPyTimer const *)arg1)->GetId();
8334
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 {
8339 resultobj = SWIG_From_int((int)(result));
8340 }
8341 return resultobj;
8342 fail:
8343 return NULL;
8344 }
8345
8346
8347 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8348 PyObject *obj;
8349 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8350 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8351 Py_INCREF(obj);
8352 return Py_BuildValue((char *)"");
8353 }
8354 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8355 PyObject *resultobj;
8356 int arg1 = (int) 0 ;
8357 int arg2 = (int) 0 ;
8358 wxTimerEvent *result;
8359 PyObject * obj0 = 0 ;
8360 PyObject * obj1 = 0 ;
8361 char *kwnames[] = {
8362 (char *) "timerid",(char *) "interval", NULL
8363 };
8364
8365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8366 if (obj0) {
8367 {
8368 arg1 = (int)(SWIG_As_int(obj0));
8369 if (SWIG_arg_fail(1)) SWIG_fail;
8370 }
8371 }
8372 if (obj1) {
8373 {
8374 arg2 = (int)(SWIG_As_int(obj1));
8375 if (SWIG_arg_fail(2)) SWIG_fail;
8376 }
8377 }
8378 {
8379 PyThreadState* __tstate = wxPyBeginAllowThreads();
8380 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8381
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8386 return resultobj;
8387 fail:
8388 return NULL;
8389 }
8390
8391
8392 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8393 PyObject *resultobj;
8394 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8395 int result;
8396 PyObject * obj0 = 0 ;
8397 char *kwnames[] = {
8398 (char *) "self", NULL
8399 };
8400
8401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8403 if (SWIG_arg_fail(1)) SWIG_fail;
8404 {
8405 PyThreadState* __tstate = wxPyBeginAllowThreads();
8406 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8407
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 {
8412 resultobj = SWIG_From_int((int)(result));
8413 }
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8421 PyObject *obj;
8422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8423 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8424 Py_INCREF(obj);
8425 return Py_BuildValue((char *)"");
8426 }
8427 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8428 PyObject *resultobj;
8429 wxTimer *arg1 = 0 ;
8430 wxTimerRunner *result;
8431 PyObject * obj0 = 0 ;
8432
8433 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8434 {
8435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8436 if (SWIG_arg_fail(1)) SWIG_fail;
8437 if (arg1 == NULL) {
8438 SWIG_null_ref("wxTimer");
8439 }
8440 if (SWIG_arg_fail(1)) SWIG_fail;
8441 }
8442 {
8443 if (!wxPyCheckForApp()) SWIG_fail;
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8446
8447 wxPyEndAllowThreads(__tstate);
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8458 PyObject *resultobj;
8459 wxTimer *arg1 = 0 ;
8460 int arg2 ;
8461 bool arg3 = (bool) false ;
8462 wxTimerRunner *result;
8463 PyObject * obj0 = 0 ;
8464 PyObject * obj1 = 0 ;
8465 PyObject * obj2 = 0 ;
8466
8467 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8468 {
8469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8470 if (SWIG_arg_fail(1)) SWIG_fail;
8471 if (arg1 == NULL) {
8472 SWIG_null_ref("wxTimer");
8473 }
8474 if (SWIG_arg_fail(1)) SWIG_fail;
8475 }
8476 {
8477 arg2 = (int)(SWIG_As_int(obj1));
8478 if (SWIG_arg_fail(2)) SWIG_fail;
8479 }
8480 if (obj2) {
8481 {
8482 arg3 = (bool)(SWIG_As_bool(obj2));
8483 if (SWIG_arg_fail(3)) SWIG_fail;
8484 }
8485 }
8486 {
8487 if (!wxPyCheckForApp()) SWIG_fail;
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8490
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8495 return resultobj;
8496 fail:
8497 return NULL;
8498 }
8499
8500
8501 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8502 int argc;
8503 PyObject *argv[4];
8504 int ii;
8505
8506 argc = PyObject_Length(args);
8507 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8508 argv[ii] = PyTuple_GetItem(args,ii);
8509 }
8510 if (argc == 1) {
8511 int _v;
8512 {
8513 void *ptr = 0;
8514 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8515 _v = 0;
8516 PyErr_Clear();
8517 } else {
8518 _v = (ptr != 0);
8519 }
8520 }
8521 if (_v) {
8522 return _wrap_new_TimerRunner__SWIG_0(self,args);
8523 }
8524 }
8525 if ((argc >= 2) && (argc <= 3)) {
8526 int _v;
8527 {
8528 void *ptr = 0;
8529 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8530 _v = 0;
8531 PyErr_Clear();
8532 } else {
8533 _v = (ptr != 0);
8534 }
8535 }
8536 if (_v) {
8537 _v = SWIG_Check_int(argv[1]);
8538 if (_v) {
8539 if (argc <= 2) {
8540 return _wrap_new_TimerRunner__SWIG_1(self,args);
8541 }
8542 _v = SWIG_Check_bool(argv[2]);
8543 if (_v) {
8544 return _wrap_new_TimerRunner__SWIG_1(self,args);
8545 }
8546 }
8547 }
8548 }
8549
8550 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8551 return NULL;
8552 }
8553
8554
8555 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj;
8557 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8558 PyObject * obj0 = 0 ;
8559 char *kwnames[] = {
8560 (char *) "self", NULL
8561 };
8562
8563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8565 if (SWIG_arg_fail(1)) SWIG_fail;
8566 {
8567 PyThreadState* __tstate = wxPyBeginAllowThreads();
8568 delete arg1;
8569
8570 wxPyEndAllowThreads(__tstate);
8571 if (PyErr_Occurred()) SWIG_fail;
8572 }
8573 Py_INCREF(Py_None); resultobj = Py_None;
8574 return resultobj;
8575 fail:
8576 return NULL;
8577 }
8578
8579
8580 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8581 PyObject *resultobj;
8582 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8583 int arg2 ;
8584 bool arg3 = (bool) false ;
8585 PyObject * obj0 = 0 ;
8586 PyObject * obj1 = 0 ;
8587 PyObject * obj2 = 0 ;
8588 char *kwnames[] = {
8589 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8590 };
8591
8592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8594 if (SWIG_arg_fail(1)) SWIG_fail;
8595 {
8596 arg2 = (int)(SWIG_As_int(obj1));
8597 if (SWIG_arg_fail(2)) SWIG_fail;
8598 }
8599 if (obj2) {
8600 {
8601 arg3 = (bool)(SWIG_As_bool(obj2));
8602 if (SWIG_arg_fail(3)) SWIG_fail;
8603 }
8604 }
8605 {
8606 PyThreadState* __tstate = wxPyBeginAllowThreads();
8607 (arg1)->Start(arg2,arg3);
8608
8609 wxPyEndAllowThreads(__tstate);
8610 if (PyErr_Occurred()) SWIG_fail;
8611 }
8612 Py_INCREF(Py_None); resultobj = Py_None;
8613 return resultobj;
8614 fail:
8615 return NULL;
8616 }
8617
8618
8619 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8620 PyObject *obj;
8621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8622 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8623 Py_INCREF(obj);
8624 return Py_BuildValue((char *)"");
8625 }
8626 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj;
8628 wxLog *result;
8629 char *kwnames[] = {
8630 NULL
8631 };
8632
8633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8634 {
8635 PyThreadState* __tstate = wxPyBeginAllowThreads();
8636 result = (wxLog *)new wxLog();
8637
8638 wxPyEndAllowThreads(__tstate);
8639 if (PyErr_Occurred()) SWIG_fail;
8640 }
8641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8642 return resultobj;
8643 fail:
8644 return NULL;
8645 }
8646
8647
8648 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8649 PyObject *resultobj;
8650 bool result;
8651 char *kwnames[] = {
8652 NULL
8653 };
8654
8655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (bool)wxLog::IsEnabled();
8659
8660 wxPyEndAllowThreads(__tstate);
8661 if (PyErr_Occurred()) SWIG_fail;
8662 }
8663 {
8664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8665 }
8666 return resultobj;
8667 fail:
8668 return NULL;
8669 }
8670
8671
8672 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8673 PyObject *resultobj;
8674 bool arg1 = (bool) true ;
8675 bool result;
8676 PyObject * obj0 = 0 ;
8677 char *kwnames[] = {
8678 (char *) "doIt", NULL
8679 };
8680
8681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8682 if (obj0) {
8683 {
8684 arg1 = (bool)(SWIG_As_bool(obj0));
8685 if (SWIG_arg_fail(1)) SWIG_fail;
8686 }
8687 }
8688 {
8689 PyThreadState* __tstate = wxPyBeginAllowThreads();
8690 result = (bool)wxLog::EnableLogging(arg1);
8691
8692 wxPyEndAllowThreads(__tstate);
8693 if (PyErr_Occurred()) SWIG_fail;
8694 }
8695 {
8696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8697 }
8698 return resultobj;
8699 fail:
8700 return NULL;
8701 }
8702
8703
8704 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8705 PyObject *resultobj;
8706 wxLogLevel arg1 ;
8707 wxChar *arg2 = (wxChar *) 0 ;
8708 time_t arg3 ;
8709 PyObject * obj0 = 0 ;
8710 PyObject * obj1 = 0 ;
8711 PyObject * obj2 = 0 ;
8712 char *kwnames[] = {
8713 (char *) "level",(char *) "szString",(char *) "t", NULL
8714 };
8715
8716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8717 {
8718 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8719 if (SWIG_arg_fail(1)) SWIG_fail;
8720 }
8721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8722 if (SWIG_arg_fail(2)) SWIG_fail;
8723 {
8724 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8725 if (SWIG_arg_fail(3)) SWIG_fail;
8726 }
8727 {
8728 PyThreadState* __tstate = wxPyBeginAllowThreads();
8729 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8730
8731 wxPyEndAllowThreads(__tstate);
8732 if (PyErr_Occurred()) SWIG_fail;
8733 }
8734 Py_INCREF(Py_None); resultobj = Py_None;
8735 return resultobj;
8736 fail:
8737 return NULL;
8738 }
8739
8740
8741 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8742 PyObject *resultobj;
8743 wxLog *arg1 = (wxLog *) 0 ;
8744 PyObject * obj0 = 0 ;
8745 char *kwnames[] = {
8746 (char *) "self", NULL
8747 };
8748
8749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8751 if (SWIG_arg_fail(1)) SWIG_fail;
8752 {
8753 PyThreadState* __tstate = wxPyBeginAllowThreads();
8754 (arg1)->Flush();
8755
8756 wxPyEndAllowThreads(__tstate);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 Py_INCREF(Py_None); resultobj = Py_None;
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8767 PyObject *resultobj;
8768 char *kwnames[] = {
8769 NULL
8770 };
8771
8772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8773 {
8774 PyThreadState* __tstate = wxPyBeginAllowThreads();
8775 wxLog::FlushActive();
8776
8777 wxPyEndAllowThreads(__tstate);
8778 if (PyErr_Occurred()) SWIG_fail;
8779 }
8780 Py_INCREF(Py_None); resultobj = Py_None;
8781 return resultobj;
8782 fail:
8783 return NULL;
8784 }
8785
8786
8787 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8788 PyObject *resultobj;
8789 wxLog *result;
8790 char *kwnames[] = {
8791 NULL
8792 };
8793
8794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8795 {
8796 PyThreadState* __tstate = wxPyBeginAllowThreads();
8797 result = (wxLog *)wxLog::GetActiveTarget();
8798
8799 wxPyEndAllowThreads(__tstate);
8800 if (PyErr_Occurred()) SWIG_fail;
8801 }
8802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8803 return resultobj;
8804 fail:
8805 return NULL;
8806 }
8807
8808
8809 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8810 PyObject *resultobj;
8811 wxLog *arg1 = (wxLog *) 0 ;
8812 wxLog *result;
8813 PyObject * obj0 = 0 ;
8814 char *kwnames[] = {
8815 (char *) "pLogger", NULL
8816 };
8817
8818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8820 if (SWIG_arg_fail(1)) SWIG_fail;
8821 {
8822 PyThreadState* __tstate = wxPyBeginAllowThreads();
8823 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8824
8825 wxPyEndAllowThreads(__tstate);
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8829 return resultobj;
8830 fail:
8831 return NULL;
8832 }
8833
8834
8835 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj;
8837 char *kwnames[] = {
8838 NULL
8839 };
8840
8841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8842 {
8843 PyThreadState* __tstate = wxPyBeginAllowThreads();
8844 wxLog::Suspend();
8845
8846 wxPyEndAllowThreads(__tstate);
8847 if (PyErr_Occurred()) SWIG_fail;
8848 }
8849 Py_INCREF(Py_None); resultobj = Py_None;
8850 return resultobj;
8851 fail:
8852 return NULL;
8853 }
8854
8855
8856 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8857 PyObject *resultobj;
8858 char *kwnames[] = {
8859 NULL
8860 };
8861
8862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8863 {
8864 PyThreadState* __tstate = wxPyBeginAllowThreads();
8865 wxLog::Resume();
8866
8867 wxPyEndAllowThreads(__tstate);
8868 if (PyErr_Occurred()) SWIG_fail;
8869 }
8870 Py_INCREF(Py_None); resultobj = Py_None;
8871 return resultobj;
8872 fail:
8873 return NULL;
8874 }
8875
8876
8877 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8878 PyObject *resultobj;
8879 bool arg1 = (bool) true ;
8880 PyObject * obj0 = 0 ;
8881 char *kwnames[] = {
8882 (char *) "bVerbose", NULL
8883 };
8884
8885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8886 if (obj0) {
8887 {
8888 arg1 = (bool)(SWIG_As_bool(obj0));
8889 if (SWIG_arg_fail(1)) SWIG_fail;
8890 }
8891 }
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 wxLog::SetVerbose(arg1);
8895
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 Py_INCREF(Py_None); resultobj = Py_None;
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj;
8908 wxLogLevel arg1 ;
8909 PyObject * obj0 = 0 ;
8910 char *kwnames[] = {
8911 (char *) "logLevel", NULL
8912 };
8913
8914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8915 {
8916 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8917 if (SWIG_arg_fail(1)) SWIG_fail;
8918 }
8919 {
8920 PyThreadState* __tstate = wxPyBeginAllowThreads();
8921 wxLog::SetLogLevel(arg1);
8922
8923 wxPyEndAllowThreads(__tstate);
8924 if (PyErr_Occurred()) SWIG_fail;
8925 }
8926 Py_INCREF(Py_None); resultobj = Py_None;
8927 return resultobj;
8928 fail:
8929 return NULL;
8930 }
8931
8932
8933 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8934 PyObject *resultobj;
8935 char *kwnames[] = {
8936 NULL
8937 };
8938
8939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8940 {
8941 PyThreadState* __tstate = wxPyBeginAllowThreads();
8942 wxLog::DontCreateOnDemand();
8943
8944 wxPyEndAllowThreads(__tstate);
8945 if (PyErr_Occurred()) SWIG_fail;
8946 }
8947 Py_INCREF(Py_None); resultobj = Py_None;
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8955 PyObject *resultobj;
8956 wxTraceMask arg1 ;
8957 PyObject * obj0 = 0 ;
8958 char *kwnames[] = {
8959 (char *) "ulMask", NULL
8960 };
8961
8962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8963 {
8964 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8965 if (SWIG_arg_fail(1)) SWIG_fail;
8966 }
8967 {
8968 PyThreadState* __tstate = wxPyBeginAllowThreads();
8969 wxLog::SetTraceMask(arg1);
8970
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 Py_INCREF(Py_None); resultobj = Py_None;
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8982 PyObject *resultobj;
8983 wxString *arg1 = 0 ;
8984 bool temp1 = false ;
8985 PyObject * obj0 = 0 ;
8986 char *kwnames[] = {
8987 (char *) "str", NULL
8988 };
8989
8990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
8991 {
8992 arg1 = wxString_in_helper(obj0);
8993 if (arg1 == NULL) SWIG_fail;
8994 temp1 = true;
8995 }
8996 {
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 wxLog::AddTraceMask((wxString const &)*arg1);
8999
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 Py_INCREF(Py_None); resultobj = Py_None;
9004 {
9005 if (temp1)
9006 delete arg1;
9007 }
9008 return resultobj;
9009 fail:
9010 {
9011 if (temp1)
9012 delete arg1;
9013 }
9014 return NULL;
9015 }
9016
9017
9018 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj;
9020 wxString *arg1 = 0 ;
9021 bool temp1 = false ;
9022 PyObject * obj0 = 0 ;
9023 char *kwnames[] = {
9024 (char *) "str", NULL
9025 };
9026
9027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9028 {
9029 arg1 = wxString_in_helper(obj0);
9030 if (arg1 == NULL) SWIG_fail;
9031 temp1 = true;
9032 }
9033 {
9034 PyThreadState* __tstate = wxPyBeginAllowThreads();
9035 wxLog::RemoveTraceMask((wxString const &)*arg1);
9036
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 Py_INCREF(Py_None); resultobj = Py_None;
9041 {
9042 if (temp1)
9043 delete arg1;
9044 }
9045 return resultobj;
9046 fail:
9047 {
9048 if (temp1)
9049 delete arg1;
9050 }
9051 return NULL;
9052 }
9053
9054
9055 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9056 PyObject *resultobj;
9057 char *kwnames[] = {
9058 NULL
9059 };
9060
9061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 wxLog::ClearTraceMasks();
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 Py_INCREF(Py_None); resultobj = Py_None;
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9077 PyObject *resultobj;
9078 wxArrayString *result;
9079 char *kwnames[] = {
9080 NULL
9081 };
9082
9083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 {
9087 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9088 result = (wxArrayString *) &_result_ref;
9089 }
9090
9091 wxPyEndAllowThreads(__tstate);
9092 if (PyErr_Occurred()) SWIG_fail;
9093 }
9094 {
9095 resultobj = wxArrayString2PyList_helper(*result);
9096 }
9097 return resultobj;
9098 fail:
9099 return NULL;
9100 }
9101
9102
9103 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9104 PyObject *resultobj;
9105 wxChar *arg1 = (wxChar *) 0 ;
9106 PyObject * obj0 = 0 ;
9107 char *kwnames[] = {
9108 (char *) "ts", NULL
9109 };
9110
9111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9113 if (SWIG_arg_fail(1)) SWIG_fail;
9114 {
9115 PyThreadState* __tstate = wxPyBeginAllowThreads();
9116 wxLog::SetTimestamp((wxChar const *)arg1);
9117
9118 wxPyEndAllowThreads(__tstate);
9119 if (PyErr_Occurred()) SWIG_fail;
9120 }
9121 Py_INCREF(Py_None); resultobj = Py_None;
9122 return resultobj;
9123 fail:
9124 return NULL;
9125 }
9126
9127
9128 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9129 PyObject *resultobj;
9130 bool result;
9131 char *kwnames[] = {
9132 NULL
9133 };
9134
9135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9136 {
9137 PyThreadState* __tstate = wxPyBeginAllowThreads();
9138 result = (bool)wxLog::GetVerbose();
9139
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 {
9144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9145 }
9146 return resultobj;
9147 fail:
9148 return NULL;
9149 }
9150
9151
9152 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9153 PyObject *resultobj;
9154 wxTraceMask result;
9155 char *kwnames[] = {
9156 NULL
9157 };
9158
9159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 result = (wxTraceMask)wxLog::GetTraceMask();
9163
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 {
9168 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9169 }
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9177 PyObject *resultobj;
9178 wxChar *arg1 = (wxChar *) 0 ;
9179 bool result;
9180 PyObject * obj0 = 0 ;
9181 char *kwnames[] = {
9182 (char *) "mask", NULL
9183 };
9184
9185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9187 if (SWIG_arg_fail(1)) SWIG_fail;
9188 {
9189 PyThreadState* __tstate = wxPyBeginAllowThreads();
9190 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9191
9192 wxPyEndAllowThreads(__tstate);
9193 if (PyErr_Occurred()) SWIG_fail;
9194 }
9195 {
9196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9197 }
9198 return resultobj;
9199 fail:
9200 return NULL;
9201 }
9202
9203
9204 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9205 PyObject *resultobj;
9206 wxLogLevel result;
9207 char *kwnames[] = {
9208 NULL
9209 };
9210
9211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 result = (wxLogLevel)wxLog::GetLogLevel();
9215
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 {
9220 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9221 }
9222 return resultobj;
9223 fail:
9224 return NULL;
9225 }
9226
9227
9228 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9229 PyObject *resultobj;
9230 wxChar *result;
9231 char *kwnames[] = {
9232 NULL
9233 };
9234
9235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9236 {
9237 PyThreadState* __tstate = wxPyBeginAllowThreads();
9238 result = (wxChar *)wxLog::GetTimestamp();
9239
9240 wxPyEndAllowThreads(__tstate);
9241 if (PyErr_Occurred()) SWIG_fail;
9242 }
9243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9244 return resultobj;
9245 fail:
9246 return NULL;
9247 }
9248
9249
9250 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9251 PyObject *resultobj;
9252 wxString result;
9253 char *kwnames[] = {
9254 NULL
9255 };
9256
9257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9258 {
9259 PyThreadState* __tstate = wxPyBeginAllowThreads();
9260 result = Log_TimeStamp();
9261
9262 wxPyEndAllowThreads(__tstate);
9263 if (PyErr_Occurred()) SWIG_fail;
9264 }
9265 {
9266 #if wxUSE_UNICODE
9267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9268 #else
9269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9270 #endif
9271 }
9272 return resultobj;
9273 fail:
9274 return NULL;
9275 }
9276
9277
9278 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9279 PyObject *resultobj;
9280 wxLog *arg1 = (wxLog *) 0 ;
9281 PyObject * obj0 = 0 ;
9282 char *kwnames[] = {
9283 (char *) "self", NULL
9284 };
9285
9286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9288 if (SWIG_arg_fail(1)) SWIG_fail;
9289 {
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 wxLog_Destroy(arg1);
9292
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 Py_INCREF(Py_None); resultobj = Py_None;
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9304 PyObject *obj;
9305 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9306 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9307 Py_INCREF(obj);
9308 return Py_BuildValue((char *)"");
9309 }
9310 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9311 PyObject *resultobj;
9312 wxLogStderr *result;
9313 char *kwnames[] = {
9314 NULL
9315 };
9316
9317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 result = (wxLogStderr *)new wxLogStderr();
9321
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9333 PyObject *obj;
9334 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9335 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9336 Py_INCREF(obj);
9337 return Py_BuildValue((char *)"");
9338 }
9339 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9340 PyObject *resultobj;
9341 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9342 wxLogTextCtrl *result;
9343 PyObject * obj0 = 0 ;
9344 char *kwnames[] = {
9345 (char *) "pTextCtrl", NULL
9346 };
9347
9348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9350 if (SWIG_arg_fail(1)) SWIG_fail;
9351 {
9352 PyThreadState* __tstate = wxPyBeginAllowThreads();
9353 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9354
9355 wxPyEndAllowThreads(__tstate);
9356 if (PyErr_Occurred()) SWIG_fail;
9357 }
9358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9359 return resultobj;
9360 fail:
9361 return NULL;
9362 }
9363
9364
9365 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9366 PyObject *obj;
9367 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9368 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9369 Py_INCREF(obj);
9370 return Py_BuildValue((char *)"");
9371 }
9372 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9373 PyObject *resultobj;
9374 wxLogGui *result;
9375 char *kwnames[] = {
9376 NULL
9377 };
9378
9379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9380 {
9381 PyThreadState* __tstate = wxPyBeginAllowThreads();
9382 result = (wxLogGui *)new wxLogGui();
9383
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9388 return resultobj;
9389 fail:
9390 return NULL;
9391 }
9392
9393
9394 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9395 PyObject *obj;
9396 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9397 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9398 Py_INCREF(obj);
9399 return Py_BuildValue((char *)"");
9400 }
9401 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9402 PyObject *resultobj;
9403 wxFrame *arg1 = (wxFrame *) 0 ;
9404 wxString *arg2 = 0 ;
9405 bool arg3 = (bool) true ;
9406 bool arg4 = (bool) true ;
9407 wxLogWindow *result;
9408 bool temp2 = false ;
9409 PyObject * obj0 = 0 ;
9410 PyObject * obj1 = 0 ;
9411 PyObject * obj2 = 0 ;
9412 PyObject * obj3 = 0 ;
9413 char *kwnames[] = {
9414 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9415 };
9416
9417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9419 if (SWIG_arg_fail(1)) SWIG_fail;
9420 {
9421 arg2 = wxString_in_helper(obj1);
9422 if (arg2 == NULL) SWIG_fail;
9423 temp2 = true;
9424 }
9425 if (obj2) {
9426 {
9427 arg3 = (bool)(SWIG_As_bool(obj2));
9428 if (SWIG_arg_fail(3)) SWIG_fail;
9429 }
9430 }
9431 if (obj3) {
9432 {
9433 arg4 = (bool)(SWIG_As_bool(obj3));
9434 if (SWIG_arg_fail(4)) SWIG_fail;
9435 }
9436 }
9437 {
9438 PyThreadState* __tstate = wxPyBeginAllowThreads();
9439 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9440
9441 wxPyEndAllowThreads(__tstate);
9442 if (PyErr_Occurred()) SWIG_fail;
9443 }
9444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9445 {
9446 if (temp2)
9447 delete arg2;
9448 }
9449 return resultobj;
9450 fail:
9451 {
9452 if (temp2)
9453 delete arg2;
9454 }
9455 return NULL;
9456 }
9457
9458
9459 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9460 PyObject *resultobj;
9461 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9462 bool arg2 = (bool) true ;
9463 PyObject * obj0 = 0 ;
9464 PyObject * obj1 = 0 ;
9465 char *kwnames[] = {
9466 (char *) "self",(char *) "bShow", NULL
9467 };
9468
9469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9471 if (SWIG_arg_fail(1)) SWIG_fail;
9472 if (obj1) {
9473 {
9474 arg2 = (bool)(SWIG_As_bool(obj1));
9475 if (SWIG_arg_fail(2)) SWIG_fail;
9476 }
9477 }
9478 {
9479 PyThreadState* __tstate = wxPyBeginAllowThreads();
9480 (arg1)->Show(arg2);
9481
9482 wxPyEndAllowThreads(__tstate);
9483 if (PyErr_Occurred()) SWIG_fail;
9484 }
9485 Py_INCREF(Py_None); resultobj = Py_None;
9486 return resultobj;
9487 fail:
9488 return NULL;
9489 }
9490
9491
9492 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9493 PyObject *resultobj;
9494 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9495 wxFrame *result;
9496 PyObject * obj0 = 0 ;
9497 char *kwnames[] = {
9498 (char *) "self", NULL
9499 };
9500
9501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9503 if (SWIG_arg_fail(1)) SWIG_fail;
9504 {
9505 PyThreadState* __tstate = wxPyBeginAllowThreads();
9506 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9507
9508 wxPyEndAllowThreads(__tstate);
9509 if (PyErr_Occurred()) SWIG_fail;
9510 }
9511 {
9512 resultobj = wxPyMake_wxObject(result, 0);
9513 }
9514 return resultobj;
9515 fail:
9516 return NULL;
9517 }
9518
9519
9520 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9521 PyObject *resultobj;
9522 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9523 wxLog *result;
9524 PyObject * obj0 = 0 ;
9525 char *kwnames[] = {
9526 (char *) "self", NULL
9527 };
9528
9529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9531 if (SWIG_arg_fail(1)) SWIG_fail;
9532 {
9533 PyThreadState* __tstate = wxPyBeginAllowThreads();
9534 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9535
9536 wxPyEndAllowThreads(__tstate);
9537 if (PyErr_Occurred()) SWIG_fail;
9538 }
9539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9540 return resultobj;
9541 fail:
9542 return NULL;
9543 }
9544
9545
9546 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9547 PyObject *resultobj;
9548 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9549 bool result;
9550 PyObject * obj0 = 0 ;
9551 char *kwnames[] = {
9552 (char *) "self", NULL
9553 };
9554
9555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9557 if (SWIG_arg_fail(1)) SWIG_fail;
9558 {
9559 PyThreadState* __tstate = wxPyBeginAllowThreads();
9560 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9561
9562 wxPyEndAllowThreads(__tstate);
9563 if (PyErr_Occurred()) SWIG_fail;
9564 }
9565 {
9566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9567 }
9568 return resultobj;
9569 fail:
9570 return NULL;
9571 }
9572
9573
9574 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9575 PyObject *resultobj;
9576 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9577 bool arg2 ;
9578 PyObject * obj0 = 0 ;
9579 PyObject * obj1 = 0 ;
9580 char *kwnames[] = {
9581 (char *) "self",(char *) "bDoPass", NULL
9582 };
9583
9584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9586 if (SWIG_arg_fail(1)) SWIG_fail;
9587 {
9588 arg2 = (bool)(SWIG_As_bool(obj1));
9589 if (SWIG_arg_fail(2)) SWIG_fail;
9590 }
9591 {
9592 PyThreadState* __tstate = wxPyBeginAllowThreads();
9593 (arg1)->PassMessages(arg2);
9594
9595 wxPyEndAllowThreads(__tstate);
9596 if (PyErr_Occurred()) SWIG_fail;
9597 }
9598 Py_INCREF(Py_None); resultobj = Py_None;
9599 return resultobj;
9600 fail:
9601 return NULL;
9602 }
9603
9604
9605 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9606 PyObject *obj;
9607 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9608 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9609 Py_INCREF(obj);
9610 return Py_BuildValue((char *)"");
9611 }
9612 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9613 PyObject *resultobj;
9614 wxLog *arg1 = (wxLog *) 0 ;
9615 wxLogChain *result;
9616 PyObject * obj0 = 0 ;
9617 char *kwnames[] = {
9618 (char *) "logger", NULL
9619 };
9620
9621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9623 if (SWIG_arg_fail(1)) SWIG_fail;
9624 {
9625 PyThreadState* __tstate = wxPyBeginAllowThreads();
9626 result = (wxLogChain *)new wxLogChain(arg1);
9627
9628 wxPyEndAllowThreads(__tstate);
9629 if (PyErr_Occurred()) SWIG_fail;
9630 }
9631 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9632 return resultobj;
9633 fail:
9634 return NULL;
9635 }
9636
9637
9638 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9639 PyObject *resultobj;
9640 wxLogChain *arg1 = (wxLogChain *) 0 ;
9641 wxLog *arg2 = (wxLog *) 0 ;
9642 PyObject * obj0 = 0 ;
9643 PyObject * obj1 = 0 ;
9644 char *kwnames[] = {
9645 (char *) "self",(char *) "logger", NULL
9646 };
9647
9648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9650 if (SWIG_arg_fail(1)) SWIG_fail;
9651 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9652 if (SWIG_arg_fail(2)) SWIG_fail;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 (arg1)->SetLog(arg2);
9656
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 Py_INCREF(Py_None); resultobj = Py_None;
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9668 PyObject *resultobj;
9669 wxLogChain *arg1 = (wxLogChain *) 0 ;
9670 bool arg2 ;
9671 PyObject * obj0 = 0 ;
9672 PyObject * obj1 = 0 ;
9673 char *kwnames[] = {
9674 (char *) "self",(char *) "bDoPass", NULL
9675 };
9676
9677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9679 if (SWIG_arg_fail(1)) SWIG_fail;
9680 {
9681 arg2 = (bool)(SWIG_As_bool(obj1));
9682 if (SWIG_arg_fail(2)) SWIG_fail;
9683 }
9684 {
9685 PyThreadState* __tstate = wxPyBeginAllowThreads();
9686 (arg1)->PassMessages(arg2);
9687
9688 wxPyEndAllowThreads(__tstate);
9689 if (PyErr_Occurred()) SWIG_fail;
9690 }
9691 Py_INCREF(Py_None); resultobj = Py_None;
9692 return resultobj;
9693 fail:
9694 return NULL;
9695 }
9696
9697
9698 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9699 PyObject *resultobj;
9700 wxLogChain *arg1 = (wxLogChain *) 0 ;
9701 bool result;
9702 PyObject * obj0 = 0 ;
9703 char *kwnames[] = {
9704 (char *) "self", NULL
9705 };
9706
9707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9709 if (SWIG_arg_fail(1)) SWIG_fail;
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 result = (bool)(arg1)->IsPassingMessages();
9713
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 {
9718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9719 }
9720 return resultobj;
9721 fail:
9722 return NULL;
9723 }
9724
9725
9726 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9727 PyObject *resultobj;
9728 wxLogChain *arg1 = (wxLogChain *) 0 ;
9729 wxLog *result;
9730 PyObject * obj0 = 0 ;
9731 char *kwnames[] = {
9732 (char *) "self", NULL
9733 };
9734
9735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9737 if (SWIG_arg_fail(1)) SWIG_fail;
9738 {
9739 PyThreadState* __tstate = wxPyBeginAllowThreads();
9740 result = (wxLog *)(arg1)->GetOldLog();
9741
9742 wxPyEndAllowThreads(__tstate);
9743 if (PyErr_Occurred()) SWIG_fail;
9744 }
9745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9746 return resultobj;
9747 fail:
9748 return NULL;
9749 }
9750
9751
9752 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9753 PyObject *obj;
9754 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9755 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9756 Py_INCREF(obj);
9757 return Py_BuildValue((char *)"");
9758 }
9759 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9760 PyObject *resultobj;
9761 unsigned long result;
9762 char *kwnames[] = {
9763 NULL
9764 };
9765
9766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9767 {
9768 PyThreadState* __tstate = wxPyBeginAllowThreads();
9769 result = (unsigned long)wxSysErrorCode();
9770
9771 wxPyEndAllowThreads(__tstate);
9772 if (PyErr_Occurred()) SWIG_fail;
9773 }
9774 {
9775 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9776 }
9777 return resultobj;
9778 fail:
9779 return NULL;
9780 }
9781
9782
9783 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9784 PyObject *resultobj;
9785 unsigned long arg1 = (unsigned long) 0 ;
9786 wxString result;
9787 PyObject * obj0 = 0 ;
9788 char *kwnames[] = {
9789 (char *) "nErrCode", NULL
9790 };
9791
9792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9793 if (obj0) {
9794 {
9795 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9796 if (SWIG_arg_fail(1)) SWIG_fail;
9797 }
9798 }
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 result = wxSysErrorMsg(arg1);
9802
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 {
9807 #if wxUSE_UNICODE
9808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9809 #else
9810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9811 #endif
9812 }
9813 return resultobj;
9814 fail:
9815 return NULL;
9816 }
9817
9818
9819 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9820 PyObject *resultobj;
9821 wxString *arg1 = 0 ;
9822 bool temp1 = false ;
9823 PyObject * obj0 = 0 ;
9824 char *kwnames[] = {
9825 (char *) "msg", NULL
9826 };
9827
9828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9829 {
9830 arg1 = wxString_in_helper(obj0);
9831 if (arg1 == NULL) SWIG_fail;
9832 temp1 = true;
9833 }
9834 {
9835 PyThreadState* __tstate = wxPyBeginAllowThreads();
9836 wxPyLogFatalError((wxString const &)*arg1);
9837
9838 wxPyEndAllowThreads(__tstate);
9839 if (PyErr_Occurred()) SWIG_fail;
9840 }
9841 Py_INCREF(Py_None); resultobj = Py_None;
9842 {
9843 if (temp1)
9844 delete arg1;
9845 }
9846 return resultobj;
9847 fail:
9848 {
9849 if (temp1)
9850 delete arg1;
9851 }
9852 return NULL;
9853 }
9854
9855
9856 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9857 PyObject *resultobj;
9858 wxString *arg1 = 0 ;
9859 bool temp1 = false ;
9860 PyObject * obj0 = 0 ;
9861 char *kwnames[] = {
9862 (char *) "msg", NULL
9863 };
9864
9865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9866 {
9867 arg1 = wxString_in_helper(obj0);
9868 if (arg1 == NULL) SWIG_fail;
9869 temp1 = true;
9870 }
9871 {
9872 PyThreadState* __tstate = wxPyBeginAllowThreads();
9873 wxPyLogError((wxString const &)*arg1);
9874
9875 wxPyEndAllowThreads(__tstate);
9876 if (PyErr_Occurred()) SWIG_fail;
9877 }
9878 Py_INCREF(Py_None); resultobj = Py_None;
9879 {
9880 if (temp1)
9881 delete arg1;
9882 }
9883 return resultobj;
9884 fail:
9885 {
9886 if (temp1)
9887 delete arg1;
9888 }
9889 return NULL;
9890 }
9891
9892
9893 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9894 PyObject *resultobj;
9895 wxString *arg1 = 0 ;
9896 bool temp1 = false ;
9897 PyObject * obj0 = 0 ;
9898 char *kwnames[] = {
9899 (char *) "msg", NULL
9900 };
9901
9902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9903 {
9904 arg1 = wxString_in_helper(obj0);
9905 if (arg1 == NULL) SWIG_fail;
9906 temp1 = true;
9907 }
9908 {
9909 PyThreadState* __tstate = wxPyBeginAllowThreads();
9910 wxPyLogWarning((wxString const &)*arg1);
9911
9912 wxPyEndAllowThreads(__tstate);
9913 if (PyErr_Occurred()) SWIG_fail;
9914 }
9915 Py_INCREF(Py_None); resultobj = Py_None;
9916 {
9917 if (temp1)
9918 delete arg1;
9919 }
9920 return resultobj;
9921 fail:
9922 {
9923 if (temp1)
9924 delete arg1;
9925 }
9926 return NULL;
9927 }
9928
9929
9930 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9931 PyObject *resultobj;
9932 wxString *arg1 = 0 ;
9933 bool temp1 = false ;
9934 PyObject * obj0 = 0 ;
9935 char *kwnames[] = {
9936 (char *) "msg", NULL
9937 };
9938
9939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9940 {
9941 arg1 = wxString_in_helper(obj0);
9942 if (arg1 == NULL) SWIG_fail;
9943 temp1 = true;
9944 }
9945 {
9946 PyThreadState* __tstate = wxPyBeginAllowThreads();
9947 wxPyLogMessage((wxString const &)*arg1);
9948
9949 wxPyEndAllowThreads(__tstate);
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 Py_INCREF(Py_None); resultobj = Py_None;
9953 {
9954 if (temp1)
9955 delete arg1;
9956 }
9957 return resultobj;
9958 fail:
9959 {
9960 if (temp1)
9961 delete arg1;
9962 }
9963 return NULL;
9964 }
9965
9966
9967 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9968 PyObject *resultobj;
9969 wxString *arg1 = 0 ;
9970 bool temp1 = false ;
9971 PyObject * obj0 = 0 ;
9972 char *kwnames[] = {
9973 (char *) "msg", NULL
9974 };
9975
9976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9977 {
9978 arg1 = wxString_in_helper(obj0);
9979 if (arg1 == NULL) SWIG_fail;
9980 temp1 = true;
9981 }
9982 {
9983 PyThreadState* __tstate = wxPyBeginAllowThreads();
9984 wxPyLogInfo((wxString const &)*arg1);
9985
9986 wxPyEndAllowThreads(__tstate);
9987 if (PyErr_Occurred()) SWIG_fail;
9988 }
9989 Py_INCREF(Py_None); resultobj = Py_None;
9990 {
9991 if (temp1)
9992 delete arg1;
9993 }
9994 return resultobj;
9995 fail:
9996 {
9997 if (temp1)
9998 delete arg1;
9999 }
10000 return NULL;
10001 }
10002
10003
10004 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj;
10006 wxString *arg1 = 0 ;
10007 bool temp1 = false ;
10008 PyObject * obj0 = 0 ;
10009 char *kwnames[] = {
10010 (char *) "msg", NULL
10011 };
10012
10013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10014 {
10015 arg1 = wxString_in_helper(obj0);
10016 if (arg1 == NULL) SWIG_fail;
10017 temp1 = true;
10018 }
10019 {
10020 PyThreadState* __tstate = wxPyBeginAllowThreads();
10021 wxPyLogDebug((wxString const &)*arg1);
10022
10023 wxPyEndAllowThreads(__tstate);
10024 if (PyErr_Occurred()) SWIG_fail;
10025 }
10026 Py_INCREF(Py_None); resultobj = Py_None;
10027 {
10028 if (temp1)
10029 delete arg1;
10030 }
10031 return resultobj;
10032 fail:
10033 {
10034 if (temp1)
10035 delete arg1;
10036 }
10037 return NULL;
10038 }
10039
10040
10041 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10042 PyObject *resultobj;
10043 wxString *arg1 = 0 ;
10044 bool temp1 = false ;
10045 PyObject * obj0 = 0 ;
10046 char *kwnames[] = {
10047 (char *) "msg", NULL
10048 };
10049
10050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10051 {
10052 arg1 = wxString_in_helper(obj0);
10053 if (arg1 == NULL) SWIG_fail;
10054 temp1 = true;
10055 }
10056 {
10057 PyThreadState* __tstate = wxPyBeginAllowThreads();
10058 wxPyLogVerbose((wxString const &)*arg1);
10059
10060 wxPyEndAllowThreads(__tstate);
10061 if (PyErr_Occurred()) SWIG_fail;
10062 }
10063 Py_INCREF(Py_None); resultobj = Py_None;
10064 {
10065 if (temp1)
10066 delete arg1;
10067 }
10068 return resultobj;
10069 fail:
10070 {
10071 if (temp1)
10072 delete arg1;
10073 }
10074 return NULL;
10075 }
10076
10077
10078 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10079 PyObject *resultobj;
10080 wxString *arg1 = 0 ;
10081 bool temp1 = false ;
10082 PyObject * obj0 = 0 ;
10083 char *kwnames[] = {
10084 (char *) "msg", NULL
10085 };
10086
10087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10088 {
10089 arg1 = wxString_in_helper(obj0);
10090 if (arg1 == NULL) SWIG_fail;
10091 temp1 = true;
10092 }
10093 {
10094 PyThreadState* __tstate = wxPyBeginAllowThreads();
10095 wxPyLogStatus((wxString const &)*arg1);
10096
10097 wxPyEndAllowThreads(__tstate);
10098 if (PyErr_Occurred()) SWIG_fail;
10099 }
10100 Py_INCREF(Py_None); resultobj = Py_None;
10101 {
10102 if (temp1)
10103 delete arg1;
10104 }
10105 return resultobj;
10106 fail:
10107 {
10108 if (temp1)
10109 delete arg1;
10110 }
10111 return NULL;
10112 }
10113
10114
10115 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10116 PyObject *resultobj;
10117 wxFrame *arg1 = (wxFrame *) 0 ;
10118 wxString *arg2 = 0 ;
10119 bool temp2 = false ;
10120 PyObject * obj0 = 0 ;
10121 PyObject * obj1 = 0 ;
10122 char *kwnames[] = {
10123 (char *) "pFrame",(char *) "msg", NULL
10124 };
10125
10126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10128 if (SWIG_arg_fail(1)) SWIG_fail;
10129 {
10130 arg2 = wxString_in_helper(obj1);
10131 if (arg2 == NULL) SWIG_fail;
10132 temp2 = true;
10133 }
10134 {
10135 PyThreadState* __tstate = wxPyBeginAllowThreads();
10136 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10137
10138 wxPyEndAllowThreads(__tstate);
10139 if (PyErr_Occurred()) SWIG_fail;
10140 }
10141 Py_INCREF(Py_None); resultobj = Py_None;
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return resultobj;
10147 fail:
10148 {
10149 if (temp2)
10150 delete arg2;
10151 }
10152 return NULL;
10153 }
10154
10155
10156 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10157 PyObject *resultobj;
10158 wxString *arg1 = 0 ;
10159 bool temp1 = false ;
10160 PyObject * obj0 = 0 ;
10161 char *kwnames[] = {
10162 (char *) "msg", NULL
10163 };
10164
10165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10166 {
10167 arg1 = wxString_in_helper(obj0);
10168 if (arg1 == NULL) SWIG_fail;
10169 temp1 = true;
10170 }
10171 {
10172 PyThreadState* __tstate = wxPyBeginAllowThreads();
10173 wxPyLogSysError((wxString const &)*arg1);
10174
10175 wxPyEndAllowThreads(__tstate);
10176 if (PyErr_Occurred()) SWIG_fail;
10177 }
10178 Py_INCREF(Py_None); resultobj = Py_None;
10179 {
10180 if (temp1)
10181 delete arg1;
10182 }
10183 return resultobj;
10184 fail:
10185 {
10186 if (temp1)
10187 delete arg1;
10188 }
10189 return NULL;
10190 }
10191
10192
10193 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10194 PyObject *resultobj;
10195 unsigned long arg1 ;
10196 wxString *arg2 = 0 ;
10197 bool temp2 = false ;
10198 PyObject * obj0 = 0 ;
10199 PyObject * obj1 = 0 ;
10200 char *kwnames[] = {
10201 (char *) "level",(char *) "msg", NULL
10202 };
10203
10204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10205 {
10206 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10207 if (SWIG_arg_fail(1)) SWIG_fail;
10208 }
10209 {
10210 arg2 = wxString_in_helper(obj1);
10211 if (arg2 == NULL) SWIG_fail;
10212 temp2 = true;
10213 }
10214 {
10215 PyThreadState* __tstate = wxPyBeginAllowThreads();
10216 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10217
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 Py_INCREF(Py_None); resultobj = Py_None;
10222 {
10223 if (temp2)
10224 delete arg2;
10225 }
10226 return resultobj;
10227 fail:
10228 {
10229 if (temp2)
10230 delete arg2;
10231 }
10232 return NULL;
10233 }
10234
10235
10236 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10237 PyObject *resultobj;
10238 unsigned long arg1 ;
10239 wxString *arg2 = 0 ;
10240 bool temp2 = false ;
10241 PyObject * obj0 = 0 ;
10242 PyObject * obj1 = 0 ;
10243
10244 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10245 {
10246 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10247 if (SWIG_arg_fail(1)) SWIG_fail;
10248 }
10249 {
10250 arg2 = wxString_in_helper(obj1);
10251 if (arg2 == NULL) SWIG_fail;
10252 temp2 = true;
10253 }
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 wxPyLogTrace(arg1,(wxString const &)*arg2);
10257
10258 wxPyEndAllowThreads(__tstate);
10259 if (PyErr_Occurred()) SWIG_fail;
10260 }
10261 Py_INCREF(Py_None); resultobj = Py_None;
10262 {
10263 if (temp2)
10264 delete arg2;
10265 }
10266 return resultobj;
10267 fail:
10268 {
10269 if (temp2)
10270 delete arg2;
10271 }
10272 return NULL;
10273 }
10274
10275
10276 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10277 PyObject *resultobj;
10278 wxString *arg1 = 0 ;
10279 wxString *arg2 = 0 ;
10280 bool temp1 = false ;
10281 bool temp2 = false ;
10282 PyObject * obj0 = 0 ;
10283 PyObject * obj1 = 0 ;
10284
10285 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10286 {
10287 arg1 = wxString_in_helper(obj0);
10288 if (arg1 == NULL) SWIG_fail;
10289 temp1 = true;
10290 }
10291 {
10292 arg2 = wxString_in_helper(obj1);
10293 if (arg2 == NULL) SWIG_fail;
10294 temp2 = true;
10295 }
10296 {
10297 PyThreadState* __tstate = wxPyBeginAllowThreads();
10298 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10299
10300 wxPyEndAllowThreads(__tstate);
10301 if (PyErr_Occurred()) SWIG_fail;
10302 }
10303 Py_INCREF(Py_None); resultobj = Py_None;
10304 {
10305 if (temp1)
10306 delete arg1;
10307 }
10308 {
10309 if (temp2)
10310 delete arg2;
10311 }
10312 return resultobj;
10313 fail:
10314 {
10315 if (temp1)
10316 delete arg1;
10317 }
10318 {
10319 if (temp2)
10320 delete arg2;
10321 }
10322 return NULL;
10323 }
10324
10325
10326 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10327 int argc;
10328 PyObject *argv[3];
10329 int ii;
10330
10331 argc = PyObject_Length(args);
10332 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10333 argv[ii] = PyTuple_GetItem(args,ii);
10334 }
10335 if (argc == 2) {
10336 int _v;
10337 {
10338 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10339 }
10340 if (_v) {
10341 {
10342 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10343 }
10344 if (_v) {
10345 return _wrap_LogTrace__SWIG_1(self,args);
10346 }
10347 }
10348 }
10349 if (argc == 2) {
10350 int _v;
10351 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10352 if (_v) {
10353 {
10354 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10355 }
10356 if (_v) {
10357 return _wrap_LogTrace__SWIG_0(self,args);
10358 }
10359 }
10360 }
10361
10362 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10363 return NULL;
10364 }
10365
10366
10367 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10368 PyObject *resultobj;
10369 wxString *arg1 = 0 ;
10370 wxString *arg2 = 0 ;
10371 bool temp1 = false ;
10372 bool temp2 = false ;
10373 PyObject * obj0 = 0 ;
10374 PyObject * obj1 = 0 ;
10375 char *kwnames[] = {
10376 (char *) "title",(char *) "text", NULL
10377 };
10378
10379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10380 {
10381 arg1 = wxString_in_helper(obj0);
10382 if (arg1 == NULL) SWIG_fail;
10383 temp1 = true;
10384 }
10385 {
10386 arg2 = wxString_in_helper(obj1);
10387 if (arg2 == NULL) SWIG_fail;
10388 temp2 = true;
10389 }
10390 {
10391 PyThreadState* __tstate = wxPyBeginAllowThreads();
10392 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10393
10394 wxPyEndAllowThreads(__tstate);
10395 if (PyErr_Occurred()) SWIG_fail;
10396 }
10397 Py_INCREF(Py_None); resultobj = Py_None;
10398 {
10399 if (temp1)
10400 delete arg1;
10401 }
10402 {
10403 if (temp2)
10404 delete arg2;
10405 }
10406 return resultobj;
10407 fail:
10408 {
10409 if (temp1)
10410 delete arg1;
10411 }
10412 {
10413 if (temp2)
10414 delete arg2;
10415 }
10416 return NULL;
10417 }
10418
10419
10420 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10421 PyObject *resultobj;
10422 wxLogNull *result;
10423 char *kwnames[] = {
10424 NULL
10425 };
10426
10427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10428 {
10429 PyThreadState* __tstate = wxPyBeginAllowThreads();
10430 result = (wxLogNull *)new wxLogNull();
10431
10432 wxPyEndAllowThreads(__tstate);
10433 if (PyErr_Occurred()) SWIG_fail;
10434 }
10435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10436 return resultobj;
10437 fail:
10438 return NULL;
10439 }
10440
10441
10442 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10443 PyObject *resultobj;
10444 wxLogNull *arg1 = (wxLogNull *) 0 ;
10445 PyObject * obj0 = 0 ;
10446 char *kwnames[] = {
10447 (char *) "self", NULL
10448 };
10449
10450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10452 if (SWIG_arg_fail(1)) SWIG_fail;
10453 {
10454 PyThreadState* __tstate = wxPyBeginAllowThreads();
10455 delete arg1;
10456
10457 wxPyEndAllowThreads(__tstate);
10458 if (PyErr_Occurred()) SWIG_fail;
10459 }
10460 Py_INCREF(Py_None); resultobj = Py_None;
10461 return resultobj;
10462 fail:
10463 return NULL;
10464 }
10465
10466
10467 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10468 PyObject *obj;
10469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10470 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10471 Py_INCREF(obj);
10472 return Py_BuildValue((char *)"");
10473 }
10474 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10475 PyObject *resultobj;
10476 wxPyLog *result;
10477 char *kwnames[] = {
10478 NULL
10479 };
10480
10481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10482 {
10483 PyThreadState* __tstate = wxPyBeginAllowThreads();
10484 result = (wxPyLog *)new wxPyLog();
10485
10486 wxPyEndAllowThreads(__tstate);
10487 if (PyErr_Occurred()) SWIG_fail;
10488 }
10489 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10490 return resultobj;
10491 fail:
10492 return NULL;
10493 }
10494
10495
10496 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10497 PyObject *resultobj;
10498 wxPyLog *arg1 = (wxPyLog *) 0 ;
10499 PyObject *arg2 = (PyObject *) 0 ;
10500 PyObject *arg3 = (PyObject *) 0 ;
10501 PyObject * obj0 = 0 ;
10502 PyObject * obj1 = 0 ;
10503 PyObject * obj2 = 0 ;
10504 char *kwnames[] = {
10505 (char *) "self",(char *) "self",(char *) "_class", NULL
10506 };
10507
10508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10510 if (SWIG_arg_fail(1)) SWIG_fail;
10511 arg2 = obj1;
10512 arg3 = obj2;
10513 {
10514 PyThreadState* __tstate = wxPyBeginAllowThreads();
10515 (arg1)->_setCallbackInfo(arg2,arg3);
10516
10517 wxPyEndAllowThreads(__tstate);
10518 if (PyErr_Occurred()) SWIG_fail;
10519 }
10520 Py_INCREF(Py_None); resultobj = Py_None;
10521 return resultobj;
10522 fail:
10523 return NULL;
10524 }
10525
10526
10527 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10528 PyObject *obj;
10529 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10530 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10531 Py_INCREF(obj);
10532 return Py_BuildValue((char *)"");
10533 }
10534 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10535 PyObject *resultobj;
10536 int arg1 ;
10537 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10538 int arg3 = (int) wxKILL_NOCHILDREN ;
10539 wxKillError result;
10540 PyObject * obj0 = 0 ;
10541 PyObject * obj1 = 0 ;
10542 PyObject * obj2 = 0 ;
10543 char *kwnames[] = {
10544 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10545 };
10546
10547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10548 {
10549 arg1 = (int)(SWIG_As_int(obj0));
10550 if (SWIG_arg_fail(1)) SWIG_fail;
10551 }
10552 if (obj1) {
10553 {
10554 arg2 = (wxSignal)(SWIG_As_int(obj1));
10555 if (SWIG_arg_fail(2)) SWIG_fail;
10556 }
10557 }
10558 if (obj2) {
10559 {
10560 arg3 = (int)(SWIG_As_int(obj2));
10561 if (SWIG_arg_fail(3)) SWIG_fail;
10562 }
10563 }
10564 {
10565 PyThreadState* __tstate = wxPyBeginAllowThreads();
10566 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10567
10568 wxPyEndAllowThreads(__tstate);
10569 if (PyErr_Occurred()) SWIG_fail;
10570 }
10571 resultobj = SWIG_From_int((result));
10572 return resultobj;
10573 fail:
10574 return NULL;
10575 }
10576
10577
10578 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10579 PyObject *resultobj;
10580 int arg1 ;
10581 bool result;
10582 PyObject * obj0 = 0 ;
10583 char *kwnames[] = {
10584 (char *) "pid", NULL
10585 };
10586
10587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10588 {
10589 arg1 = (int)(SWIG_As_int(obj0));
10590 if (SWIG_arg_fail(1)) SWIG_fail;
10591 }
10592 {
10593 PyThreadState* __tstate = wxPyBeginAllowThreads();
10594 result = (bool)wxPyProcess::Exists(arg1);
10595
10596 wxPyEndAllowThreads(__tstate);
10597 if (PyErr_Occurred()) SWIG_fail;
10598 }
10599 {
10600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10601 }
10602 return resultobj;
10603 fail:
10604 return NULL;
10605 }
10606
10607
10608 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10609 PyObject *resultobj;
10610 wxString *arg1 = 0 ;
10611 int arg2 = (int) wxEXEC_ASYNC ;
10612 wxPyProcess *result;
10613 bool temp1 = false ;
10614 PyObject * obj0 = 0 ;
10615 PyObject * obj1 = 0 ;
10616 char *kwnames[] = {
10617 (char *) "cmd",(char *) "flags", NULL
10618 };
10619
10620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10621 {
10622 arg1 = wxString_in_helper(obj0);
10623 if (arg1 == NULL) SWIG_fail;
10624 temp1 = true;
10625 }
10626 if (obj1) {
10627 {
10628 arg2 = (int)(SWIG_As_int(obj1));
10629 if (SWIG_arg_fail(2)) SWIG_fail;
10630 }
10631 }
10632 {
10633 PyThreadState* __tstate = wxPyBeginAllowThreads();
10634 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10635
10636 wxPyEndAllowThreads(__tstate);
10637 if (PyErr_Occurred()) SWIG_fail;
10638 }
10639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10640 {
10641 if (temp1)
10642 delete arg1;
10643 }
10644 return resultobj;
10645 fail:
10646 {
10647 if (temp1)
10648 delete arg1;
10649 }
10650 return NULL;
10651 }
10652
10653
10654 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj;
10656 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10657 int arg2 = (int) -1 ;
10658 wxPyProcess *result;
10659 PyObject * obj0 = 0 ;
10660 PyObject * obj1 = 0 ;
10661 char *kwnames[] = {
10662 (char *) "parent",(char *) "id", NULL
10663 };
10664
10665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10666 if (obj0) {
10667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10668 if (SWIG_arg_fail(1)) SWIG_fail;
10669 }
10670 if (obj1) {
10671 {
10672 arg2 = (int)(SWIG_As_int(obj1));
10673 if (SWIG_arg_fail(2)) SWIG_fail;
10674 }
10675 }
10676 {
10677 PyThreadState* __tstate = wxPyBeginAllowThreads();
10678 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10679
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10684 return resultobj;
10685 fail:
10686 return NULL;
10687 }
10688
10689
10690 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj;
10692 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10693 PyObject *arg2 = (PyObject *) 0 ;
10694 PyObject *arg3 = (PyObject *) 0 ;
10695 PyObject * obj0 = 0 ;
10696 PyObject * obj1 = 0 ;
10697 PyObject * obj2 = 0 ;
10698 char *kwnames[] = {
10699 (char *) "self",(char *) "self",(char *) "_class", NULL
10700 };
10701
10702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10704 if (SWIG_arg_fail(1)) SWIG_fail;
10705 arg2 = obj1;
10706 arg3 = obj2;
10707 {
10708 PyThreadState* __tstate = wxPyBeginAllowThreads();
10709 (arg1)->_setCallbackInfo(arg2,arg3);
10710
10711 wxPyEndAllowThreads(__tstate);
10712 if (PyErr_Occurred()) SWIG_fail;
10713 }
10714 Py_INCREF(Py_None); resultobj = Py_None;
10715 return resultobj;
10716 fail:
10717 return NULL;
10718 }
10719
10720
10721 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10722 PyObject *resultobj;
10723 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10724 int arg2 ;
10725 int arg3 ;
10726 PyObject * obj0 = 0 ;
10727 PyObject * obj1 = 0 ;
10728 PyObject * obj2 = 0 ;
10729 char *kwnames[] = {
10730 (char *) "self",(char *) "pid",(char *) "status", NULL
10731 };
10732
10733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10735 if (SWIG_arg_fail(1)) SWIG_fail;
10736 {
10737 arg2 = (int)(SWIG_As_int(obj1));
10738 if (SWIG_arg_fail(2)) SWIG_fail;
10739 }
10740 {
10741 arg3 = (int)(SWIG_As_int(obj2));
10742 if (SWIG_arg_fail(3)) SWIG_fail;
10743 }
10744 {
10745 PyThreadState* __tstate = wxPyBeginAllowThreads();
10746 (arg1)->base_OnTerminate(arg2,arg3);
10747
10748 wxPyEndAllowThreads(__tstate);
10749 if (PyErr_Occurred()) SWIG_fail;
10750 }
10751 Py_INCREF(Py_None); resultobj = Py_None;
10752 return resultobj;
10753 fail:
10754 return NULL;
10755 }
10756
10757
10758 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10759 PyObject *resultobj;
10760 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10761 PyObject * obj0 = 0 ;
10762 char *kwnames[] = {
10763 (char *) "self", NULL
10764 };
10765
10766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10768 if (SWIG_arg_fail(1)) SWIG_fail;
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 (arg1)->Redirect();
10772
10773 wxPyEndAllowThreads(__tstate);
10774 if (PyErr_Occurred()) SWIG_fail;
10775 }
10776 Py_INCREF(Py_None); resultobj = Py_None;
10777 return resultobj;
10778 fail:
10779 return NULL;
10780 }
10781
10782
10783 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10784 PyObject *resultobj;
10785 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10786 bool result;
10787 PyObject * obj0 = 0 ;
10788 char *kwnames[] = {
10789 (char *) "self", NULL
10790 };
10791
10792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10794 if (SWIG_arg_fail(1)) SWIG_fail;
10795 {
10796 PyThreadState* __tstate = wxPyBeginAllowThreads();
10797 result = (bool)(arg1)->IsRedirected();
10798
10799 wxPyEndAllowThreads(__tstate);
10800 if (PyErr_Occurred()) SWIG_fail;
10801 }
10802 {
10803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10804 }
10805 return resultobj;
10806 fail:
10807 return NULL;
10808 }
10809
10810
10811 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10812 PyObject *resultobj;
10813 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10814 PyObject * obj0 = 0 ;
10815 char *kwnames[] = {
10816 (char *) "self", NULL
10817 };
10818
10819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10821 if (SWIG_arg_fail(1)) SWIG_fail;
10822 {
10823 PyThreadState* __tstate = wxPyBeginAllowThreads();
10824 (arg1)->Detach();
10825
10826 wxPyEndAllowThreads(__tstate);
10827 if (PyErr_Occurred()) SWIG_fail;
10828 }
10829 Py_INCREF(Py_None); resultobj = Py_None;
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10839 wxInputStream *result;
10840 PyObject * obj0 = 0 ;
10841 char *kwnames[] = {
10842 (char *) "self", NULL
10843 };
10844
10845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10847 if (SWIG_arg_fail(1)) SWIG_fail;
10848 {
10849 PyThreadState* __tstate = wxPyBeginAllowThreads();
10850 result = (wxInputStream *)(arg1)->GetInputStream();
10851
10852 wxPyEndAllowThreads(__tstate);
10853 if (PyErr_Occurred()) SWIG_fail;
10854 }
10855 {
10856 wxPyInputStream * _ptr = NULL;
10857
10858 if (result) {
10859 _ptr = new wxPyInputStream(result);
10860 }
10861 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10862 }
10863 return resultobj;
10864 fail:
10865 return NULL;
10866 }
10867
10868
10869 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10870 PyObject *resultobj;
10871 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10872 wxInputStream *result;
10873 PyObject * obj0 = 0 ;
10874 char *kwnames[] = {
10875 (char *) "self", NULL
10876 };
10877
10878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10880 if (SWIG_arg_fail(1)) SWIG_fail;
10881 {
10882 PyThreadState* __tstate = wxPyBeginAllowThreads();
10883 result = (wxInputStream *)(arg1)->GetErrorStream();
10884
10885 wxPyEndAllowThreads(__tstate);
10886 if (PyErr_Occurred()) SWIG_fail;
10887 }
10888 {
10889 wxPyInputStream * _ptr = NULL;
10890
10891 if (result) {
10892 _ptr = new wxPyInputStream(result);
10893 }
10894 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10895 }
10896 return resultobj;
10897 fail:
10898 return NULL;
10899 }
10900
10901
10902 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10903 PyObject *resultobj;
10904 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10905 wxOutputStream *result;
10906 PyObject * obj0 = 0 ;
10907 char *kwnames[] = {
10908 (char *) "self", NULL
10909 };
10910
10911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10913 if (SWIG_arg_fail(1)) SWIG_fail;
10914 {
10915 PyThreadState* __tstate = wxPyBeginAllowThreads();
10916 result = (wxOutputStream *)(arg1)->GetOutputStream();
10917
10918 wxPyEndAllowThreads(__tstate);
10919 if (PyErr_Occurred()) SWIG_fail;
10920 }
10921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10922 return resultobj;
10923 fail:
10924 return NULL;
10925 }
10926
10927
10928 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10929 PyObject *resultobj;
10930 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10931 PyObject * obj0 = 0 ;
10932 char *kwnames[] = {
10933 (char *) "self", NULL
10934 };
10935
10936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10938 if (SWIG_arg_fail(1)) SWIG_fail;
10939 {
10940 PyThreadState* __tstate = wxPyBeginAllowThreads();
10941 (arg1)->CloseOutput();
10942
10943 wxPyEndAllowThreads(__tstate);
10944 if (PyErr_Occurred()) SWIG_fail;
10945 }
10946 Py_INCREF(Py_None); resultobj = Py_None;
10947 return resultobj;
10948 fail:
10949 return NULL;
10950 }
10951
10952
10953 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10954 PyObject *resultobj;
10955 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10956 bool result;
10957 PyObject * obj0 = 0 ;
10958 char *kwnames[] = {
10959 (char *) "self", NULL
10960 };
10961
10962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10964 if (SWIG_arg_fail(1)) SWIG_fail;
10965 {
10966 PyThreadState* __tstate = wxPyBeginAllowThreads();
10967 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
10968
10969 wxPyEndAllowThreads(__tstate);
10970 if (PyErr_Occurred()) SWIG_fail;
10971 }
10972 {
10973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10974 }
10975 return resultobj;
10976 fail:
10977 return NULL;
10978 }
10979
10980
10981 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10982 PyObject *resultobj;
10983 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10984 bool result;
10985 PyObject * obj0 = 0 ;
10986 char *kwnames[] = {
10987 (char *) "self", NULL
10988 };
10989
10990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
10991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10992 if (SWIG_arg_fail(1)) SWIG_fail;
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
10996
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 {
11001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11002 }
11003 return resultobj;
11004 fail:
11005 return NULL;
11006 }
11007
11008
11009 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11010 PyObject *resultobj;
11011 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11012 bool result;
11013 PyObject * obj0 = 0 ;
11014 char *kwnames[] = {
11015 (char *) "self", NULL
11016 };
11017
11018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11020 if (SWIG_arg_fail(1)) SWIG_fail;
11021 {
11022 PyThreadState* __tstate = wxPyBeginAllowThreads();
11023 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11024
11025 wxPyEndAllowThreads(__tstate);
11026 if (PyErr_Occurred()) SWIG_fail;
11027 }
11028 {
11029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11030 }
11031 return resultobj;
11032 fail:
11033 return NULL;
11034 }
11035
11036
11037 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11038 PyObject *obj;
11039 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11040 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11041 Py_INCREF(obj);
11042 return Py_BuildValue((char *)"");
11043 }
11044 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11045 PyObject *resultobj;
11046 int arg1 = (int) 0 ;
11047 int arg2 = (int) 0 ;
11048 int arg3 = (int) 0 ;
11049 wxProcessEvent *result;
11050 PyObject * obj0 = 0 ;
11051 PyObject * obj1 = 0 ;
11052 PyObject * obj2 = 0 ;
11053 char *kwnames[] = {
11054 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11055 };
11056
11057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11058 if (obj0) {
11059 {
11060 arg1 = (int)(SWIG_As_int(obj0));
11061 if (SWIG_arg_fail(1)) SWIG_fail;
11062 }
11063 }
11064 if (obj1) {
11065 {
11066 arg2 = (int)(SWIG_As_int(obj1));
11067 if (SWIG_arg_fail(2)) SWIG_fail;
11068 }
11069 }
11070 if (obj2) {
11071 {
11072 arg3 = (int)(SWIG_As_int(obj2));
11073 if (SWIG_arg_fail(3)) SWIG_fail;
11074 }
11075 }
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11079
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11084 return resultobj;
11085 fail:
11086 return NULL;
11087 }
11088
11089
11090 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11091 PyObject *resultobj;
11092 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11093 int result;
11094 PyObject * obj0 = 0 ;
11095 char *kwnames[] = {
11096 (char *) "self", NULL
11097 };
11098
11099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11101 if (SWIG_arg_fail(1)) SWIG_fail;
11102 {
11103 PyThreadState* __tstate = wxPyBeginAllowThreads();
11104 result = (int)(arg1)->GetPid();
11105
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 {
11110 resultobj = SWIG_From_int((int)(result));
11111 }
11112 return resultobj;
11113 fail:
11114 return NULL;
11115 }
11116
11117
11118 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11119 PyObject *resultobj;
11120 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11121 int result;
11122 PyObject * obj0 = 0 ;
11123 char *kwnames[] = {
11124 (char *) "self", NULL
11125 };
11126
11127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11129 if (SWIG_arg_fail(1)) SWIG_fail;
11130 {
11131 PyThreadState* __tstate = wxPyBeginAllowThreads();
11132 result = (int)(arg1)->GetExitCode();
11133
11134 wxPyEndAllowThreads(__tstate);
11135 if (PyErr_Occurred()) SWIG_fail;
11136 }
11137 {
11138 resultobj = SWIG_From_int((int)(result));
11139 }
11140 return resultobj;
11141 fail:
11142 return NULL;
11143 }
11144
11145
11146 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11147 PyObject *resultobj;
11148 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11149 int arg2 ;
11150 PyObject * obj0 = 0 ;
11151 PyObject * obj1 = 0 ;
11152 char *kwnames[] = {
11153 (char *) "self",(char *) "m_pid", NULL
11154 };
11155
11156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11158 if (SWIG_arg_fail(1)) SWIG_fail;
11159 {
11160 arg2 = (int)(SWIG_As_int(obj1));
11161 if (SWIG_arg_fail(2)) SWIG_fail;
11162 }
11163 if (arg1) (arg1)->m_pid = arg2;
11164
11165 Py_INCREF(Py_None); resultobj = Py_None;
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11173 PyObject *resultobj;
11174 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11175 int result;
11176 PyObject * obj0 = 0 ;
11177 char *kwnames[] = {
11178 (char *) "self", NULL
11179 };
11180
11181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11183 if (SWIG_arg_fail(1)) SWIG_fail;
11184 result = (int) ((arg1)->m_pid);
11185
11186 {
11187 resultobj = SWIG_From_int((int)(result));
11188 }
11189 return resultobj;
11190 fail:
11191 return NULL;
11192 }
11193
11194
11195 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11196 PyObject *resultobj;
11197 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11198 int arg2 ;
11199 PyObject * obj0 = 0 ;
11200 PyObject * obj1 = 0 ;
11201 char *kwnames[] = {
11202 (char *) "self",(char *) "m_exitcode", NULL
11203 };
11204
11205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11207 if (SWIG_arg_fail(1)) SWIG_fail;
11208 {
11209 arg2 = (int)(SWIG_As_int(obj1));
11210 if (SWIG_arg_fail(2)) SWIG_fail;
11211 }
11212 if (arg1) (arg1)->m_exitcode = arg2;
11213
11214 Py_INCREF(Py_None); resultobj = Py_None;
11215 return resultobj;
11216 fail:
11217 return NULL;
11218 }
11219
11220
11221 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11222 PyObject *resultobj;
11223 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11224 int result;
11225 PyObject * obj0 = 0 ;
11226 char *kwnames[] = {
11227 (char *) "self", NULL
11228 };
11229
11230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11232 if (SWIG_arg_fail(1)) SWIG_fail;
11233 result = (int) ((arg1)->m_exitcode);
11234
11235 {
11236 resultobj = SWIG_From_int((int)(result));
11237 }
11238 return resultobj;
11239 fail:
11240 return NULL;
11241 }
11242
11243
11244 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11245 PyObject *obj;
11246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11247 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11248 Py_INCREF(obj);
11249 return Py_BuildValue((char *)"");
11250 }
11251 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11252 PyObject *resultobj;
11253 wxString *arg1 = 0 ;
11254 int arg2 = (int) wxEXEC_ASYNC ;
11255 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11256 long result;
11257 bool temp1 = false ;
11258 PyObject * obj0 = 0 ;
11259 PyObject * obj1 = 0 ;
11260 PyObject * obj2 = 0 ;
11261 char *kwnames[] = {
11262 (char *) "command",(char *) "flags",(char *) "process", NULL
11263 };
11264
11265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11266 {
11267 arg1 = wxString_in_helper(obj0);
11268 if (arg1 == NULL) SWIG_fail;
11269 temp1 = true;
11270 }
11271 if (obj1) {
11272 {
11273 arg2 = (int)(SWIG_As_int(obj1));
11274 if (SWIG_arg_fail(2)) SWIG_fail;
11275 }
11276 }
11277 if (obj2) {
11278 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11279 if (SWIG_arg_fail(3)) SWIG_fail;
11280 }
11281 {
11282 if (!wxPyCheckForApp()) SWIG_fail;
11283 PyThreadState* __tstate = wxPyBeginAllowThreads();
11284 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11285
11286 wxPyEndAllowThreads(__tstate);
11287 if (PyErr_Occurred()) SWIG_fail;
11288 }
11289 {
11290 resultobj = SWIG_From_long((long)(result));
11291 }
11292 {
11293 if (temp1)
11294 delete arg1;
11295 }
11296 return resultobj;
11297 fail:
11298 {
11299 if (temp1)
11300 delete arg1;
11301 }
11302 return NULL;
11303 }
11304
11305
11306 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11307 PyObject *resultobj;
11308 long arg1 ;
11309 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11310 wxKillError *arg3 = (wxKillError *) 0 ;
11311 int arg4 = (int) wxKILL_NOCHILDREN ;
11312 int result;
11313 wxKillError temp3 ;
11314 PyObject * obj0 = 0 ;
11315 PyObject * obj1 = 0 ;
11316 PyObject * obj2 = 0 ;
11317 char *kwnames[] = {
11318 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11319 };
11320
11321 {
11322 arg3 = &temp3;
11323 }
11324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11325 {
11326 arg1 = (long)(SWIG_As_long(obj0));
11327 if (SWIG_arg_fail(1)) SWIG_fail;
11328 }
11329 if (obj1) {
11330 {
11331 arg2 = (wxSignal)(SWIG_As_int(obj1));
11332 if (SWIG_arg_fail(2)) SWIG_fail;
11333 }
11334 }
11335 if (obj2) {
11336 {
11337 arg4 = (int)(SWIG_As_int(obj2));
11338 if (SWIG_arg_fail(4)) SWIG_fail;
11339 }
11340 }
11341 {
11342 PyThreadState* __tstate = wxPyBeginAllowThreads();
11343 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11344
11345 wxPyEndAllowThreads(__tstate);
11346 if (PyErr_Occurred()) SWIG_fail;
11347 }
11348 {
11349 resultobj = SWIG_From_int((int)(result));
11350 }
11351 {
11352 PyObject* o;
11353 o = PyInt_FromLong((long) (*arg3));
11354 resultobj = t_output_helper(resultobj, o);
11355 }
11356 return resultobj;
11357 fail:
11358 return NULL;
11359 }
11360
11361
11362 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11363 PyObject *resultobj;
11364 int arg1 = (int) wxJOYSTICK1 ;
11365 wxJoystick *result;
11366 PyObject * obj0 = 0 ;
11367 char *kwnames[] = {
11368 (char *) "joystick", NULL
11369 };
11370
11371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11372 if (obj0) {
11373 {
11374 arg1 = (int)(SWIG_As_int(obj0));
11375 if (SWIG_arg_fail(1)) SWIG_fail;
11376 }
11377 }
11378 {
11379 if (!wxPyCheckForApp()) SWIG_fail;
11380 PyThreadState* __tstate = wxPyBeginAllowThreads();
11381 result = (wxJoystick *)new wxJoystick(arg1);
11382
11383 wxPyEndAllowThreads(__tstate);
11384 if (PyErr_Occurred()) SWIG_fail;
11385 }
11386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11387 return resultobj;
11388 fail:
11389 return NULL;
11390 }
11391
11392
11393 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11394 PyObject *resultobj;
11395 wxJoystick *arg1 = (wxJoystick *) 0 ;
11396 PyObject * obj0 = 0 ;
11397 char *kwnames[] = {
11398 (char *) "self", NULL
11399 };
11400
11401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11403 if (SWIG_arg_fail(1)) SWIG_fail;
11404 {
11405 PyThreadState* __tstate = wxPyBeginAllowThreads();
11406 delete arg1;
11407
11408 wxPyEndAllowThreads(__tstate);
11409 if (PyErr_Occurred()) SWIG_fail;
11410 }
11411 Py_INCREF(Py_None); resultobj = Py_None;
11412 return resultobj;
11413 fail:
11414 return NULL;
11415 }
11416
11417
11418 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11419 PyObject *resultobj;
11420 wxJoystick *arg1 = (wxJoystick *) 0 ;
11421 wxPoint result;
11422 PyObject * obj0 = 0 ;
11423 char *kwnames[] = {
11424 (char *) "self", NULL
11425 };
11426
11427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11429 if (SWIG_arg_fail(1)) SWIG_fail;
11430 {
11431 PyThreadState* __tstate = wxPyBeginAllowThreads();
11432 result = (arg1)->GetPosition();
11433
11434 wxPyEndAllowThreads(__tstate);
11435 if (PyErr_Occurred()) SWIG_fail;
11436 }
11437 {
11438 wxPoint * resultptr;
11439 resultptr = new wxPoint((wxPoint &)(result));
11440 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11441 }
11442 return resultobj;
11443 fail:
11444 return NULL;
11445 }
11446
11447
11448 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11449 PyObject *resultobj;
11450 wxJoystick *arg1 = (wxJoystick *) 0 ;
11451 int result;
11452 PyObject * obj0 = 0 ;
11453 char *kwnames[] = {
11454 (char *) "self", NULL
11455 };
11456
11457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11459 if (SWIG_arg_fail(1)) SWIG_fail;
11460 {
11461 PyThreadState* __tstate = wxPyBeginAllowThreads();
11462 result = (int)(arg1)->GetZPosition();
11463
11464 wxPyEndAllowThreads(__tstate);
11465 if (PyErr_Occurred()) SWIG_fail;
11466 }
11467 {
11468 resultobj = SWIG_From_int((int)(result));
11469 }
11470 return resultobj;
11471 fail:
11472 return NULL;
11473 }
11474
11475
11476 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11477 PyObject *resultobj;
11478 wxJoystick *arg1 = (wxJoystick *) 0 ;
11479 int result;
11480 PyObject * obj0 = 0 ;
11481 char *kwnames[] = {
11482 (char *) "self", NULL
11483 };
11484
11485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11487 if (SWIG_arg_fail(1)) SWIG_fail;
11488 {
11489 PyThreadState* __tstate = wxPyBeginAllowThreads();
11490 result = (int)(arg1)->GetButtonState();
11491
11492 wxPyEndAllowThreads(__tstate);
11493 if (PyErr_Occurred()) SWIG_fail;
11494 }
11495 {
11496 resultobj = SWIG_From_int((int)(result));
11497 }
11498 return resultobj;
11499 fail:
11500 return NULL;
11501 }
11502
11503
11504 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11505 PyObject *resultobj;
11506 wxJoystick *arg1 = (wxJoystick *) 0 ;
11507 int result;
11508 PyObject * obj0 = 0 ;
11509 char *kwnames[] = {
11510 (char *) "self", NULL
11511 };
11512
11513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11515 if (SWIG_arg_fail(1)) SWIG_fail;
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 result = (int)(arg1)->GetPOVPosition();
11519
11520 wxPyEndAllowThreads(__tstate);
11521 if (PyErr_Occurred()) SWIG_fail;
11522 }
11523 {
11524 resultobj = SWIG_From_int((int)(result));
11525 }
11526 return resultobj;
11527 fail:
11528 return NULL;
11529 }
11530
11531
11532 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11533 PyObject *resultobj;
11534 wxJoystick *arg1 = (wxJoystick *) 0 ;
11535 int result;
11536 PyObject * obj0 = 0 ;
11537 char *kwnames[] = {
11538 (char *) "self", NULL
11539 };
11540
11541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11543 if (SWIG_arg_fail(1)) SWIG_fail;
11544 {
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 result = (int)(arg1)->GetPOVCTSPosition();
11547
11548 wxPyEndAllowThreads(__tstate);
11549 if (PyErr_Occurred()) SWIG_fail;
11550 }
11551 {
11552 resultobj = SWIG_From_int((int)(result));
11553 }
11554 return resultobj;
11555 fail:
11556 return NULL;
11557 }
11558
11559
11560 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11561 PyObject *resultobj;
11562 wxJoystick *arg1 = (wxJoystick *) 0 ;
11563 int result;
11564 PyObject * obj0 = 0 ;
11565 char *kwnames[] = {
11566 (char *) "self", NULL
11567 };
11568
11569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11571 if (SWIG_arg_fail(1)) SWIG_fail;
11572 {
11573 PyThreadState* __tstate = wxPyBeginAllowThreads();
11574 result = (int)(arg1)->GetRudderPosition();
11575
11576 wxPyEndAllowThreads(__tstate);
11577 if (PyErr_Occurred()) SWIG_fail;
11578 }
11579 {
11580 resultobj = SWIG_From_int((int)(result));
11581 }
11582 return resultobj;
11583 fail:
11584 return NULL;
11585 }
11586
11587
11588 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11589 PyObject *resultobj;
11590 wxJoystick *arg1 = (wxJoystick *) 0 ;
11591 int result;
11592 PyObject * obj0 = 0 ;
11593 char *kwnames[] = {
11594 (char *) "self", NULL
11595 };
11596
11597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11599 if (SWIG_arg_fail(1)) SWIG_fail;
11600 {
11601 PyThreadState* __tstate = wxPyBeginAllowThreads();
11602 result = (int)(arg1)->GetUPosition();
11603
11604 wxPyEndAllowThreads(__tstate);
11605 if (PyErr_Occurred()) SWIG_fail;
11606 }
11607 {
11608 resultobj = SWIG_From_int((int)(result));
11609 }
11610 return resultobj;
11611 fail:
11612 return NULL;
11613 }
11614
11615
11616 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11617 PyObject *resultobj;
11618 wxJoystick *arg1 = (wxJoystick *) 0 ;
11619 int result;
11620 PyObject * obj0 = 0 ;
11621 char *kwnames[] = {
11622 (char *) "self", NULL
11623 };
11624
11625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11627 if (SWIG_arg_fail(1)) SWIG_fail;
11628 {
11629 PyThreadState* __tstate = wxPyBeginAllowThreads();
11630 result = (int)(arg1)->GetVPosition();
11631
11632 wxPyEndAllowThreads(__tstate);
11633 if (PyErr_Occurred()) SWIG_fail;
11634 }
11635 {
11636 resultobj = SWIG_From_int((int)(result));
11637 }
11638 return resultobj;
11639 fail:
11640 return NULL;
11641 }
11642
11643
11644 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11645 PyObject *resultobj;
11646 wxJoystick *arg1 = (wxJoystick *) 0 ;
11647 int result;
11648 PyObject * obj0 = 0 ;
11649 char *kwnames[] = {
11650 (char *) "self", NULL
11651 };
11652
11653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11655 if (SWIG_arg_fail(1)) SWIG_fail;
11656 {
11657 PyThreadState* __tstate = wxPyBeginAllowThreads();
11658 result = (int)(arg1)->GetMovementThreshold();
11659
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 {
11664 resultobj = SWIG_From_int((int)(result));
11665 }
11666 return resultobj;
11667 fail:
11668 return NULL;
11669 }
11670
11671
11672 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11673 PyObject *resultobj;
11674 wxJoystick *arg1 = (wxJoystick *) 0 ;
11675 int arg2 ;
11676 PyObject * obj0 = 0 ;
11677 PyObject * obj1 = 0 ;
11678 char *kwnames[] = {
11679 (char *) "self",(char *) "threshold", NULL
11680 };
11681
11682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11684 if (SWIG_arg_fail(1)) SWIG_fail;
11685 {
11686 arg2 = (int)(SWIG_As_int(obj1));
11687 if (SWIG_arg_fail(2)) SWIG_fail;
11688 }
11689 {
11690 PyThreadState* __tstate = wxPyBeginAllowThreads();
11691 (arg1)->SetMovementThreshold(arg2);
11692
11693 wxPyEndAllowThreads(__tstate);
11694 if (PyErr_Occurred()) SWIG_fail;
11695 }
11696 Py_INCREF(Py_None); resultobj = Py_None;
11697 return resultobj;
11698 fail:
11699 return NULL;
11700 }
11701
11702
11703 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11704 PyObject *resultobj;
11705 wxJoystick *arg1 = (wxJoystick *) 0 ;
11706 bool result;
11707 PyObject * obj0 = 0 ;
11708 char *kwnames[] = {
11709 (char *) "self", NULL
11710 };
11711
11712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11714 if (SWIG_arg_fail(1)) SWIG_fail;
11715 {
11716 PyThreadState* __tstate = wxPyBeginAllowThreads();
11717 result = (bool)(arg1)->IsOk();
11718
11719 wxPyEndAllowThreads(__tstate);
11720 if (PyErr_Occurred()) SWIG_fail;
11721 }
11722 {
11723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11724 }
11725 return resultobj;
11726 fail:
11727 return NULL;
11728 }
11729
11730
11731 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11732 PyObject *resultobj;
11733 wxJoystick *arg1 = (wxJoystick *) 0 ;
11734 int result;
11735 PyObject * obj0 = 0 ;
11736 char *kwnames[] = {
11737 (char *) "self", NULL
11738 };
11739
11740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11742 if (SWIG_arg_fail(1)) SWIG_fail;
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 result = (int)(arg1)->GetNumberJoysticks();
11746
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 {
11751 resultobj = SWIG_From_int((int)(result));
11752 }
11753 return resultobj;
11754 fail:
11755 return NULL;
11756 }
11757
11758
11759 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11760 PyObject *resultobj;
11761 wxJoystick *arg1 = (wxJoystick *) 0 ;
11762 int result;
11763 PyObject * obj0 = 0 ;
11764 char *kwnames[] = {
11765 (char *) "self", NULL
11766 };
11767
11768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11770 if (SWIG_arg_fail(1)) SWIG_fail;
11771 {
11772 PyThreadState* __tstate = wxPyBeginAllowThreads();
11773 result = (int)(arg1)->GetManufacturerId();
11774
11775 wxPyEndAllowThreads(__tstate);
11776 if (PyErr_Occurred()) SWIG_fail;
11777 }
11778 {
11779 resultobj = SWIG_From_int((int)(result));
11780 }
11781 return resultobj;
11782 fail:
11783 return NULL;
11784 }
11785
11786
11787 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11788 PyObject *resultobj;
11789 wxJoystick *arg1 = (wxJoystick *) 0 ;
11790 int result;
11791 PyObject * obj0 = 0 ;
11792 char *kwnames[] = {
11793 (char *) "self", NULL
11794 };
11795
11796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11798 if (SWIG_arg_fail(1)) SWIG_fail;
11799 {
11800 PyThreadState* __tstate = wxPyBeginAllowThreads();
11801 result = (int)(arg1)->GetProductId();
11802
11803 wxPyEndAllowThreads(__tstate);
11804 if (PyErr_Occurred()) SWIG_fail;
11805 }
11806 {
11807 resultobj = SWIG_From_int((int)(result));
11808 }
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11816 PyObject *resultobj;
11817 wxJoystick *arg1 = (wxJoystick *) 0 ;
11818 wxString result;
11819 PyObject * obj0 = 0 ;
11820 char *kwnames[] = {
11821 (char *) "self", NULL
11822 };
11823
11824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11826 if (SWIG_arg_fail(1)) SWIG_fail;
11827 {
11828 PyThreadState* __tstate = wxPyBeginAllowThreads();
11829 result = (arg1)->GetProductName();
11830
11831 wxPyEndAllowThreads(__tstate);
11832 if (PyErr_Occurred()) SWIG_fail;
11833 }
11834 {
11835 #if wxUSE_UNICODE
11836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11837 #else
11838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11839 #endif
11840 }
11841 return resultobj;
11842 fail:
11843 return NULL;
11844 }
11845
11846
11847 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11848 PyObject *resultobj;
11849 wxJoystick *arg1 = (wxJoystick *) 0 ;
11850 int result;
11851 PyObject * obj0 = 0 ;
11852 char *kwnames[] = {
11853 (char *) "self", NULL
11854 };
11855
11856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11858 if (SWIG_arg_fail(1)) SWIG_fail;
11859 {
11860 PyThreadState* __tstate = wxPyBeginAllowThreads();
11861 result = (int)(arg1)->GetXMin();
11862
11863 wxPyEndAllowThreads(__tstate);
11864 if (PyErr_Occurred()) SWIG_fail;
11865 }
11866 {
11867 resultobj = SWIG_From_int((int)(result));
11868 }
11869 return resultobj;
11870 fail:
11871 return NULL;
11872 }
11873
11874
11875 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11876 PyObject *resultobj;
11877 wxJoystick *arg1 = (wxJoystick *) 0 ;
11878 int result;
11879 PyObject * obj0 = 0 ;
11880 char *kwnames[] = {
11881 (char *) "self", NULL
11882 };
11883
11884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
11889 result = (int)(arg1)->GetYMin();
11890
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 {
11895 resultobj = SWIG_From_int((int)(result));
11896 }
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj;
11905 wxJoystick *arg1 = (wxJoystick *) 0 ;
11906 int result;
11907 PyObject * obj0 = 0 ;
11908 char *kwnames[] = {
11909 (char *) "self", NULL
11910 };
11911
11912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11914 if (SWIG_arg_fail(1)) SWIG_fail;
11915 {
11916 PyThreadState* __tstate = wxPyBeginAllowThreads();
11917 result = (int)(arg1)->GetZMin();
11918
11919 wxPyEndAllowThreads(__tstate);
11920 if (PyErr_Occurred()) SWIG_fail;
11921 }
11922 {
11923 resultobj = SWIG_From_int((int)(result));
11924 }
11925 return resultobj;
11926 fail:
11927 return NULL;
11928 }
11929
11930
11931 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11932 PyObject *resultobj;
11933 wxJoystick *arg1 = (wxJoystick *) 0 ;
11934 int result;
11935 PyObject * obj0 = 0 ;
11936 char *kwnames[] = {
11937 (char *) "self", NULL
11938 };
11939
11940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
11941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11942 if (SWIG_arg_fail(1)) SWIG_fail;
11943 {
11944 PyThreadState* __tstate = wxPyBeginAllowThreads();
11945 result = (int)(arg1)->GetXMax();
11946
11947 wxPyEndAllowThreads(__tstate);
11948 if (PyErr_Occurred()) SWIG_fail;
11949 }
11950 {
11951 resultobj = SWIG_From_int((int)(result));
11952 }
11953 return resultobj;
11954 fail:
11955 return NULL;
11956 }
11957
11958
11959 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11960 PyObject *resultobj;
11961 wxJoystick *arg1 = (wxJoystick *) 0 ;
11962 int result;
11963 PyObject * obj0 = 0 ;
11964 char *kwnames[] = {
11965 (char *) "self", NULL
11966 };
11967
11968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11970 if (SWIG_arg_fail(1)) SWIG_fail;
11971 {
11972 PyThreadState* __tstate = wxPyBeginAllowThreads();
11973 result = (int)(arg1)->GetYMax();
11974
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 {
11979 resultobj = SWIG_From_int((int)(result));
11980 }
11981 return resultobj;
11982 fail:
11983 return NULL;
11984 }
11985
11986
11987 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
11988 PyObject *resultobj;
11989 wxJoystick *arg1 = (wxJoystick *) 0 ;
11990 int result;
11991 PyObject * obj0 = 0 ;
11992 char *kwnames[] = {
11993 (char *) "self", NULL
11994 };
11995
11996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
11997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11998 if (SWIG_arg_fail(1)) SWIG_fail;
11999 {
12000 PyThreadState* __tstate = wxPyBeginAllowThreads();
12001 result = (int)(arg1)->GetZMax();
12002
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 {
12007 resultobj = SWIG_From_int((int)(result));
12008 }
12009 return resultobj;
12010 fail:
12011 return NULL;
12012 }
12013
12014
12015 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12016 PyObject *resultobj;
12017 wxJoystick *arg1 = (wxJoystick *) 0 ;
12018 int result;
12019 PyObject * obj0 = 0 ;
12020 char *kwnames[] = {
12021 (char *) "self", NULL
12022 };
12023
12024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12026 if (SWIG_arg_fail(1)) SWIG_fail;
12027 {
12028 PyThreadState* __tstate = wxPyBeginAllowThreads();
12029 result = (int)(arg1)->GetNumberButtons();
12030
12031 wxPyEndAllowThreads(__tstate);
12032 if (PyErr_Occurred()) SWIG_fail;
12033 }
12034 {
12035 resultobj = SWIG_From_int((int)(result));
12036 }
12037 return resultobj;
12038 fail:
12039 return NULL;
12040 }
12041
12042
12043 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12044 PyObject *resultobj;
12045 wxJoystick *arg1 = (wxJoystick *) 0 ;
12046 int result;
12047 PyObject * obj0 = 0 ;
12048 char *kwnames[] = {
12049 (char *) "self", NULL
12050 };
12051
12052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12054 if (SWIG_arg_fail(1)) SWIG_fail;
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 result = (int)(arg1)->GetNumberAxes();
12058
12059 wxPyEndAllowThreads(__tstate);
12060 if (PyErr_Occurred()) SWIG_fail;
12061 }
12062 {
12063 resultobj = SWIG_From_int((int)(result));
12064 }
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12072 PyObject *resultobj;
12073 wxJoystick *arg1 = (wxJoystick *) 0 ;
12074 int result;
12075 PyObject * obj0 = 0 ;
12076 char *kwnames[] = {
12077 (char *) "self", NULL
12078 };
12079
12080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12082 if (SWIG_arg_fail(1)) SWIG_fail;
12083 {
12084 PyThreadState* __tstate = wxPyBeginAllowThreads();
12085 result = (int)(arg1)->GetMaxButtons();
12086
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 {
12091 resultobj = SWIG_From_int((int)(result));
12092 }
12093 return resultobj;
12094 fail:
12095 return NULL;
12096 }
12097
12098
12099 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12100 PyObject *resultobj;
12101 wxJoystick *arg1 = (wxJoystick *) 0 ;
12102 int result;
12103 PyObject * obj0 = 0 ;
12104 char *kwnames[] = {
12105 (char *) "self", NULL
12106 };
12107
12108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12110 if (SWIG_arg_fail(1)) SWIG_fail;
12111 {
12112 PyThreadState* __tstate = wxPyBeginAllowThreads();
12113 result = (int)(arg1)->GetMaxAxes();
12114
12115 wxPyEndAllowThreads(__tstate);
12116 if (PyErr_Occurred()) SWIG_fail;
12117 }
12118 {
12119 resultobj = SWIG_From_int((int)(result));
12120 }
12121 return resultobj;
12122 fail:
12123 return NULL;
12124 }
12125
12126
12127 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12128 PyObject *resultobj;
12129 wxJoystick *arg1 = (wxJoystick *) 0 ;
12130 int result;
12131 PyObject * obj0 = 0 ;
12132 char *kwnames[] = {
12133 (char *) "self", NULL
12134 };
12135
12136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12138 if (SWIG_arg_fail(1)) SWIG_fail;
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 result = (int)(arg1)->GetPollingMin();
12142
12143 wxPyEndAllowThreads(__tstate);
12144 if (PyErr_Occurred()) SWIG_fail;
12145 }
12146 {
12147 resultobj = SWIG_From_int((int)(result));
12148 }
12149 return resultobj;
12150 fail:
12151 return NULL;
12152 }
12153
12154
12155 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12156 PyObject *resultobj;
12157 wxJoystick *arg1 = (wxJoystick *) 0 ;
12158 int result;
12159 PyObject * obj0 = 0 ;
12160 char *kwnames[] = {
12161 (char *) "self", NULL
12162 };
12163
12164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12166 if (SWIG_arg_fail(1)) SWIG_fail;
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 result = (int)(arg1)->GetPollingMax();
12170
12171 wxPyEndAllowThreads(__tstate);
12172 if (PyErr_Occurred()) SWIG_fail;
12173 }
12174 {
12175 resultobj = SWIG_From_int((int)(result));
12176 }
12177 return resultobj;
12178 fail:
12179 return NULL;
12180 }
12181
12182
12183 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12184 PyObject *resultobj;
12185 wxJoystick *arg1 = (wxJoystick *) 0 ;
12186 int result;
12187 PyObject * obj0 = 0 ;
12188 char *kwnames[] = {
12189 (char *) "self", NULL
12190 };
12191
12192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12194 if (SWIG_arg_fail(1)) SWIG_fail;
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 result = (int)(arg1)->GetRudderMin();
12198
12199 wxPyEndAllowThreads(__tstate);
12200 if (PyErr_Occurred()) SWIG_fail;
12201 }
12202 {
12203 resultobj = SWIG_From_int((int)(result));
12204 }
12205 return resultobj;
12206 fail:
12207 return NULL;
12208 }
12209
12210
12211 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12212 PyObject *resultobj;
12213 wxJoystick *arg1 = (wxJoystick *) 0 ;
12214 int result;
12215 PyObject * obj0 = 0 ;
12216 char *kwnames[] = {
12217 (char *) "self", NULL
12218 };
12219
12220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12222 if (SWIG_arg_fail(1)) SWIG_fail;
12223 {
12224 PyThreadState* __tstate = wxPyBeginAllowThreads();
12225 result = (int)(arg1)->GetRudderMax();
12226
12227 wxPyEndAllowThreads(__tstate);
12228 if (PyErr_Occurred()) SWIG_fail;
12229 }
12230 {
12231 resultobj = SWIG_From_int((int)(result));
12232 }
12233 return resultobj;
12234 fail:
12235 return NULL;
12236 }
12237
12238
12239 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12240 PyObject *resultobj;
12241 wxJoystick *arg1 = (wxJoystick *) 0 ;
12242 int result;
12243 PyObject * obj0 = 0 ;
12244 char *kwnames[] = {
12245 (char *) "self", NULL
12246 };
12247
12248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12250 if (SWIG_arg_fail(1)) SWIG_fail;
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 result = (int)(arg1)->GetUMin();
12254
12255 wxPyEndAllowThreads(__tstate);
12256 if (PyErr_Occurred()) SWIG_fail;
12257 }
12258 {
12259 resultobj = SWIG_From_int((int)(result));
12260 }
12261 return resultobj;
12262 fail:
12263 return NULL;
12264 }
12265
12266
12267 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12268 PyObject *resultobj;
12269 wxJoystick *arg1 = (wxJoystick *) 0 ;
12270 int result;
12271 PyObject * obj0 = 0 ;
12272 char *kwnames[] = {
12273 (char *) "self", NULL
12274 };
12275
12276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12278 if (SWIG_arg_fail(1)) SWIG_fail;
12279 {
12280 PyThreadState* __tstate = wxPyBeginAllowThreads();
12281 result = (int)(arg1)->GetUMax();
12282
12283 wxPyEndAllowThreads(__tstate);
12284 if (PyErr_Occurred()) SWIG_fail;
12285 }
12286 {
12287 resultobj = SWIG_From_int((int)(result));
12288 }
12289 return resultobj;
12290 fail:
12291 return NULL;
12292 }
12293
12294
12295 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12296 PyObject *resultobj;
12297 wxJoystick *arg1 = (wxJoystick *) 0 ;
12298 int result;
12299 PyObject * obj0 = 0 ;
12300 char *kwnames[] = {
12301 (char *) "self", NULL
12302 };
12303
12304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12306 if (SWIG_arg_fail(1)) SWIG_fail;
12307 {
12308 PyThreadState* __tstate = wxPyBeginAllowThreads();
12309 result = (int)(arg1)->GetVMin();
12310
12311 wxPyEndAllowThreads(__tstate);
12312 if (PyErr_Occurred()) SWIG_fail;
12313 }
12314 {
12315 resultobj = SWIG_From_int((int)(result));
12316 }
12317 return resultobj;
12318 fail:
12319 return NULL;
12320 }
12321
12322
12323 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12324 PyObject *resultobj;
12325 wxJoystick *arg1 = (wxJoystick *) 0 ;
12326 int result;
12327 PyObject * obj0 = 0 ;
12328 char *kwnames[] = {
12329 (char *) "self", NULL
12330 };
12331
12332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12334 if (SWIG_arg_fail(1)) SWIG_fail;
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 result = (int)(arg1)->GetVMax();
12338
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 {
12343 resultobj = SWIG_From_int((int)(result));
12344 }
12345 return resultobj;
12346 fail:
12347 return NULL;
12348 }
12349
12350
12351 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12352 PyObject *resultobj;
12353 wxJoystick *arg1 = (wxJoystick *) 0 ;
12354 bool result;
12355 PyObject * obj0 = 0 ;
12356 char *kwnames[] = {
12357 (char *) "self", NULL
12358 };
12359
12360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12362 if (SWIG_arg_fail(1)) SWIG_fail;
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 result = (bool)(arg1)->HasRudder();
12366
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 {
12371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12372 }
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxJoystick *arg1 = (wxJoystick *) 0 ;
12382 bool result;
12383 PyObject * obj0 = 0 ;
12384 char *kwnames[] = {
12385 (char *) "self", NULL
12386 };
12387
12388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12390 if (SWIG_arg_fail(1)) SWIG_fail;
12391 {
12392 PyThreadState* __tstate = wxPyBeginAllowThreads();
12393 result = (bool)(arg1)->HasZ();
12394
12395 wxPyEndAllowThreads(__tstate);
12396 if (PyErr_Occurred()) SWIG_fail;
12397 }
12398 {
12399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12400 }
12401 return resultobj;
12402 fail:
12403 return NULL;
12404 }
12405
12406
12407 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12408 PyObject *resultobj;
12409 wxJoystick *arg1 = (wxJoystick *) 0 ;
12410 bool result;
12411 PyObject * obj0 = 0 ;
12412 char *kwnames[] = {
12413 (char *) "self", NULL
12414 };
12415
12416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12418 if (SWIG_arg_fail(1)) SWIG_fail;
12419 {
12420 PyThreadState* __tstate = wxPyBeginAllowThreads();
12421 result = (bool)(arg1)->HasU();
12422
12423 wxPyEndAllowThreads(__tstate);
12424 if (PyErr_Occurred()) SWIG_fail;
12425 }
12426 {
12427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12428 }
12429 return resultobj;
12430 fail:
12431 return NULL;
12432 }
12433
12434
12435 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12436 PyObject *resultobj;
12437 wxJoystick *arg1 = (wxJoystick *) 0 ;
12438 bool result;
12439 PyObject * obj0 = 0 ;
12440 char *kwnames[] = {
12441 (char *) "self", NULL
12442 };
12443
12444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12446 if (SWIG_arg_fail(1)) SWIG_fail;
12447 {
12448 PyThreadState* __tstate = wxPyBeginAllowThreads();
12449 result = (bool)(arg1)->HasV();
12450
12451 wxPyEndAllowThreads(__tstate);
12452 if (PyErr_Occurred()) SWIG_fail;
12453 }
12454 {
12455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12456 }
12457 return resultobj;
12458 fail:
12459 return NULL;
12460 }
12461
12462
12463 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12464 PyObject *resultobj;
12465 wxJoystick *arg1 = (wxJoystick *) 0 ;
12466 bool result;
12467 PyObject * obj0 = 0 ;
12468 char *kwnames[] = {
12469 (char *) "self", NULL
12470 };
12471
12472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12474 if (SWIG_arg_fail(1)) SWIG_fail;
12475 {
12476 PyThreadState* __tstate = wxPyBeginAllowThreads();
12477 result = (bool)(arg1)->HasPOV();
12478
12479 wxPyEndAllowThreads(__tstate);
12480 if (PyErr_Occurred()) SWIG_fail;
12481 }
12482 {
12483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12484 }
12485 return resultobj;
12486 fail:
12487 return NULL;
12488 }
12489
12490
12491 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12492 PyObject *resultobj;
12493 wxJoystick *arg1 = (wxJoystick *) 0 ;
12494 bool result;
12495 PyObject * obj0 = 0 ;
12496 char *kwnames[] = {
12497 (char *) "self", NULL
12498 };
12499
12500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12502 if (SWIG_arg_fail(1)) SWIG_fail;
12503 {
12504 PyThreadState* __tstate = wxPyBeginAllowThreads();
12505 result = (bool)(arg1)->HasPOV4Dir();
12506
12507 wxPyEndAllowThreads(__tstate);
12508 if (PyErr_Occurred()) SWIG_fail;
12509 }
12510 {
12511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12512 }
12513 return resultobj;
12514 fail:
12515 return NULL;
12516 }
12517
12518
12519 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12520 PyObject *resultobj;
12521 wxJoystick *arg1 = (wxJoystick *) 0 ;
12522 bool result;
12523 PyObject * obj0 = 0 ;
12524 char *kwnames[] = {
12525 (char *) "self", NULL
12526 };
12527
12528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12530 if (SWIG_arg_fail(1)) SWIG_fail;
12531 {
12532 PyThreadState* __tstate = wxPyBeginAllowThreads();
12533 result = (bool)(arg1)->HasPOVCTS();
12534
12535 wxPyEndAllowThreads(__tstate);
12536 if (PyErr_Occurred()) SWIG_fail;
12537 }
12538 {
12539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12540 }
12541 return resultobj;
12542 fail:
12543 return NULL;
12544 }
12545
12546
12547 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12548 PyObject *resultobj;
12549 wxJoystick *arg1 = (wxJoystick *) 0 ;
12550 wxWindow *arg2 = (wxWindow *) 0 ;
12551 int arg3 = (int) 0 ;
12552 bool result;
12553 PyObject * obj0 = 0 ;
12554 PyObject * obj1 = 0 ;
12555 PyObject * obj2 = 0 ;
12556 char *kwnames[] = {
12557 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12558 };
12559
12560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12562 if (SWIG_arg_fail(1)) SWIG_fail;
12563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12564 if (SWIG_arg_fail(2)) SWIG_fail;
12565 if (obj2) {
12566 {
12567 arg3 = (int)(SWIG_As_int(obj2));
12568 if (SWIG_arg_fail(3)) SWIG_fail;
12569 }
12570 }
12571 {
12572 PyThreadState* __tstate = wxPyBeginAllowThreads();
12573 result = (bool)(arg1)->SetCapture(arg2,arg3);
12574
12575 wxPyEndAllowThreads(__tstate);
12576 if (PyErr_Occurred()) SWIG_fail;
12577 }
12578 {
12579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12580 }
12581 return resultobj;
12582 fail:
12583 return NULL;
12584 }
12585
12586
12587 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12588 PyObject *resultobj;
12589 wxJoystick *arg1 = (wxJoystick *) 0 ;
12590 bool result;
12591 PyObject * obj0 = 0 ;
12592 char *kwnames[] = {
12593 (char *) "self", NULL
12594 };
12595
12596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12598 if (SWIG_arg_fail(1)) SWIG_fail;
12599 {
12600 PyThreadState* __tstate = wxPyBeginAllowThreads();
12601 result = (bool)(arg1)->ReleaseCapture();
12602
12603 wxPyEndAllowThreads(__tstate);
12604 if (PyErr_Occurred()) SWIG_fail;
12605 }
12606 {
12607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12608 }
12609 return resultobj;
12610 fail:
12611 return NULL;
12612 }
12613
12614
12615 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12616 PyObject *obj;
12617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12618 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12619 Py_INCREF(obj);
12620 return Py_BuildValue((char *)"");
12621 }
12622 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12623 PyObject *resultobj;
12624 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12625 int arg2 = (int) 0 ;
12626 int arg3 = (int) wxJOYSTICK1 ;
12627 int arg4 = (int) 0 ;
12628 wxJoystickEvent *result;
12629 PyObject * obj0 = 0 ;
12630 PyObject * obj1 = 0 ;
12631 PyObject * obj2 = 0 ;
12632 PyObject * obj3 = 0 ;
12633 char *kwnames[] = {
12634 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12635 };
12636
12637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12638 if (obj0) {
12639 {
12640 arg1 = (wxEventType)(SWIG_As_int(obj0));
12641 if (SWIG_arg_fail(1)) SWIG_fail;
12642 }
12643 }
12644 if (obj1) {
12645 {
12646 arg2 = (int)(SWIG_As_int(obj1));
12647 if (SWIG_arg_fail(2)) SWIG_fail;
12648 }
12649 }
12650 if (obj2) {
12651 {
12652 arg3 = (int)(SWIG_As_int(obj2));
12653 if (SWIG_arg_fail(3)) SWIG_fail;
12654 }
12655 }
12656 if (obj3) {
12657 {
12658 arg4 = (int)(SWIG_As_int(obj3));
12659 if (SWIG_arg_fail(4)) SWIG_fail;
12660 }
12661 }
12662 {
12663 PyThreadState* __tstate = wxPyBeginAllowThreads();
12664 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12665
12666 wxPyEndAllowThreads(__tstate);
12667 if (PyErr_Occurred()) SWIG_fail;
12668 }
12669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12670 return resultobj;
12671 fail:
12672 return NULL;
12673 }
12674
12675
12676 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12677 PyObject *resultobj;
12678 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12679 wxPoint result;
12680 PyObject * obj0 = 0 ;
12681 char *kwnames[] = {
12682 (char *) "self", NULL
12683 };
12684
12685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12687 if (SWIG_arg_fail(1)) SWIG_fail;
12688 {
12689 PyThreadState* __tstate = wxPyBeginAllowThreads();
12690 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12691
12692 wxPyEndAllowThreads(__tstate);
12693 if (PyErr_Occurred()) SWIG_fail;
12694 }
12695 {
12696 wxPoint * resultptr;
12697 resultptr = new wxPoint((wxPoint &)(result));
12698 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12699 }
12700 return resultobj;
12701 fail:
12702 return NULL;
12703 }
12704
12705
12706 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12707 PyObject *resultobj;
12708 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12709 int result;
12710 PyObject * obj0 = 0 ;
12711 char *kwnames[] = {
12712 (char *) "self", NULL
12713 };
12714
12715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12717 if (SWIG_arg_fail(1)) SWIG_fail;
12718 {
12719 PyThreadState* __tstate = wxPyBeginAllowThreads();
12720 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12721
12722 wxPyEndAllowThreads(__tstate);
12723 if (PyErr_Occurred()) SWIG_fail;
12724 }
12725 {
12726 resultobj = SWIG_From_int((int)(result));
12727 }
12728 return resultobj;
12729 fail:
12730 return NULL;
12731 }
12732
12733
12734 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12735 PyObject *resultobj;
12736 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12737 int result;
12738 PyObject * obj0 = 0 ;
12739 char *kwnames[] = {
12740 (char *) "self", NULL
12741 };
12742
12743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12745 if (SWIG_arg_fail(1)) SWIG_fail;
12746 {
12747 PyThreadState* __tstate = wxPyBeginAllowThreads();
12748 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12749
12750 wxPyEndAllowThreads(__tstate);
12751 if (PyErr_Occurred()) SWIG_fail;
12752 }
12753 {
12754 resultobj = SWIG_From_int((int)(result));
12755 }
12756 return resultobj;
12757 fail:
12758 return NULL;
12759 }
12760
12761
12762 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12763 PyObject *resultobj;
12764 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12765 int result;
12766 PyObject * obj0 = 0 ;
12767 char *kwnames[] = {
12768 (char *) "self", NULL
12769 };
12770
12771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12773 if (SWIG_arg_fail(1)) SWIG_fail;
12774 {
12775 PyThreadState* __tstate = wxPyBeginAllowThreads();
12776 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12777
12778 wxPyEndAllowThreads(__tstate);
12779 if (PyErr_Occurred()) SWIG_fail;
12780 }
12781 {
12782 resultobj = SWIG_From_int((int)(result));
12783 }
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12791 PyObject *resultobj;
12792 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12793 int result;
12794 PyObject * obj0 = 0 ;
12795 char *kwnames[] = {
12796 (char *) "self", NULL
12797 };
12798
12799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12801 if (SWIG_arg_fail(1)) SWIG_fail;
12802 {
12803 PyThreadState* __tstate = wxPyBeginAllowThreads();
12804 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12805
12806 wxPyEndAllowThreads(__tstate);
12807 if (PyErr_Occurred()) SWIG_fail;
12808 }
12809 {
12810 resultobj = SWIG_From_int((int)(result));
12811 }
12812 return resultobj;
12813 fail:
12814 return NULL;
12815 }
12816
12817
12818 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12819 PyObject *resultobj;
12820 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12821 int arg2 ;
12822 PyObject * obj0 = 0 ;
12823 PyObject * obj1 = 0 ;
12824 char *kwnames[] = {
12825 (char *) "self",(char *) "stick", NULL
12826 };
12827
12828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12830 if (SWIG_arg_fail(1)) SWIG_fail;
12831 {
12832 arg2 = (int)(SWIG_As_int(obj1));
12833 if (SWIG_arg_fail(2)) SWIG_fail;
12834 }
12835 {
12836 PyThreadState* __tstate = wxPyBeginAllowThreads();
12837 (arg1)->SetJoystick(arg2);
12838
12839 wxPyEndAllowThreads(__tstate);
12840 if (PyErr_Occurred()) SWIG_fail;
12841 }
12842 Py_INCREF(Py_None); resultobj = Py_None;
12843 return resultobj;
12844 fail:
12845 return NULL;
12846 }
12847
12848
12849 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12850 PyObject *resultobj;
12851 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12852 int arg2 ;
12853 PyObject * obj0 = 0 ;
12854 PyObject * obj1 = 0 ;
12855 char *kwnames[] = {
12856 (char *) "self",(char *) "state", NULL
12857 };
12858
12859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
12860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12861 if (SWIG_arg_fail(1)) SWIG_fail;
12862 {
12863 arg2 = (int)(SWIG_As_int(obj1));
12864 if (SWIG_arg_fail(2)) SWIG_fail;
12865 }
12866 {
12867 PyThreadState* __tstate = wxPyBeginAllowThreads();
12868 (arg1)->SetButtonState(arg2);
12869
12870 wxPyEndAllowThreads(__tstate);
12871 if (PyErr_Occurred()) SWIG_fail;
12872 }
12873 Py_INCREF(Py_None); resultobj = Py_None;
12874 return resultobj;
12875 fail:
12876 return NULL;
12877 }
12878
12879
12880 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12881 PyObject *resultobj;
12882 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12883 int arg2 ;
12884 PyObject * obj0 = 0 ;
12885 PyObject * obj1 = 0 ;
12886 char *kwnames[] = {
12887 (char *) "self",(char *) "change", NULL
12888 };
12889
12890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
12891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12892 if (SWIG_arg_fail(1)) SWIG_fail;
12893 {
12894 arg2 = (int)(SWIG_As_int(obj1));
12895 if (SWIG_arg_fail(2)) SWIG_fail;
12896 }
12897 {
12898 PyThreadState* __tstate = wxPyBeginAllowThreads();
12899 (arg1)->SetButtonChange(arg2);
12900
12901 wxPyEndAllowThreads(__tstate);
12902 if (PyErr_Occurred()) SWIG_fail;
12903 }
12904 Py_INCREF(Py_None); resultobj = Py_None;
12905 return resultobj;
12906 fail:
12907 return NULL;
12908 }
12909
12910
12911 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12912 PyObject *resultobj;
12913 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12914 wxPoint *arg2 = 0 ;
12915 wxPoint temp2 ;
12916 PyObject * obj0 = 0 ;
12917 PyObject * obj1 = 0 ;
12918 char *kwnames[] = {
12919 (char *) "self",(char *) "pos", NULL
12920 };
12921
12922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
12923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12924 if (SWIG_arg_fail(1)) SWIG_fail;
12925 {
12926 arg2 = &temp2;
12927 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12928 }
12929 {
12930 PyThreadState* __tstate = wxPyBeginAllowThreads();
12931 (arg1)->SetPosition((wxPoint const &)*arg2);
12932
12933 wxPyEndAllowThreads(__tstate);
12934 if (PyErr_Occurred()) SWIG_fail;
12935 }
12936 Py_INCREF(Py_None); resultobj = Py_None;
12937 return resultobj;
12938 fail:
12939 return NULL;
12940 }
12941
12942
12943 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12944 PyObject *resultobj;
12945 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12946 int arg2 ;
12947 PyObject * obj0 = 0 ;
12948 PyObject * obj1 = 0 ;
12949 char *kwnames[] = {
12950 (char *) "self",(char *) "zPos", NULL
12951 };
12952
12953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
12954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12955 if (SWIG_arg_fail(1)) SWIG_fail;
12956 {
12957 arg2 = (int)(SWIG_As_int(obj1));
12958 if (SWIG_arg_fail(2)) SWIG_fail;
12959 }
12960 {
12961 PyThreadState* __tstate = wxPyBeginAllowThreads();
12962 (arg1)->SetZPosition(arg2);
12963
12964 wxPyEndAllowThreads(__tstate);
12965 if (PyErr_Occurred()) SWIG_fail;
12966 }
12967 Py_INCREF(Py_None); resultobj = Py_None;
12968 return resultobj;
12969 fail:
12970 return NULL;
12971 }
12972
12973
12974 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
12975 PyObject *resultobj;
12976 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12977 bool result;
12978 PyObject * obj0 = 0 ;
12979 char *kwnames[] = {
12980 (char *) "self", NULL
12981 };
12982
12983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
12984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12985 if (SWIG_arg_fail(1)) SWIG_fail;
12986 {
12987 PyThreadState* __tstate = wxPyBeginAllowThreads();
12988 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
12989
12990 wxPyEndAllowThreads(__tstate);
12991 if (PyErr_Occurred()) SWIG_fail;
12992 }
12993 {
12994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12995 }
12996 return resultobj;
12997 fail:
12998 return NULL;
12999 }
13000
13001
13002 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13003 PyObject *resultobj;
13004 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13005 bool result;
13006 PyObject * obj0 = 0 ;
13007 char *kwnames[] = {
13008 (char *) "self", NULL
13009 };
13010
13011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13013 if (SWIG_arg_fail(1)) SWIG_fail;
13014 {
13015 PyThreadState* __tstate = wxPyBeginAllowThreads();
13016 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13017
13018 wxPyEndAllowThreads(__tstate);
13019 if (PyErr_Occurred()) SWIG_fail;
13020 }
13021 {
13022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13023 }
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13031 PyObject *resultobj;
13032 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13033 bool result;
13034 PyObject * obj0 = 0 ;
13035 char *kwnames[] = {
13036 (char *) "self", NULL
13037 };
13038
13039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13041 if (SWIG_arg_fail(1)) SWIG_fail;
13042 {
13043 PyThreadState* __tstate = wxPyBeginAllowThreads();
13044 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13045
13046 wxPyEndAllowThreads(__tstate);
13047 if (PyErr_Occurred()) SWIG_fail;
13048 }
13049 {
13050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13051 }
13052 return resultobj;
13053 fail:
13054 return NULL;
13055 }
13056
13057
13058 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13059 PyObject *resultobj;
13060 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13061 int arg2 = (int) wxJOY_BUTTON_ANY ;
13062 bool result;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 char *kwnames[] = {
13066 (char *) "self",(char *) "but", NULL
13067 };
13068
13069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13071 if (SWIG_arg_fail(1)) SWIG_fail;
13072 if (obj1) {
13073 {
13074 arg2 = (int)(SWIG_As_int(obj1));
13075 if (SWIG_arg_fail(2)) SWIG_fail;
13076 }
13077 }
13078 {
13079 PyThreadState* __tstate = wxPyBeginAllowThreads();
13080 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13081
13082 wxPyEndAllowThreads(__tstate);
13083 if (PyErr_Occurred()) SWIG_fail;
13084 }
13085 {
13086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13087 }
13088 return resultobj;
13089 fail:
13090 return NULL;
13091 }
13092
13093
13094 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13095 PyObject *resultobj;
13096 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13097 int arg2 = (int) wxJOY_BUTTON_ANY ;
13098 bool result;
13099 PyObject * obj0 = 0 ;
13100 PyObject * obj1 = 0 ;
13101 char *kwnames[] = {
13102 (char *) "self",(char *) "but", NULL
13103 };
13104
13105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13107 if (SWIG_arg_fail(1)) SWIG_fail;
13108 if (obj1) {
13109 {
13110 arg2 = (int)(SWIG_As_int(obj1));
13111 if (SWIG_arg_fail(2)) SWIG_fail;
13112 }
13113 }
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13117
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 {
13122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13123 }
13124 return resultobj;
13125 fail:
13126 return NULL;
13127 }
13128
13129
13130 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13131 PyObject *resultobj;
13132 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13133 int arg2 = (int) wxJOY_BUTTON_ANY ;
13134 bool result;
13135 PyObject * obj0 = 0 ;
13136 PyObject * obj1 = 0 ;
13137 char *kwnames[] = {
13138 (char *) "self",(char *) "but", NULL
13139 };
13140
13141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13143 if (SWIG_arg_fail(1)) SWIG_fail;
13144 if (obj1) {
13145 {
13146 arg2 = (int)(SWIG_As_int(obj1));
13147 if (SWIG_arg_fail(2)) SWIG_fail;
13148 }
13149 }
13150 {
13151 PyThreadState* __tstate = wxPyBeginAllowThreads();
13152 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13153
13154 wxPyEndAllowThreads(__tstate);
13155 if (PyErr_Occurred()) SWIG_fail;
13156 }
13157 {
13158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13159 }
13160 return resultobj;
13161 fail:
13162 return NULL;
13163 }
13164
13165
13166 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13167 PyObject *obj;
13168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13169 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13170 Py_INCREF(obj);
13171 return Py_BuildValue((char *)"");
13172 }
13173 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13174 PyObject *resultobj;
13175 wxString const &arg1_defvalue = wxPyEmptyString ;
13176 wxString *arg1 = (wxString *) &arg1_defvalue ;
13177 wxSound *result;
13178 bool temp1 = false ;
13179 PyObject * obj0 = 0 ;
13180 char *kwnames[] = {
13181 (char *) "fileName", NULL
13182 };
13183
13184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13185 if (obj0) {
13186 {
13187 arg1 = wxString_in_helper(obj0);
13188 if (arg1 == NULL) SWIG_fail;
13189 temp1 = true;
13190 }
13191 }
13192 {
13193 if (!wxPyCheckForApp()) SWIG_fail;
13194 PyThreadState* __tstate = wxPyBeginAllowThreads();
13195 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13196
13197 wxPyEndAllowThreads(__tstate);
13198 if (PyErr_Occurred()) SWIG_fail;
13199 }
13200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13201 {
13202 if (temp1)
13203 delete arg1;
13204 }
13205 return resultobj;
13206 fail:
13207 {
13208 if (temp1)
13209 delete arg1;
13210 }
13211 return NULL;
13212 }
13213
13214
13215 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13216 PyObject *resultobj;
13217 PyObject *arg1 = (PyObject *) 0 ;
13218 wxSound *result;
13219 PyObject * obj0 = 0 ;
13220 char *kwnames[] = {
13221 (char *) "data", NULL
13222 };
13223
13224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13225 arg1 = obj0;
13226 {
13227 if (!wxPyCheckForApp()) SWIG_fail;
13228 PyThreadState* __tstate = wxPyBeginAllowThreads();
13229 result = (wxSound *)new_wxSound(arg1);
13230
13231 wxPyEndAllowThreads(__tstate);
13232 if (PyErr_Occurred()) SWIG_fail;
13233 }
13234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13235 return resultobj;
13236 fail:
13237 return NULL;
13238 }
13239
13240
13241 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13242 PyObject *resultobj;
13243 wxSound *arg1 = (wxSound *) 0 ;
13244 PyObject * obj0 = 0 ;
13245 char *kwnames[] = {
13246 (char *) "self", NULL
13247 };
13248
13249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13251 if (SWIG_arg_fail(1)) SWIG_fail;
13252 {
13253 PyThreadState* __tstate = wxPyBeginAllowThreads();
13254 delete arg1;
13255
13256 wxPyEndAllowThreads(__tstate);
13257 if (PyErr_Occurred()) SWIG_fail;
13258 }
13259 Py_INCREF(Py_None); resultobj = Py_None;
13260 return resultobj;
13261 fail:
13262 return NULL;
13263 }
13264
13265
13266 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj;
13268 wxSound *arg1 = (wxSound *) 0 ;
13269 wxString *arg2 = 0 ;
13270 bool result;
13271 bool temp2 = false ;
13272 PyObject * obj0 = 0 ;
13273 PyObject * obj1 = 0 ;
13274 char *kwnames[] = {
13275 (char *) "self",(char *) "fileName", NULL
13276 };
13277
13278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13280 if (SWIG_arg_fail(1)) SWIG_fail;
13281 {
13282 arg2 = wxString_in_helper(obj1);
13283 if (arg2 == NULL) SWIG_fail;
13284 temp2 = true;
13285 }
13286 {
13287 PyThreadState* __tstate = wxPyBeginAllowThreads();
13288 result = (bool)(arg1)->Create((wxString const &)*arg2);
13289
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 {
13294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13295 }
13296 {
13297 if (temp2)
13298 delete arg2;
13299 }
13300 return resultobj;
13301 fail:
13302 {
13303 if (temp2)
13304 delete arg2;
13305 }
13306 return NULL;
13307 }
13308
13309
13310 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13311 PyObject *resultobj;
13312 wxSound *arg1 = (wxSound *) 0 ;
13313 PyObject *arg2 = (PyObject *) 0 ;
13314 bool result;
13315 PyObject * obj0 = 0 ;
13316 PyObject * obj1 = 0 ;
13317 char *kwnames[] = {
13318 (char *) "self",(char *) "data", NULL
13319 };
13320
13321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13323 if (SWIG_arg_fail(1)) SWIG_fail;
13324 arg2 = obj1;
13325 {
13326 PyThreadState* __tstate = wxPyBeginAllowThreads();
13327 result = (bool)wxSound_CreateFromData(arg1,arg2);
13328
13329 wxPyEndAllowThreads(__tstate);
13330 if (PyErr_Occurred()) SWIG_fail;
13331 }
13332 {
13333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13334 }
13335 return resultobj;
13336 fail:
13337 return NULL;
13338 }
13339
13340
13341 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13342 PyObject *resultobj;
13343 wxSound *arg1 = (wxSound *) 0 ;
13344 bool result;
13345 PyObject * obj0 = 0 ;
13346 char *kwnames[] = {
13347 (char *) "self", NULL
13348 };
13349
13350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13352 if (SWIG_arg_fail(1)) SWIG_fail;
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 result = (bool)(arg1)->IsOk();
13356
13357 wxPyEndAllowThreads(__tstate);
13358 if (PyErr_Occurred()) SWIG_fail;
13359 }
13360 {
13361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13362 }
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj;
13371 wxSound *arg1 = (wxSound *) 0 ;
13372 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13373 bool result;
13374 PyObject * obj0 = 0 ;
13375 PyObject * obj1 = 0 ;
13376 char *kwnames[] = {
13377 (char *) "self",(char *) "flags", NULL
13378 };
13379
13380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13382 if (SWIG_arg_fail(1)) SWIG_fail;
13383 if (obj1) {
13384 {
13385 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13386 if (SWIG_arg_fail(2)) SWIG_fail;
13387 }
13388 }
13389 {
13390 if (!wxPyCheckForApp()) SWIG_fail;
13391 PyThreadState* __tstate = wxPyBeginAllowThreads();
13392 result = (bool)((wxSound const *)arg1)->Play(arg2);
13393
13394 wxPyEndAllowThreads(__tstate);
13395 if (PyErr_Occurred()) SWIG_fail;
13396 }
13397 {
13398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13399 }
13400 return resultobj;
13401 fail:
13402 return NULL;
13403 }
13404
13405
13406 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13407 PyObject *resultobj;
13408 wxString *arg1 = 0 ;
13409 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13410 bool result;
13411 bool temp1 = false ;
13412 PyObject * obj0 = 0 ;
13413 PyObject * obj1 = 0 ;
13414 char *kwnames[] = {
13415 (char *) "filename",(char *) "flags", NULL
13416 };
13417
13418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13419 {
13420 arg1 = wxString_in_helper(obj0);
13421 if (arg1 == NULL) SWIG_fail;
13422 temp1 = true;
13423 }
13424 if (obj1) {
13425 {
13426 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13427 if (SWIG_arg_fail(2)) SWIG_fail;
13428 }
13429 }
13430 {
13431 if (!wxPyCheckForApp()) SWIG_fail;
13432 PyThreadState* __tstate = wxPyBeginAllowThreads();
13433 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13434
13435 wxPyEndAllowThreads(__tstate);
13436 if (PyErr_Occurred()) SWIG_fail;
13437 }
13438 {
13439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13440 }
13441 {
13442 if (temp1)
13443 delete arg1;
13444 }
13445 return resultobj;
13446 fail:
13447 {
13448 if (temp1)
13449 delete arg1;
13450 }
13451 return NULL;
13452 }
13453
13454
13455 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13456 PyObject *resultobj;
13457 char *kwnames[] = {
13458 NULL
13459 };
13460
13461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13462 {
13463 if (!wxPyCheckForApp()) SWIG_fail;
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 wxSound::Stop();
13466
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 Py_INCREF(Py_None); resultobj = Py_None;
13471 return resultobj;
13472 fail:
13473 return NULL;
13474 }
13475
13476
13477 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13478 PyObject *obj;
13479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13480 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13481 Py_INCREF(obj);
13482 return Py_BuildValue((char *)"");
13483 }
13484 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13485 PyObject *resultobj;
13486 wxString *arg1 = 0 ;
13487 wxString *arg2 = 0 ;
13488 wxString *arg3 = 0 ;
13489 wxString *arg4 = 0 ;
13490 wxFileTypeInfo *result;
13491 bool temp1 = false ;
13492 bool temp2 = false ;
13493 bool temp3 = false ;
13494 bool temp4 = false ;
13495 PyObject * obj0 = 0 ;
13496 PyObject * obj1 = 0 ;
13497 PyObject * obj2 = 0 ;
13498 PyObject * obj3 = 0 ;
13499 char *kwnames[] = {
13500 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13501 };
13502
13503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13504 {
13505 arg1 = wxString_in_helper(obj0);
13506 if (arg1 == NULL) SWIG_fail;
13507 temp1 = true;
13508 }
13509 {
13510 arg2 = wxString_in_helper(obj1);
13511 if (arg2 == NULL) SWIG_fail;
13512 temp2 = true;
13513 }
13514 {
13515 arg3 = wxString_in_helper(obj2);
13516 if (arg3 == NULL) SWIG_fail;
13517 temp3 = true;
13518 }
13519 {
13520 arg4 = wxString_in_helper(obj3);
13521 if (arg4 == NULL) SWIG_fail;
13522 temp4 = true;
13523 }
13524 {
13525 PyThreadState* __tstate = wxPyBeginAllowThreads();
13526 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13527
13528 wxPyEndAllowThreads(__tstate);
13529 if (PyErr_Occurred()) SWIG_fail;
13530 }
13531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13532 {
13533 if (temp1)
13534 delete arg1;
13535 }
13536 {
13537 if (temp2)
13538 delete arg2;
13539 }
13540 {
13541 if (temp3)
13542 delete arg3;
13543 }
13544 {
13545 if (temp4)
13546 delete arg4;
13547 }
13548 return resultobj;
13549 fail:
13550 {
13551 if (temp1)
13552 delete arg1;
13553 }
13554 {
13555 if (temp2)
13556 delete arg2;
13557 }
13558 {
13559 if (temp3)
13560 delete arg3;
13561 }
13562 {
13563 if (temp4)
13564 delete arg4;
13565 }
13566 return NULL;
13567 }
13568
13569
13570 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj;
13572 wxArrayString *arg1 = 0 ;
13573 wxFileTypeInfo *result;
13574 bool temp1 = false ;
13575 PyObject * obj0 = 0 ;
13576 char *kwnames[] = {
13577 (char *) "sArray", NULL
13578 };
13579
13580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13581 {
13582 if (! PySequence_Check(obj0)) {
13583 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13584 SWIG_fail;
13585 }
13586 arg1 = new wxArrayString;
13587 temp1 = true;
13588 int i, len=PySequence_Length(obj0);
13589 for (i=0; i<len; i++) {
13590 PyObject* item = PySequence_GetItem(obj0, i);
13591 #if wxUSE_UNICODE
13592 PyObject* str = PyObject_Unicode(item);
13593 #else
13594 PyObject* str = PyObject_Str(item);
13595 #endif
13596 if (PyErr_Occurred()) SWIG_fail;
13597 arg1->Add(Py2wxString(str));
13598 Py_DECREF(item);
13599 Py_DECREF(str);
13600 }
13601 }
13602 {
13603 PyThreadState* __tstate = wxPyBeginAllowThreads();
13604 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13605
13606 wxPyEndAllowThreads(__tstate);
13607 if (PyErr_Occurred()) SWIG_fail;
13608 }
13609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13610 {
13611 if (temp1) delete arg1;
13612 }
13613 return resultobj;
13614 fail:
13615 {
13616 if (temp1) delete arg1;
13617 }
13618 return NULL;
13619 }
13620
13621
13622 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13623 PyObject *resultobj;
13624 wxFileTypeInfo *result;
13625 char *kwnames[] = {
13626 NULL
13627 };
13628
13629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13630 {
13631 PyThreadState* __tstate = wxPyBeginAllowThreads();
13632 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13633
13634 wxPyEndAllowThreads(__tstate);
13635 if (PyErr_Occurred()) SWIG_fail;
13636 }
13637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13638 return resultobj;
13639 fail:
13640 return NULL;
13641 }
13642
13643
13644 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13645 PyObject *resultobj;
13646 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13647 bool result;
13648 PyObject * obj0 = 0 ;
13649 char *kwnames[] = {
13650 (char *) "self", NULL
13651 };
13652
13653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13655 if (SWIG_arg_fail(1)) SWIG_fail;
13656 {
13657 PyThreadState* __tstate = wxPyBeginAllowThreads();
13658 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13659
13660 wxPyEndAllowThreads(__tstate);
13661 if (PyErr_Occurred()) SWIG_fail;
13662 }
13663 {
13664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13665 }
13666 return resultobj;
13667 fail:
13668 return NULL;
13669 }
13670
13671
13672 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13673 PyObject *resultobj;
13674 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13675 wxString *arg2 = 0 ;
13676 int arg3 = (int) 0 ;
13677 bool temp2 = false ;
13678 PyObject * obj0 = 0 ;
13679 PyObject * obj1 = 0 ;
13680 PyObject * obj2 = 0 ;
13681 char *kwnames[] = {
13682 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13683 };
13684
13685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13687 if (SWIG_arg_fail(1)) SWIG_fail;
13688 {
13689 arg2 = wxString_in_helper(obj1);
13690 if (arg2 == NULL) SWIG_fail;
13691 temp2 = true;
13692 }
13693 if (obj2) {
13694 {
13695 arg3 = (int)(SWIG_As_int(obj2));
13696 if (SWIG_arg_fail(3)) SWIG_fail;
13697 }
13698 }
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13702
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 Py_INCREF(Py_None); resultobj = Py_None;
13707 {
13708 if (temp2)
13709 delete arg2;
13710 }
13711 return resultobj;
13712 fail:
13713 {
13714 if (temp2)
13715 delete arg2;
13716 }
13717 return NULL;
13718 }
13719
13720
13721 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13722 PyObject *resultobj;
13723 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13724 wxString *arg2 = 0 ;
13725 bool temp2 = false ;
13726 PyObject * obj0 = 0 ;
13727 PyObject * obj1 = 0 ;
13728 char *kwnames[] = {
13729 (char *) "self",(char *) "shortDesc", NULL
13730 };
13731
13732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13734 if (SWIG_arg_fail(1)) SWIG_fail;
13735 {
13736 arg2 = wxString_in_helper(obj1);
13737 if (arg2 == NULL) SWIG_fail;
13738 temp2 = true;
13739 }
13740 {
13741 PyThreadState* __tstate = wxPyBeginAllowThreads();
13742 (arg1)->SetShortDesc((wxString const &)*arg2);
13743
13744 wxPyEndAllowThreads(__tstate);
13745 if (PyErr_Occurred()) SWIG_fail;
13746 }
13747 Py_INCREF(Py_None); resultobj = Py_None;
13748 {
13749 if (temp2)
13750 delete arg2;
13751 }
13752 return resultobj;
13753 fail:
13754 {
13755 if (temp2)
13756 delete arg2;
13757 }
13758 return NULL;
13759 }
13760
13761
13762 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13763 PyObject *resultobj;
13764 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13765 wxString *result;
13766 PyObject * obj0 = 0 ;
13767 char *kwnames[] = {
13768 (char *) "self", NULL
13769 };
13770
13771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13773 if (SWIG_arg_fail(1)) SWIG_fail;
13774 {
13775 PyThreadState* __tstate = wxPyBeginAllowThreads();
13776 {
13777 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13778 result = (wxString *) &_result_ref;
13779 }
13780
13781 wxPyEndAllowThreads(__tstate);
13782 if (PyErr_Occurred()) SWIG_fail;
13783 }
13784 {
13785 #if wxUSE_UNICODE
13786 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13787 #else
13788 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13789 #endif
13790 }
13791 return resultobj;
13792 fail:
13793 return NULL;
13794 }
13795
13796
13797 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13798 PyObject *resultobj;
13799 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13800 wxString *result;
13801 PyObject * obj0 = 0 ;
13802 char *kwnames[] = {
13803 (char *) "self", NULL
13804 };
13805
13806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13808 if (SWIG_arg_fail(1)) SWIG_fail;
13809 {
13810 PyThreadState* __tstate = wxPyBeginAllowThreads();
13811 {
13812 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13813 result = (wxString *) &_result_ref;
13814 }
13815
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 {
13820 #if wxUSE_UNICODE
13821 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13822 #else
13823 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13824 #endif
13825 }
13826 return resultobj;
13827 fail:
13828 return NULL;
13829 }
13830
13831
13832 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13833 PyObject *resultobj;
13834 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13835 wxString *result;
13836 PyObject * obj0 = 0 ;
13837 char *kwnames[] = {
13838 (char *) "self", NULL
13839 };
13840
13841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13843 if (SWIG_arg_fail(1)) SWIG_fail;
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 {
13847 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
13848 result = (wxString *) &_result_ref;
13849 }
13850
13851 wxPyEndAllowThreads(__tstate);
13852 if (PyErr_Occurred()) SWIG_fail;
13853 }
13854 {
13855 #if wxUSE_UNICODE
13856 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13857 #else
13858 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13859 #endif
13860 }
13861 return resultobj;
13862 fail:
13863 return NULL;
13864 }
13865
13866
13867 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13868 PyObject *resultobj;
13869 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13870 wxString *result;
13871 PyObject * obj0 = 0 ;
13872 char *kwnames[] = {
13873 (char *) "self", NULL
13874 };
13875
13876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
13877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13878 if (SWIG_arg_fail(1)) SWIG_fail;
13879 {
13880 PyThreadState* __tstate = wxPyBeginAllowThreads();
13881 {
13882 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
13883 result = (wxString *) &_result_ref;
13884 }
13885
13886 wxPyEndAllowThreads(__tstate);
13887 if (PyErr_Occurred()) SWIG_fail;
13888 }
13889 {
13890 #if wxUSE_UNICODE
13891 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13892 #else
13893 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13894 #endif
13895 }
13896 return resultobj;
13897 fail:
13898 return NULL;
13899 }
13900
13901
13902 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
13903 PyObject *resultobj;
13904 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13905 wxString *result;
13906 PyObject * obj0 = 0 ;
13907 char *kwnames[] = {
13908 (char *) "self", NULL
13909 };
13910
13911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
13912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13913 if (SWIG_arg_fail(1)) SWIG_fail;
13914 {
13915 PyThreadState* __tstate = wxPyBeginAllowThreads();
13916 {
13917 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
13918 result = (wxString *) &_result_ref;
13919 }
13920
13921 wxPyEndAllowThreads(__tstate);
13922 if (PyErr_Occurred()) SWIG_fail;
13923 }
13924 {
13925 #if wxUSE_UNICODE
13926 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13927 #else
13928 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13929 #endif
13930 }
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
13938 PyObject *resultobj;
13939 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13940 wxArrayString *result;
13941 PyObject * obj0 = 0 ;
13942 char *kwnames[] = {
13943 (char *) "self", NULL
13944 };
13945
13946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
13947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13948 if (SWIG_arg_fail(1)) SWIG_fail;
13949 {
13950 PyThreadState* __tstate = wxPyBeginAllowThreads();
13951 {
13952 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
13953 result = (wxArrayString *) &_result_ref;
13954 }
13955
13956 wxPyEndAllowThreads(__tstate);
13957 if (PyErr_Occurred()) SWIG_fail;
13958 }
13959 {
13960 resultobj = wxArrayString2PyList_helper(*result);
13961 }
13962 return resultobj;
13963 fail:
13964 return NULL;
13965 }
13966
13967
13968 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
13969 PyObject *resultobj;
13970 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13971 int result;
13972 PyObject * obj0 = 0 ;
13973 char *kwnames[] = {
13974 (char *) "self", NULL
13975 };
13976
13977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
13978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13979 if (SWIG_arg_fail(1)) SWIG_fail;
13980 {
13981 PyThreadState* __tstate = wxPyBeginAllowThreads();
13982 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
13983
13984 wxPyEndAllowThreads(__tstate);
13985 if (PyErr_Occurred()) SWIG_fail;
13986 }
13987 {
13988 resultobj = SWIG_From_int((int)(result));
13989 }
13990 return resultobj;
13991 fail:
13992 return NULL;
13993 }
13994
13995
13996 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
13997 PyObject *resultobj;
13998 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13999 wxString *result;
14000 PyObject * obj0 = 0 ;
14001 char *kwnames[] = {
14002 (char *) "self", NULL
14003 };
14004
14005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14007 if (SWIG_arg_fail(1)) SWIG_fail;
14008 {
14009 PyThreadState* __tstate = wxPyBeginAllowThreads();
14010 {
14011 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14012 result = (wxString *) &_result_ref;
14013 }
14014
14015 wxPyEndAllowThreads(__tstate);
14016 if (PyErr_Occurred()) SWIG_fail;
14017 }
14018 {
14019 #if wxUSE_UNICODE
14020 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14021 #else
14022 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14023 #endif
14024 }
14025 return resultobj;
14026 fail:
14027 return NULL;
14028 }
14029
14030
14031 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14032 PyObject *resultobj;
14033 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14034 int result;
14035 PyObject * obj0 = 0 ;
14036 char *kwnames[] = {
14037 (char *) "self", NULL
14038 };
14039
14040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14042 if (SWIG_arg_fail(1)) SWIG_fail;
14043 {
14044 PyThreadState* __tstate = wxPyBeginAllowThreads();
14045 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14046
14047 wxPyEndAllowThreads(__tstate);
14048 if (PyErr_Occurred()) SWIG_fail;
14049 }
14050 {
14051 resultobj = SWIG_From_int((int)(result));
14052 }
14053 return resultobj;
14054 fail:
14055 return NULL;
14056 }
14057
14058
14059 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14060 PyObject *obj;
14061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14062 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14063 Py_INCREF(obj);
14064 return Py_BuildValue((char *)"");
14065 }
14066 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14067 PyObject *resultobj;
14068 wxFileTypeInfo *arg1 = 0 ;
14069 wxFileType *result;
14070 PyObject * obj0 = 0 ;
14071 char *kwnames[] = {
14072 (char *) "ftInfo", NULL
14073 };
14074
14075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14076 {
14077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14078 if (SWIG_arg_fail(1)) SWIG_fail;
14079 if (arg1 == NULL) {
14080 SWIG_null_ref("wxFileTypeInfo");
14081 }
14082 if (SWIG_arg_fail(1)) SWIG_fail;
14083 }
14084 {
14085 PyThreadState* __tstate = wxPyBeginAllowThreads();
14086 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14087
14088 wxPyEndAllowThreads(__tstate);
14089 if (PyErr_Occurred()) SWIG_fail;
14090 }
14091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14092 return resultobj;
14093 fail:
14094 return NULL;
14095 }
14096
14097
14098 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14099 PyObject *resultobj;
14100 wxFileType *arg1 = (wxFileType *) 0 ;
14101 PyObject * obj0 = 0 ;
14102 char *kwnames[] = {
14103 (char *) "self", NULL
14104 };
14105
14106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14108 if (SWIG_arg_fail(1)) SWIG_fail;
14109 {
14110 PyThreadState* __tstate = wxPyBeginAllowThreads();
14111 delete arg1;
14112
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 Py_INCREF(Py_None); resultobj = Py_None;
14117 return resultobj;
14118 fail:
14119 return NULL;
14120 }
14121
14122
14123 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14124 PyObject *resultobj;
14125 wxFileType *arg1 = (wxFileType *) 0 ;
14126 PyObject *result;
14127 PyObject * obj0 = 0 ;
14128 char *kwnames[] = {
14129 (char *) "self", NULL
14130 };
14131
14132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14134 if (SWIG_arg_fail(1)) SWIG_fail;
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 result = (PyObject *)wxFileType_GetMimeType(arg1);
14138
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 resultobj = result;
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14150 PyObject *resultobj;
14151 wxFileType *arg1 = (wxFileType *) 0 ;
14152 PyObject *result;
14153 PyObject * obj0 = 0 ;
14154 char *kwnames[] = {
14155 (char *) "self", NULL
14156 };
14157
14158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14160 if (SWIG_arg_fail(1)) SWIG_fail;
14161 {
14162 PyThreadState* __tstate = wxPyBeginAllowThreads();
14163 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14164
14165 wxPyEndAllowThreads(__tstate);
14166 if (PyErr_Occurred()) SWIG_fail;
14167 }
14168 resultobj = result;
14169 return resultobj;
14170 fail:
14171 return NULL;
14172 }
14173
14174
14175 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14176 PyObject *resultobj;
14177 wxFileType *arg1 = (wxFileType *) 0 ;
14178 PyObject *result;
14179 PyObject * obj0 = 0 ;
14180 char *kwnames[] = {
14181 (char *) "self", NULL
14182 };
14183
14184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14186 if (SWIG_arg_fail(1)) SWIG_fail;
14187 {
14188 PyThreadState* __tstate = wxPyBeginAllowThreads();
14189 result = (PyObject *)wxFileType_GetExtensions(arg1);
14190
14191 wxPyEndAllowThreads(__tstate);
14192 if (PyErr_Occurred()) SWIG_fail;
14193 }
14194 resultobj = result;
14195 return resultobj;
14196 fail:
14197 return NULL;
14198 }
14199
14200
14201 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14202 PyObject *resultobj;
14203 wxFileType *arg1 = (wxFileType *) 0 ;
14204 wxIcon *result;
14205 PyObject * obj0 = 0 ;
14206 char *kwnames[] = {
14207 (char *) "self", NULL
14208 };
14209
14210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14212 if (SWIG_arg_fail(1)) SWIG_fail;
14213 {
14214 PyThreadState* __tstate = wxPyBeginAllowThreads();
14215 result = (wxIcon *)wxFileType_GetIcon(arg1);
14216
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14228 PyObject *resultobj;
14229 wxFileType *arg1 = (wxFileType *) 0 ;
14230 PyObject *result;
14231 PyObject * obj0 = 0 ;
14232 char *kwnames[] = {
14233 (char *) "self", NULL
14234 };
14235
14236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14238 if (SWIG_arg_fail(1)) SWIG_fail;
14239 {
14240 PyThreadState* __tstate = wxPyBeginAllowThreads();
14241 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14242
14243 wxPyEndAllowThreads(__tstate);
14244 if (PyErr_Occurred()) SWIG_fail;
14245 }
14246 resultobj = result;
14247 return resultobj;
14248 fail:
14249 return NULL;
14250 }
14251
14252
14253 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14254 PyObject *resultobj;
14255 wxFileType *arg1 = (wxFileType *) 0 ;
14256 PyObject *result;
14257 PyObject * obj0 = 0 ;
14258 char *kwnames[] = {
14259 (char *) "self", NULL
14260 };
14261
14262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14264 if (SWIG_arg_fail(1)) SWIG_fail;
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 result = (PyObject *)wxFileType_GetDescription(arg1);
14268
14269 wxPyEndAllowThreads(__tstate);
14270 if (PyErr_Occurred()) SWIG_fail;
14271 }
14272 resultobj = result;
14273 return resultobj;
14274 fail:
14275 return NULL;
14276 }
14277
14278
14279 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14280 PyObject *resultobj;
14281 wxFileType *arg1 = (wxFileType *) 0 ;
14282 wxString *arg2 = 0 ;
14283 wxString const &arg3_defvalue = wxPyEmptyString ;
14284 wxString *arg3 = (wxString *) &arg3_defvalue ;
14285 PyObject *result;
14286 bool temp2 = false ;
14287 bool temp3 = false ;
14288 PyObject * obj0 = 0 ;
14289 PyObject * obj1 = 0 ;
14290 PyObject * obj2 = 0 ;
14291 char *kwnames[] = {
14292 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14293 };
14294
14295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14297 if (SWIG_arg_fail(1)) SWIG_fail;
14298 {
14299 arg2 = wxString_in_helper(obj1);
14300 if (arg2 == NULL) SWIG_fail;
14301 temp2 = true;
14302 }
14303 if (obj2) {
14304 {
14305 arg3 = wxString_in_helper(obj2);
14306 if (arg3 == NULL) SWIG_fail;
14307 temp3 = true;
14308 }
14309 }
14310 {
14311 PyThreadState* __tstate = wxPyBeginAllowThreads();
14312 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14313
14314 wxPyEndAllowThreads(__tstate);
14315 if (PyErr_Occurred()) SWIG_fail;
14316 }
14317 resultobj = result;
14318 {
14319 if (temp2)
14320 delete arg2;
14321 }
14322 {
14323 if (temp3)
14324 delete arg3;
14325 }
14326 return resultobj;
14327 fail:
14328 {
14329 if (temp2)
14330 delete arg2;
14331 }
14332 {
14333 if (temp3)
14334 delete arg3;
14335 }
14336 return NULL;
14337 }
14338
14339
14340 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj;
14342 wxFileType *arg1 = (wxFileType *) 0 ;
14343 wxString *arg2 = 0 ;
14344 wxString const &arg3_defvalue = wxPyEmptyString ;
14345 wxString *arg3 = (wxString *) &arg3_defvalue ;
14346 PyObject *result;
14347 bool temp2 = false ;
14348 bool temp3 = false ;
14349 PyObject * obj0 = 0 ;
14350 PyObject * obj1 = 0 ;
14351 PyObject * obj2 = 0 ;
14352 char *kwnames[] = {
14353 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14354 };
14355
14356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14358 if (SWIG_arg_fail(1)) SWIG_fail;
14359 {
14360 arg2 = wxString_in_helper(obj1);
14361 if (arg2 == NULL) SWIG_fail;
14362 temp2 = true;
14363 }
14364 if (obj2) {
14365 {
14366 arg3 = wxString_in_helper(obj2);
14367 if (arg3 == NULL) SWIG_fail;
14368 temp3 = true;
14369 }
14370 }
14371 {
14372 PyThreadState* __tstate = wxPyBeginAllowThreads();
14373 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14374
14375 wxPyEndAllowThreads(__tstate);
14376 if (PyErr_Occurred()) SWIG_fail;
14377 }
14378 resultobj = result;
14379 {
14380 if (temp2)
14381 delete arg2;
14382 }
14383 {
14384 if (temp3)
14385 delete arg3;
14386 }
14387 return resultobj;
14388 fail:
14389 {
14390 if (temp2)
14391 delete arg2;
14392 }
14393 {
14394 if (temp3)
14395 delete arg3;
14396 }
14397 return NULL;
14398 }
14399
14400
14401 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14402 PyObject *resultobj;
14403 wxFileType *arg1 = (wxFileType *) 0 ;
14404 wxString *arg2 = 0 ;
14405 wxString const &arg3_defvalue = wxPyEmptyString ;
14406 wxString *arg3 = (wxString *) &arg3_defvalue ;
14407 PyObject *result;
14408 bool temp2 = false ;
14409 bool temp3 = false ;
14410 PyObject * obj0 = 0 ;
14411 PyObject * obj1 = 0 ;
14412 PyObject * obj2 = 0 ;
14413 char *kwnames[] = {
14414 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14415 };
14416
14417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14419 if (SWIG_arg_fail(1)) SWIG_fail;
14420 {
14421 arg2 = wxString_in_helper(obj1);
14422 if (arg2 == NULL) SWIG_fail;
14423 temp2 = true;
14424 }
14425 if (obj2) {
14426 {
14427 arg3 = wxString_in_helper(obj2);
14428 if (arg3 == NULL) SWIG_fail;
14429 temp3 = true;
14430 }
14431 }
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14435
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 resultobj = result;
14440 {
14441 if (temp2)
14442 delete arg2;
14443 }
14444 {
14445 if (temp3)
14446 delete arg3;
14447 }
14448 return resultobj;
14449 fail:
14450 {
14451 if (temp2)
14452 delete arg2;
14453 }
14454 {
14455 if (temp3)
14456 delete arg3;
14457 }
14458 return NULL;
14459 }
14460
14461
14462 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14463 PyObject *resultobj;
14464 wxFileType *arg1 = (wxFileType *) 0 ;
14465 wxString *arg2 = 0 ;
14466 wxString *arg3 = 0 ;
14467 bool arg4 = (bool) true ;
14468 bool result;
14469 bool temp2 = false ;
14470 bool temp3 = false ;
14471 PyObject * obj0 = 0 ;
14472 PyObject * obj1 = 0 ;
14473 PyObject * obj2 = 0 ;
14474 PyObject * obj3 = 0 ;
14475 char *kwnames[] = {
14476 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14477 };
14478
14479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14481 if (SWIG_arg_fail(1)) SWIG_fail;
14482 {
14483 arg2 = wxString_in_helper(obj1);
14484 if (arg2 == NULL) SWIG_fail;
14485 temp2 = true;
14486 }
14487 {
14488 arg3 = wxString_in_helper(obj2);
14489 if (arg3 == NULL) SWIG_fail;
14490 temp3 = true;
14491 }
14492 if (obj3) {
14493 {
14494 arg4 = (bool)(SWIG_As_bool(obj3));
14495 if (SWIG_arg_fail(4)) SWIG_fail;
14496 }
14497 }
14498 {
14499 PyThreadState* __tstate = wxPyBeginAllowThreads();
14500 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14501
14502 wxPyEndAllowThreads(__tstate);
14503 if (PyErr_Occurred()) SWIG_fail;
14504 }
14505 {
14506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14507 }
14508 {
14509 if (temp2)
14510 delete arg2;
14511 }
14512 {
14513 if (temp3)
14514 delete arg3;
14515 }
14516 return resultobj;
14517 fail:
14518 {
14519 if (temp2)
14520 delete arg2;
14521 }
14522 {
14523 if (temp3)
14524 delete arg3;
14525 }
14526 return NULL;
14527 }
14528
14529
14530 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14531 PyObject *resultobj;
14532 wxFileType *arg1 = (wxFileType *) 0 ;
14533 wxString const &arg2_defvalue = wxPyEmptyString ;
14534 wxString *arg2 = (wxString *) &arg2_defvalue ;
14535 int arg3 = (int) 0 ;
14536 bool result;
14537 bool temp2 = false ;
14538 PyObject * obj0 = 0 ;
14539 PyObject * obj1 = 0 ;
14540 PyObject * obj2 = 0 ;
14541 char *kwnames[] = {
14542 (char *) "self",(char *) "cmd",(char *) "index", NULL
14543 };
14544
14545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14547 if (SWIG_arg_fail(1)) SWIG_fail;
14548 if (obj1) {
14549 {
14550 arg2 = wxString_in_helper(obj1);
14551 if (arg2 == NULL) SWIG_fail;
14552 temp2 = true;
14553 }
14554 }
14555 if (obj2) {
14556 {
14557 arg3 = (int)(SWIG_As_int(obj2));
14558 if (SWIG_arg_fail(3)) SWIG_fail;
14559 }
14560 }
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14564
14565 wxPyEndAllowThreads(__tstate);
14566 if (PyErr_Occurred()) SWIG_fail;
14567 }
14568 {
14569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14570 }
14571 {
14572 if (temp2)
14573 delete arg2;
14574 }
14575 return resultobj;
14576 fail:
14577 {
14578 if (temp2)
14579 delete arg2;
14580 }
14581 return NULL;
14582 }
14583
14584
14585 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14586 PyObject *resultobj;
14587 wxFileType *arg1 = (wxFileType *) 0 ;
14588 bool result;
14589 PyObject * obj0 = 0 ;
14590 char *kwnames[] = {
14591 (char *) "self", NULL
14592 };
14593
14594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14596 if (SWIG_arg_fail(1)) SWIG_fail;
14597 {
14598 PyThreadState* __tstate = wxPyBeginAllowThreads();
14599 result = (bool)(arg1)->Unassociate();
14600
14601 wxPyEndAllowThreads(__tstate);
14602 if (PyErr_Occurred()) SWIG_fail;
14603 }
14604 {
14605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14606 }
14607 return resultobj;
14608 fail:
14609 return NULL;
14610 }
14611
14612
14613 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14614 PyObject *resultobj;
14615 wxString *arg1 = 0 ;
14616 wxString *arg2 = 0 ;
14617 wxString const &arg3_defvalue = wxPyEmptyString ;
14618 wxString *arg3 = (wxString *) &arg3_defvalue ;
14619 wxString result;
14620 bool temp1 = false ;
14621 bool temp2 = false ;
14622 bool temp3 = false ;
14623 PyObject * obj0 = 0 ;
14624 PyObject * obj1 = 0 ;
14625 PyObject * obj2 = 0 ;
14626 char *kwnames[] = {
14627 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14628 };
14629
14630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14631 {
14632 arg1 = wxString_in_helper(obj0);
14633 if (arg1 == NULL) SWIG_fail;
14634 temp1 = true;
14635 }
14636 {
14637 arg2 = wxString_in_helper(obj1);
14638 if (arg2 == NULL) SWIG_fail;
14639 temp2 = true;
14640 }
14641 if (obj2) {
14642 {
14643 arg3 = wxString_in_helper(obj2);
14644 if (arg3 == NULL) SWIG_fail;
14645 temp3 = true;
14646 }
14647 }
14648 {
14649 PyThreadState* __tstate = wxPyBeginAllowThreads();
14650 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14651
14652 wxPyEndAllowThreads(__tstate);
14653 if (PyErr_Occurred()) SWIG_fail;
14654 }
14655 {
14656 #if wxUSE_UNICODE
14657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14658 #else
14659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14660 #endif
14661 }
14662 {
14663 if (temp1)
14664 delete arg1;
14665 }
14666 {
14667 if (temp2)
14668 delete arg2;
14669 }
14670 {
14671 if (temp3)
14672 delete arg3;
14673 }
14674 return resultobj;
14675 fail:
14676 {
14677 if (temp1)
14678 delete arg1;
14679 }
14680 {
14681 if (temp2)
14682 delete arg2;
14683 }
14684 {
14685 if (temp3)
14686 delete arg3;
14687 }
14688 return NULL;
14689 }
14690
14691
14692 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14693 PyObject *obj;
14694 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14695 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14696 Py_INCREF(obj);
14697 return Py_BuildValue((char *)"");
14698 }
14699 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14700 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14701 return 1;
14702 }
14703
14704
14705 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14706 PyObject *pyobj;
14707
14708 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14709 return pyobj;
14710 }
14711
14712
14713 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14714 PyObject *resultobj;
14715 wxString *arg1 = 0 ;
14716 wxString *arg2 = 0 ;
14717 bool result;
14718 bool temp1 = false ;
14719 bool temp2 = false ;
14720 PyObject * obj0 = 0 ;
14721 PyObject * obj1 = 0 ;
14722 char *kwnames[] = {
14723 (char *) "mimeType",(char *) "wildcard", NULL
14724 };
14725
14726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14727 {
14728 arg1 = wxString_in_helper(obj0);
14729 if (arg1 == NULL) SWIG_fail;
14730 temp1 = true;
14731 }
14732 {
14733 arg2 = wxString_in_helper(obj1);
14734 if (arg2 == NULL) SWIG_fail;
14735 temp2 = true;
14736 }
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14740
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 {
14745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14746 }
14747 {
14748 if (temp1)
14749 delete arg1;
14750 }
14751 {
14752 if (temp2)
14753 delete arg2;
14754 }
14755 return resultobj;
14756 fail:
14757 {
14758 if (temp1)
14759 delete arg1;
14760 }
14761 {
14762 if (temp2)
14763 delete arg2;
14764 }
14765 return NULL;
14766 }
14767
14768
14769 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14770 PyObject *resultobj;
14771 wxMimeTypesManager *result;
14772 char *kwnames[] = {
14773 NULL
14774 };
14775
14776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14777 {
14778 PyThreadState* __tstate = wxPyBeginAllowThreads();
14779 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14780
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14792 PyObject *resultobj;
14793 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14794 int arg2 = (int) wxMAILCAP_ALL ;
14795 wxString const &arg3_defvalue = wxPyEmptyString ;
14796 wxString *arg3 = (wxString *) &arg3_defvalue ;
14797 bool temp3 = false ;
14798 PyObject * obj0 = 0 ;
14799 PyObject * obj1 = 0 ;
14800 PyObject * obj2 = 0 ;
14801 char *kwnames[] = {
14802 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14803 };
14804
14805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14807 if (SWIG_arg_fail(1)) SWIG_fail;
14808 if (obj1) {
14809 {
14810 arg2 = (int)(SWIG_As_int(obj1));
14811 if (SWIG_arg_fail(2)) SWIG_fail;
14812 }
14813 }
14814 if (obj2) {
14815 {
14816 arg3 = wxString_in_helper(obj2);
14817 if (arg3 == NULL) SWIG_fail;
14818 temp3 = true;
14819 }
14820 }
14821 {
14822 PyThreadState* __tstate = wxPyBeginAllowThreads();
14823 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14824
14825 wxPyEndAllowThreads(__tstate);
14826 if (PyErr_Occurred()) SWIG_fail;
14827 }
14828 Py_INCREF(Py_None); resultobj = Py_None;
14829 {
14830 if (temp3)
14831 delete arg3;
14832 }
14833 return resultobj;
14834 fail:
14835 {
14836 if (temp3)
14837 delete arg3;
14838 }
14839 return NULL;
14840 }
14841
14842
14843 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14844 PyObject *resultobj;
14845 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14846 PyObject * obj0 = 0 ;
14847 char *kwnames[] = {
14848 (char *) "self", NULL
14849 };
14850
14851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
14852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14853 if (SWIG_arg_fail(1)) SWIG_fail;
14854 {
14855 PyThreadState* __tstate = wxPyBeginAllowThreads();
14856 (arg1)->ClearData();
14857
14858 wxPyEndAllowThreads(__tstate);
14859 if (PyErr_Occurred()) SWIG_fail;
14860 }
14861 Py_INCREF(Py_None); resultobj = Py_None;
14862 return resultobj;
14863 fail:
14864 return NULL;
14865 }
14866
14867
14868 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
14869 PyObject *resultobj;
14870 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14871 wxString *arg2 = 0 ;
14872 wxFileType *result;
14873 bool temp2 = false ;
14874 PyObject * obj0 = 0 ;
14875 PyObject * obj1 = 0 ;
14876 char *kwnames[] = {
14877 (char *) "self",(char *) "ext", NULL
14878 };
14879
14880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
14881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14882 if (SWIG_arg_fail(1)) SWIG_fail;
14883 {
14884 arg2 = wxString_in_helper(obj1);
14885 if (arg2 == NULL) SWIG_fail;
14886 temp2 = true;
14887 }
14888 {
14889 PyThreadState* __tstate = wxPyBeginAllowThreads();
14890 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
14891
14892 wxPyEndAllowThreads(__tstate);
14893 if (PyErr_Occurred()) SWIG_fail;
14894 }
14895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14896 {
14897 if (temp2)
14898 delete arg2;
14899 }
14900 return resultobj;
14901 fail:
14902 {
14903 if (temp2)
14904 delete arg2;
14905 }
14906 return NULL;
14907 }
14908
14909
14910 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14911 PyObject *resultobj;
14912 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14913 wxString *arg2 = 0 ;
14914 wxFileType *result;
14915 bool temp2 = false ;
14916 PyObject * obj0 = 0 ;
14917 PyObject * obj1 = 0 ;
14918 char *kwnames[] = {
14919 (char *) "self",(char *) "mimeType", NULL
14920 };
14921
14922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
14923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14924 if (SWIG_arg_fail(1)) SWIG_fail;
14925 {
14926 arg2 = wxString_in_helper(obj1);
14927 if (arg2 == NULL) SWIG_fail;
14928 temp2 = true;
14929 }
14930 {
14931 PyThreadState* __tstate = wxPyBeginAllowThreads();
14932 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
14933
14934 wxPyEndAllowThreads(__tstate);
14935 if (PyErr_Occurred()) SWIG_fail;
14936 }
14937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14938 {
14939 if (temp2)
14940 delete arg2;
14941 }
14942 return resultobj;
14943 fail:
14944 {
14945 if (temp2)
14946 delete arg2;
14947 }
14948 return NULL;
14949 }
14950
14951
14952 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
14953 PyObject *resultobj;
14954 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14955 wxString *arg2 = 0 ;
14956 bool arg3 = (bool) false ;
14957 bool result;
14958 bool temp2 = false ;
14959 PyObject * obj0 = 0 ;
14960 PyObject * obj1 = 0 ;
14961 PyObject * obj2 = 0 ;
14962 char *kwnames[] = {
14963 (char *) "self",(char *) "filename",(char *) "fallback", NULL
14964 };
14965
14966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
14967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14968 if (SWIG_arg_fail(1)) SWIG_fail;
14969 {
14970 arg2 = wxString_in_helper(obj1);
14971 if (arg2 == NULL) SWIG_fail;
14972 temp2 = true;
14973 }
14974 if (obj2) {
14975 {
14976 arg3 = (bool)(SWIG_As_bool(obj2));
14977 if (SWIG_arg_fail(3)) SWIG_fail;
14978 }
14979 }
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
14983
14984 wxPyEndAllowThreads(__tstate);
14985 if (PyErr_Occurred()) SWIG_fail;
14986 }
14987 {
14988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14989 }
14990 {
14991 if (temp2)
14992 delete arg2;
14993 }
14994 return resultobj;
14995 fail:
14996 {
14997 if (temp2)
14998 delete arg2;
14999 }
15000 return NULL;
15001 }
15002
15003
15004 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15005 PyObject *resultobj;
15006 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15007 wxString *arg2 = 0 ;
15008 bool result;
15009 bool temp2 = false ;
15010 PyObject * obj0 = 0 ;
15011 PyObject * obj1 = 0 ;
15012 char *kwnames[] = {
15013 (char *) "self",(char *) "filename", NULL
15014 };
15015
15016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15018 if (SWIG_arg_fail(1)) SWIG_fail;
15019 {
15020 arg2 = wxString_in_helper(obj1);
15021 if (arg2 == NULL) SWIG_fail;
15022 temp2 = true;
15023 }
15024 {
15025 PyThreadState* __tstate = wxPyBeginAllowThreads();
15026 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15027
15028 wxPyEndAllowThreads(__tstate);
15029 if (PyErr_Occurred()) SWIG_fail;
15030 }
15031 {
15032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15033 }
15034 {
15035 if (temp2)
15036 delete arg2;
15037 }
15038 return resultobj;
15039 fail:
15040 {
15041 if (temp2)
15042 delete arg2;
15043 }
15044 return NULL;
15045 }
15046
15047
15048 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15049 PyObject *resultobj;
15050 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15051 PyObject *result;
15052 PyObject * obj0 = 0 ;
15053 char *kwnames[] = {
15054 (char *) "self", NULL
15055 };
15056
15057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15059 if (SWIG_arg_fail(1)) SWIG_fail;
15060 {
15061 PyThreadState* __tstate = wxPyBeginAllowThreads();
15062 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15063
15064 wxPyEndAllowThreads(__tstate);
15065 if (PyErr_Occurred()) SWIG_fail;
15066 }
15067 resultobj = result;
15068 return resultobj;
15069 fail:
15070 return NULL;
15071 }
15072
15073
15074 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15075 PyObject *resultobj;
15076 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15077 wxFileTypeInfo *arg2 = 0 ;
15078 PyObject * obj0 = 0 ;
15079 PyObject * obj1 = 0 ;
15080 char *kwnames[] = {
15081 (char *) "self",(char *) "ft", NULL
15082 };
15083
15084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15086 if (SWIG_arg_fail(1)) SWIG_fail;
15087 {
15088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15089 if (SWIG_arg_fail(2)) SWIG_fail;
15090 if (arg2 == NULL) {
15091 SWIG_null_ref("wxFileTypeInfo");
15092 }
15093 if (SWIG_arg_fail(2)) SWIG_fail;
15094 }
15095 {
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15098
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 Py_INCREF(Py_None); resultobj = Py_None;
15103 return resultobj;
15104 fail:
15105 return NULL;
15106 }
15107
15108
15109 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj;
15111 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15112 wxFileTypeInfo *arg2 = 0 ;
15113 wxFileType *result;
15114 PyObject * obj0 = 0 ;
15115 PyObject * obj1 = 0 ;
15116 char *kwnames[] = {
15117 (char *) "self",(char *) "ftInfo", NULL
15118 };
15119
15120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15122 if (SWIG_arg_fail(1)) SWIG_fail;
15123 {
15124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15125 if (SWIG_arg_fail(2)) SWIG_fail;
15126 if (arg2 == NULL) {
15127 SWIG_null_ref("wxFileTypeInfo");
15128 }
15129 if (SWIG_arg_fail(2)) SWIG_fail;
15130 }
15131 {
15132 PyThreadState* __tstate = wxPyBeginAllowThreads();
15133 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15134
15135 wxPyEndAllowThreads(__tstate);
15136 if (PyErr_Occurred()) SWIG_fail;
15137 }
15138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15139 return resultobj;
15140 fail:
15141 return NULL;
15142 }
15143
15144
15145 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15146 PyObject *resultobj;
15147 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15148 wxFileType *arg2 = (wxFileType *) 0 ;
15149 bool result;
15150 PyObject * obj0 = 0 ;
15151 PyObject * obj1 = 0 ;
15152 char *kwnames[] = {
15153 (char *) "self",(char *) "ft", NULL
15154 };
15155
15156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15158 if (SWIG_arg_fail(1)) SWIG_fail;
15159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15160 if (SWIG_arg_fail(2)) SWIG_fail;
15161 {
15162 PyThreadState* __tstate = wxPyBeginAllowThreads();
15163 result = (bool)(arg1)->Unassociate(arg2);
15164
15165 wxPyEndAllowThreads(__tstate);
15166 if (PyErr_Occurred()) SWIG_fail;
15167 }
15168 {
15169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15170 }
15171 return resultobj;
15172 fail:
15173 return NULL;
15174 }
15175
15176
15177 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15178 PyObject *resultobj;
15179 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15180 PyObject * obj0 = 0 ;
15181 char *kwnames[] = {
15182 (char *) "self", NULL
15183 };
15184
15185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15187 if (SWIG_arg_fail(1)) SWIG_fail;
15188 {
15189 PyThreadState* __tstate = wxPyBeginAllowThreads();
15190 delete arg1;
15191
15192 wxPyEndAllowThreads(__tstate);
15193 if (PyErr_Occurred()) SWIG_fail;
15194 }
15195 Py_INCREF(Py_None); resultobj = Py_None;
15196 return resultobj;
15197 fail:
15198 return NULL;
15199 }
15200
15201
15202 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15203 PyObject *obj;
15204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15205 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15206 Py_INCREF(obj);
15207 return Py_BuildValue((char *)"");
15208 }
15209 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15210 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15211 return 1;
15212 }
15213
15214
15215 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15216 PyObject *pyobj;
15217
15218 {
15219 #if wxUSE_UNICODE
15220 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15221 #else
15222 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15223 #endif
15224 }
15225 return pyobj;
15226 }
15227
15228
15229 static int _wrap_ART_MENU_set(PyObject *) {
15230 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15231 return 1;
15232 }
15233
15234
15235 static PyObject *_wrap_ART_MENU_get(void) {
15236 PyObject *pyobj;
15237
15238 {
15239 #if wxUSE_UNICODE
15240 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15241 #else
15242 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15243 #endif
15244 }
15245 return pyobj;
15246 }
15247
15248
15249 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15250 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15251 return 1;
15252 }
15253
15254
15255 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15256 PyObject *pyobj;
15257
15258 {
15259 #if wxUSE_UNICODE
15260 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15261 #else
15262 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15263 #endif
15264 }
15265 return pyobj;
15266 }
15267
15268
15269 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15270 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15271 return 1;
15272 }
15273
15274
15275 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15276 PyObject *pyobj;
15277
15278 {
15279 #if wxUSE_UNICODE
15280 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15281 #else
15282 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15283 #endif
15284 }
15285 return pyobj;
15286 }
15287
15288
15289 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15290 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15291 return 1;
15292 }
15293
15294
15295 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15296 PyObject *pyobj;
15297
15298 {
15299 #if wxUSE_UNICODE
15300 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15301 #else
15302 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15303 #endif
15304 }
15305 return pyobj;
15306 }
15307
15308
15309 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15310 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15311 return 1;
15312 }
15313
15314
15315 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15316 PyObject *pyobj;
15317
15318 {
15319 #if wxUSE_UNICODE
15320 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15321 #else
15322 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15323 #endif
15324 }
15325 return pyobj;
15326 }
15327
15328
15329 static int _wrap_ART_BUTTON_set(PyObject *) {
15330 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15331 return 1;
15332 }
15333
15334
15335 static PyObject *_wrap_ART_BUTTON_get(void) {
15336 PyObject *pyobj;
15337
15338 {
15339 #if wxUSE_UNICODE
15340 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15341 #else
15342 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15343 #endif
15344 }
15345 return pyobj;
15346 }
15347
15348
15349 static int _wrap_ART_OTHER_set(PyObject *) {
15350 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15351 return 1;
15352 }
15353
15354
15355 static PyObject *_wrap_ART_OTHER_get(void) {
15356 PyObject *pyobj;
15357
15358 {
15359 #if wxUSE_UNICODE
15360 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15361 #else
15362 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15363 #endif
15364 }
15365 return pyobj;
15366 }
15367
15368
15369 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15370 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15371 return 1;
15372 }
15373
15374
15375 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15376 PyObject *pyobj;
15377
15378 {
15379 #if wxUSE_UNICODE
15380 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15381 #else
15382 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15383 #endif
15384 }
15385 return pyobj;
15386 }
15387
15388
15389 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15390 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15391 return 1;
15392 }
15393
15394
15395 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15396 PyObject *pyobj;
15397
15398 {
15399 #if wxUSE_UNICODE
15400 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15401 #else
15402 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15403 #endif
15404 }
15405 return pyobj;
15406 }
15407
15408
15409 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15410 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15411 return 1;
15412 }
15413
15414
15415 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15416 PyObject *pyobj;
15417
15418 {
15419 #if wxUSE_UNICODE
15420 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15421 #else
15422 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15423 #endif
15424 }
15425 return pyobj;
15426 }
15427
15428
15429 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15430 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15431 return 1;
15432 }
15433
15434
15435 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15436 PyObject *pyobj;
15437
15438 {
15439 #if wxUSE_UNICODE
15440 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15441 #else
15442 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15443 #endif
15444 }
15445 return pyobj;
15446 }
15447
15448
15449 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15450 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15451 return 1;
15452 }
15453
15454
15455 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15456 PyObject *pyobj;
15457
15458 {
15459 #if wxUSE_UNICODE
15460 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15461 #else
15462 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15463 #endif
15464 }
15465 return pyobj;
15466 }
15467
15468
15469 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15470 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15471 return 1;
15472 }
15473
15474
15475 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15476 PyObject *pyobj;
15477
15478 {
15479 #if wxUSE_UNICODE
15480 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15481 #else
15482 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15483 #endif
15484 }
15485 return pyobj;
15486 }
15487
15488
15489 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15490 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15491 return 1;
15492 }
15493
15494
15495 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15496 PyObject *pyobj;
15497
15498 {
15499 #if wxUSE_UNICODE
15500 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15501 #else
15502 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15503 #endif
15504 }
15505 return pyobj;
15506 }
15507
15508
15509 static int _wrap_ART_GO_BACK_set(PyObject *) {
15510 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15511 return 1;
15512 }
15513
15514
15515 static PyObject *_wrap_ART_GO_BACK_get(void) {
15516 PyObject *pyobj;
15517
15518 {
15519 #if wxUSE_UNICODE
15520 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15521 #else
15522 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15523 #endif
15524 }
15525 return pyobj;
15526 }
15527
15528
15529 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15530 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15531 return 1;
15532 }
15533
15534
15535 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15536 PyObject *pyobj;
15537
15538 {
15539 #if wxUSE_UNICODE
15540 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15541 #else
15542 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15543 #endif
15544 }
15545 return pyobj;
15546 }
15547
15548
15549 static int _wrap_ART_GO_UP_set(PyObject *) {
15550 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15551 return 1;
15552 }
15553
15554
15555 static PyObject *_wrap_ART_GO_UP_get(void) {
15556 PyObject *pyobj;
15557
15558 {
15559 #if wxUSE_UNICODE
15560 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15561 #else
15562 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15563 #endif
15564 }
15565 return pyobj;
15566 }
15567
15568
15569 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15570 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15571 return 1;
15572 }
15573
15574
15575 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15576 PyObject *pyobj;
15577
15578 {
15579 #if wxUSE_UNICODE
15580 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15581 #else
15582 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15583 #endif
15584 }
15585 return pyobj;
15586 }
15587
15588
15589 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15590 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15591 return 1;
15592 }
15593
15594
15595 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15596 PyObject *pyobj;
15597
15598 {
15599 #if wxUSE_UNICODE
15600 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15601 #else
15602 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15603 #endif
15604 }
15605 return pyobj;
15606 }
15607
15608
15609 static int _wrap_ART_GO_HOME_set(PyObject *) {
15610 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15611 return 1;
15612 }
15613
15614
15615 static PyObject *_wrap_ART_GO_HOME_get(void) {
15616 PyObject *pyobj;
15617
15618 {
15619 #if wxUSE_UNICODE
15620 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15621 #else
15622 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15623 #endif
15624 }
15625 return pyobj;
15626 }
15627
15628
15629 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15630 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15631 return 1;
15632 }
15633
15634
15635 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15636 PyObject *pyobj;
15637
15638 {
15639 #if wxUSE_UNICODE
15640 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15641 #else
15642 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15643 #endif
15644 }
15645 return pyobj;
15646 }
15647
15648
15649 static int _wrap_ART_PRINT_set(PyObject *) {
15650 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15651 return 1;
15652 }
15653
15654
15655 static PyObject *_wrap_ART_PRINT_get(void) {
15656 PyObject *pyobj;
15657
15658 {
15659 #if wxUSE_UNICODE
15660 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15661 #else
15662 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15663 #endif
15664 }
15665 return pyobj;
15666 }
15667
15668
15669 static int _wrap_ART_HELP_set(PyObject *) {
15670 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15671 return 1;
15672 }
15673
15674
15675 static PyObject *_wrap_ART_HELP_get(void) {
15676 PyObject *pyobj;
15677
15678 {
15679 #if wxUSE_UNICODE
15680 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15681 #else
15682 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15683 #endif
15684 }
15685 return pyobj;
15686 }
15687
15688
15689 static int _wrap_ART_TIP_set(PyObject *) {
15690 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15691 return 1;
15692 }
15693
15694
15695 static PyObject *_wrap_ART_TIP_get(void) {
15696 PyObject *pyobj;
15697
15698 {
15699 #if wxUSE_UNICODE
15700 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15701 #else
15702 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15703 #endif
15704 }
15705 return pyobj;
15706 }
15707
15708
15709 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15710 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15711 return 1;
15712 }
15713
15714
15715 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15716 PyObject *pyobj;
15717
15718 {
15719 #if wxUSE_UNICODE
15720 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15721 #else
15722 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15723 #endif
15724 }
15725 return pyobj;
15726 }
15727
15728
15729 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15730 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15731 return 1;
15732 }
15733
15734
15735 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15736 PyObject *pyobj;
15737
15738 {
15739 #if wxUSE_UNICODE
15740 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15741 #else
15742 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15743 #endif
15744 }
15745 return pyobj;
15746 }
15747
15748
15749 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15750 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15751 return 1;
15752 }
15753
15754
15755 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15756 PyObject *pyobj;
15757
15758 {
15759 #if wxUSE_UNICODE
15760 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15761 #else
15762 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15763 #endif
15764 }
15765 return pyobj;
15766 }
15767
15768
15769 static int _wrap_ART_HARDDISK_set(PyObject *) {
15770 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15771 return 1;
15772 }
15773
15774
15775 static PyObject *_wrap_ART_HARDDISK_get(void) {
15776 PyObject *pyobj;
15777
15778 {
15779 #if wxUSE_UNICODE
15780 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15781 #else
15782 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15783 #endif
15784 }
15785 return pyobj;
15786 }
15787
15788
15789 static int _wrap_ART_FLOPPY_set(PyObject *) {
15790 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15791 return 1;
15792 }
15793
15794
15795 static PyObject *_wrap_ART_FLOPPY_get(void) {
15796 PyObject *pyobj;
15797
15798 {
15799 #if wxUSE_UNICODE
15800 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15801 #else
15802 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15803 #endif
15804 }
15805 return pyobj;
15806 }
15807
15808
15809 static int _wrap_ART_CDROM_set(PyObject *) {
15810 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
15811 return 1;
15812 }
15813
15814
15815 static PyObject *_wrap_ART_CDROM_get(void) {
15816 PyObject *pyobj;
15817
15818 {
15819 #if wxUSE_UNICODE
15820 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15821 #else
15822 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15823 #endif
15824 }
15825 return pyobj;
15826 }
15827
15828
15829 static int _wrap_ART_REMOVABLE_set(PyObject *) {
15830 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
15831 return 1;
15832 }
15833
15834
15835 static PyObject *_wrap_ART_REMOVABLE_get(void) {
15836 PyObject *pyobj;
15837
15838 {
15839 #if wxUSE_UNICODE
15840 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15841 #else
15842 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15843 #endif
15844 }
15845 return pyobj;
15846 }
15847
15848
15849 static int _wrap_ART_FOLDER_set(PyObject *) {
15850 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
15851 return 1;
15852 }
15853
15854
15855 static PyObject *_wrap_ART_FOLDER_get(void) {
15856 PyObject *pyobj;
15857
15858 {
15859 #if wxUSE_UNICODE
15860 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15861 #else
15862 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15863 #endif
15864 }
15865 return pyobj;
15866 }
15867
15868
15869 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
15870 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
15871 return 1;
15872 }
15873
15874
15875 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
15876 PyObject *pyobj;
15877
15878 {
15879 #if wxUSE_UNICODE
15880 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15881 #else
15882 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15883 #endif
15884 }
15885 return pyobj;
15886 }
15887
15888
15889 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
15890 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
15891 return 1;
15892 }
15893
15894
15895 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
15896 PyObject *pyobj;
15897
15898 {
15899 #if wxUSE_UNICODE
15900 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15901 #else
15902 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15903 #endif
15904 }
15905 return pyobj;
15906 }
15907
15908
15909 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
15910 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
15911 return 1;
15912 }
15913
15914
15915 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
15916 PyObject *pyobj;
15917
15918 {
15919 #if wxUSE_UNICODE
15920 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15921 #else
15922 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15923 #endif
15924 }
15925 return pyobj;
15926 }
15927
15928
15929 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
15930 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
15931 return 1;
15932 }
15933
15934
15935 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
15936 PyObject *pyobj;
15937
15938 {
15939 #if wxUSE_UNICODE
15940 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15941 #else
15942 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15943 #endif
15944 }
15945 return pyobj;
15946 }
15947
15948
15949 static int _wrap_ART_TICK_MARK_set(PyObject *) {
15950 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
15951 return 1;
15952 }
15953
15954
15955 static PyObject *_wrap_ART_TICK_MARK_get(void) {
15956 PyObject *pyobj;
15957
15958 {
15959 #if wxUSE_UNICODE
15960 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15961 #else
15962 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15963 #endif
15964 }
15965 return pyobj;
15966 }
15967
15968
15969 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
15970 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
15971 return 1;
15972 }
15973
15974
15975 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
15976 PyObject *pyobj;
15977
15978 {
15979 #if wxUSE_UNICODE
15980 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15981 #else
15982 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15983 #endif
15984 }
15985 return pyobj;
15986 }
15987
15988
15989 static int _wrap_ART_ERROR_set(PyObject *) {
15990 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
15991 return 1;
15992 }
15993
15994
15995 static PyObject *_wrap_ART_ERROR_get(void) {
15996 PyObject *pyobj;
15997
15998 {
15999 #if wxUSE_UNICODE
16000 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16001 #else
16002 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16003 #endif
16004 }
16005 return pyobj;
16006 }
16007
16008
16009 static int _wrap_ART_QUESTION_set(PyObject *) {
16010 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16011 return 1;
16012 }
16013
16014
16015 static PyObject *_wrap_ART_QUESTION_get(void) {
16016 PyObject *pyobj;
16017
16018 {
16019 #if wxUSE_UNICODE
16020 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16021 #else
16022 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16023 #endif
16024 }
16025 return pyobj;
16026 }
16027
16028
16029 static int _wrap_ART_WARNING_set(PyObject *) {
16030 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16031 return 1;
16032 }
16033
16034
16035 static PyObject *_wrap_ART_WARNING_get(void) {
16036 PyObject *pyobj;
16037
16038 {
16039 #if wxUSE_UNICODE
16040 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16041 #else
16042 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16043 #endif
16044 }
16045 return pyobj;
16046 }
16047
16048
16049 static int _wrap_ART_INFORMATION_set(PyObject *) {
16050 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16051 return 1;
16052 }
16053
16054
16055 static PyObject *_wrap_ART_INFORMATION_get(void) {
16056 PyObject *pyobj;
16057
16058 {
16059 #if wxUSE_UNICODE
16060 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16061 #else
16062 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16063 #endif
16064 }
16065 return pyobj;
16066 }
16067
16068
16069 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16070 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16071 return 1;
16072 }
16073
16074
16075 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16076 PyObject *pyobj;
16077
16078 {
16079 #if wxUSE_UNICODE
16080 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16081 #else
16082 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16083 #endif
16084 }
16085 return pyobj;
16086 }
16087
16088
16089 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16090 PyObject *resultobj;
16091 wxPyArtProvider *result;
16092 char *kwnames[] = {
16093 NULL
16094 };
16095
16096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16097 {
16098 if (!wxPyCheckForApp()) SWIG_fail;
16099 PyThreadState* __tstate = wxPyBeginAllowThreads();
16100 result = (wxPyArtProvider *)new wxPyArtProvider();
16101
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16106 return resultobj;
16107 fail:
16108 return NULL;
16109 }
16110
16111
16112 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16113 PyObject *resultobj;
16114 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16115 PyObject *arg2 = (PyObject *) 0 ;
16116 PyObject *arg3 = (PyObject *) 0 ;
16117 PyObject * obj0 = 0 ;
16118 PyObject * obj1 = 0 ;
16119 PyObject * obj2 = 0 ;
16120 char *kwnames[] = {
16121 (char *) "self",(char *) "self",(char *) "_class", NULL
16122 };
16123
16124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16126 if (SWIG_arg_fail(1)) SWIG_fail;
16127 arg2 = obj1;
16128 arg3 = obj2;
16129 {
16130 PyThreadState* __tstate = wxPyBeginAllowThreads();
16131 (arg1)->_setCallbackInfo(arg2,arg3);
16132
16133 wxPyEndAllowThreads(__tstate);
16134 if (PyErr_Occurred()) SWIG_fail;
16135 }
16136 Py_INCREF(Py_None); resultobj = Py_None;
16137 return resultobj;
16138 fail:
16139 return NULL;
16140 }
16141
16142
16143 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16144 PyObject *resultobj;
16145 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16146 PyObject * obj0 = 0 ;
16147 char *kwnames[] = {
16148 (char *) "provider", NULL
16149 };
16150
16151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16153 if (SWIG_arg_fail(1)) SWIG_fail;
16154 {
16155 PyThreadState* __tstate = wxPyBeginAllowThreads();
16156 wxPyArtProvider::PushProvider(arg1);
16157
16158 wxPyEndAllowThreads(__tstate);
16159 if (PyErr_Occurred()) SWIG_fail;
16160 }
16161 Py_INCREF(Py_None); resultobj = Py_None;
16162 return resultobj;
16163 fail:
16164 return NULL;
16165 }
16166
16167
16168 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16169 PyObject *resultobj;
16170 bool result;
16171 char *kwnames[] = {
16172 NULL
16173 };
16174
16175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16176 {
16177 PyThreadState* __tstate = wxPyBeginAllowThreads();
16178 result = (bool)wxPyArtProvider::PopProvider();
16179
16180 wxPyEndAllowThreads(__tstate);
16181 if (PyErr_Occurred()) SWIG_fail;
16182 }
16183 {
16184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16185 }
16186 return resultobj;
16187 fail:
16188 return NULL;
16189 }
16190
16191
16192 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16193 PyObject *resultobj;
16194 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16195 bool result;
16196 PyObject * obj0 = 0 ;
16197 char *kwnames[] = {
16198 (char *) "provider", NULL
16199 };
16200
16201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16203 if (SWIG_arg_fail(1)) SWIG_fail;
16204 {
16205 PyThreadState* __tstate = wxPyBeginAllowThreads();
16206 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16207
16208 wxPyEndAllowThreads(__tstate);
16209 if (PyErr_Occurred()) SWIG_fail;
16210 }
16211 {
16212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16213 }
16214 return resultobj;
16215 fail:
16216 return NULL;
16217 }
16218
16219
16220 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16221 PyObject *resultobj;
16222 wxString *arg1 = 0 ;
16223 wxString const &arg2_defvalue = wxPyART_OTHER ;
16224 wxString *arg2 = (wxString *) &arg2_defvalue ;
16225 wxSize const &arg3_defvalue = wxDefaultSize ;
16226 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16227 wxBitmap result;
16228 bool temp1 = false ;
16229 bool temp2 = false ;
16230 wxSize temp3 ;
16231 PyObject * obj0 = 0 ;
16232 PyObject * obj1 = 0 ;
16233 PyObject * obj2 = 0 ;
16234 char *kwnames[] = {
16235 (char *) "id",(char *) "client",(char *) "size", NULL
16236 };
16237
16238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16239 {
16240 arg1 = wxString_in_helper(obj0);
16241 if (arg1 == NULL) SWIG_fail;
16242 temp1 = true;
16243 }
16244 if (obj1) {
16245 {
16246 arg2 = wxString_in_helper(obj1);
16247 if (arg2 == NULL) SWIG_fail;
16248 temp2 = true;
16249 }
16250 }
16251 if (obj2) {
16252 {
16253 arg3 = &temp3;
16254 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16255 }
16256 }
16257 {
16258 if (!wxPyCheckForApp()) SWIG_fail;
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16261
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 {
16266 wxBitmap * resultptr;
16267 resultptr = new wxBitmap((wxBitmap &)(result));
16268 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16269 }
16270 {
16271 if (temp1)
16272 delete arg1;
16273 }
16274 {
16275 if (temp2)
16276 delete arg2;
16277 }
16278 return resultobj;
16279 fail:
16280 {
16281 if (temp1)
16282 delete arg1;
16283 }
16284 {
16285 if (temp2)
16286 delete arg2;
16287 }
16288 return NULL;
16289 }
16290
16291
16292 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16293 PyObject *resultobj;
16294 wxString *arg1 = 0 ;
16295 wxString const &arg2_defvalue = wxPyART_OTHER ;
16296 wxString *arg2 = (wxString *) &arg2_defvalue ;
16297 wxSize const &arg3_defvalue = wxDefaultSize ;
16298 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16299 wxIcon result;
16300 bool temp1 = false ;
16301 bool temp2 = false ;
16302 wxSize temp3 ;
16303 PyObject * obj0 = 0 ;
16304 PyObject * obj1 = 0 ;
16305 PyObject * obj2 = 0 ;
16306 char *kwnames[] = {
16307 (char *) "id",(char *) "client",(char *) "size", NULL
16308 };
16309
16310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16311 {
16312 arg1 = wxString_in_helper(obj0);
16313 if (arg1 == NULL) SWIG_fail;
16314 temp1 = true;
16315 }
16316 if (obj1) {
16317 {
16318 arg2 = wxString_in_helper(obj1);
16319 if (arg2 == NULL) SWIG_fail;
16320 temp2 = true;
16321 }
16322 }
16323 if (obj2) {
16324 {
16325 arg3 = &temp3;
16326 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16327 }
16328 }
16329 {
16330 if (!wxPyCheckForApp()) SWIG_fail;
16331 PyThreadState* __tstate = wxPyBeginAllowThreads();
16332 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16333
16334 wxPyEndAllowThreads(__tstate);
16335 if (PyErr_Occurred()) SWIG_fail;
16336 }
16337 {
16338 wxIcon * resultptr;
16339 resultptr = new wxIcon((wxIcon &)(result));
16340 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16341 }
16342 {
16343 if (temp1)
16344 delete arg1;
16345 }
16346 {
16347 if (temp2)
16348 delete arg2;
16349 }
16350 return resultobj;
16351 fail:
16352 {
16353 if (temp1)
16354 delete arg1;
16355 }
16356 {
16357 if (temp2)
16358 delete arg2;
16359 }
16360 return NULL;
16361 }
16362
16363
16364 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16365 PyObject *resultobj;
16366 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16367 PyObject * obj0 = 0 ;
16368 char *kwnames[] = {
16369 (char *) "self", NULL
16370 };
16371
16372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16374 if (SWIG_arg_fail(1)) SWIG_fail;
16375 {
16376 PyThreadState* __tstate = wxPyBeginAllowThreads();
16377 wxPyArtProvider_Destroy(arg1);
16378
16379 wxPyEndAllowThreads(__tstate);
16380 if (PyErr_Occurred()) SWIG_fail;
16381 }
16382 Py_INCREF(Py_None); resultobj = Py_None;
16383 return resultobj;
16384 fail:
16385 return NULL;
16386 }
16387
16388
16389 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16390 PyObject *obj;
16391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16392 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16393 Py_INCREF(obj);
16394 return Py_BuildValue((char *)"");
16395 }
16396 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16397 PyObject *resultobj;
16398 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16399 PyObject * obj0 = 0 ;
16400 char *kwnames[] = {
16401 (char *) "self", NULL
16402 };
16403
16404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16406 if (SWIG_arg_fail(1)) SWIG_fail;
16407 {
16408 PyThreadState* __tstate = wxPyBeginAllowThreads();
16409 delete arg1;
16410
16411 wxPyEndAllowThreads(__tstate);
16412 if (PyErr_Occurred()) SWIG_fail;
16413 }
16414 Py_INCREF(Py_None); resultobj = Py_None;
16415 return resultobj;
16416 fail:
16417 return NULL;
16418 }
16419
16420
16421 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj;
16423 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16424 wxConfigBase *result;
16425 PyObject * obj0 = 0 ;
16426 char *kwnames[] = {
16427 (char *) "config", NULL
16428 };
16429
16430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16432 if (SWIG_arg_fail(1)) SWIG_fail;
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16436
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16441 return resultobj;
16442 fail:
16443 return NULL;
16444 }
16445
16446
16447 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16448 PyObject *resultobj;
16449 bool arg1 = (bool) true ;
16450 wxConfigBase *result;
16451 PyObject * obj0 = 0 ;
16452 char *kwnames[] = {
16453 (char *) "createOnDemand", NULL
16454 };
16455
16456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16457 if (obj0) {
16458 {
16459 arg1 = (bool)(SWIG_As_bool(obj0));
16460 if (SWIG_arg_fail(1)) SWIG_fail;
16461 }
16462 }
16463 {
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16466
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16478 PyObject *resultobj;
16479 wxConfigBase *result;
16480 char *kwnames[] = {
16481 NULL
16482 };
16483
16484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16485 {
16486 PyThreadState* __tstate = wxPyBeginAllowThreads();
16487 result = (wxConfigBase *)wxConfigBase::Create();
16488
16489 wxPyEndAllowThreads(__tstate);
16490 if (PyErr_Occurred()) SWIG_fail;
16491 }
16492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16493 return resultobj;
16494 fail:
16495 return NULL;
16496 }
16497
16498
16499 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16500 PyObject *resultobj;
16501 char *kwnames[] = {
16502 NULL
16503 };
16504
16505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16506 {
16507 PyThreadState* __tstate = wxPyBeginAllowThreads();
16508 wxConfigBase::DontCreateOnDemand();
16509
16510 wxPyEndAllowThreads(__tstate);
16511 if (PyErr_Occurred()) SWIG_fail;
16512 }
16513 Py_INCREF(Py_None); resultobj = Py_None;
16514 return resultobj;
16515 fail:
16516 return NULL;
16517 }
16518
16519
16520 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16521 PyObject *resultobj;
16522 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16523 wxString *arg2 = 0 ;
16524 bool temp2 = false ;
16525 PyObject * obj0 = 0 ;
16526 PyObject * obj1 = 0 ;
16527 char *kwnames[] = {
16528 (char *) "self",(char *) "path", NULL
16529 };
16530
16531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16533 if (SWIG_arg_fail(1)) SWIG_fail;
16534 {
16535 arg2 = wxString_in_helper(obj1);
16536 if (arg2 == NULL) SWIG_fail;
16537 temp2 = true;
16538 }
16539 {
16540 PyThreadState* __tstate = wxPyBeginAllowThreads();
16541 (arg1)->SetPath((wxString const &)*arg2);
16542
16543 wxPyEndAllowThreads(__tstate);
16544 if (PyErr_Occurred()) SWIG_fail;
16545 }
16546 Py_INCREF(Py_None); resultobj = Py_None;
16547 {
16548 if (temp2)
16549 delete arg2;
16550 }
16551 return resultobj;
16552 fail:
16553 {
16554 if (temp2)
16555 delete arg2;
16556 }
16557 return NULL;
16558 }
16559
16560
16561 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16562 PyObject *resultobj;
16563 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16564 wxString *result;
16565 PyObject * obj0 = 0 ;
16566 char *kwnames[] = {
16567 (char *) "self", NULL
16568 };
16569
16570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16572 if (SWIG_arg_fail(1)) SWIG_fail;
16573 {
16574 PyThreadState* __tstate = wxPyBeginAllowThreads();
16575 {
16576 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16577 result = (wxString *) &_result_ref;
16578 }
16579
16580 wxPyEndAllowThreads(__tstate);
16581 if (PyErr_Occurred()) SWIG_fail;
16582 }
16583 {
16584 #if wxUSE_UNICODE
16585 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16586 #else
16587 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16588 #endif
16589 }
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj;
16598 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16599 PyObject *result;
16600 PyObject * obj0 = 0 ;
16601 char *kwnames[] = {
16602 (char *) "self", NULL
16603 };
16604
16605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16607 if (SWIG_arg_fail(1)) SWIG_fail;
16608 {
16609 PyThreadState* __tstate = wxPyBeginAllowThreads();
16610 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16611
16612 wxPyEndAllowThreads(__tstate);
16613 if (PyErr_Occurred()) SWIG_fail;
16614 }
16615 resultobj = result;
16616 return resultobj;
16617 fail:
16618 return NULL;
16619 }
16620
16621
16622 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16623 PyObject *resultobj;
16624 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16625 long arg2 ;
16626 PyObject *result;
16627 PyObject * obj0 = 0 ;
16628 PyObject * obj1 = 0 ;
16629 char *kwnames[] = {
16630 (char *) "self",(char *) "index", NULL
16631 };
16632
16633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16635 if (SWIG_arg_fail(1)) SWIG_fail;
16636 {
16637 arg2 = (long)(SWIG_As_long(obj1));
16638 if (SWIG_arg_fail(2)) SWIG_fail;
16639 }
16640 {
16641 PyThreadState* __tstate = wxPyBeginAllowThreads();
16642 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16643
16644 wxPyEndAllowThreads(__tstate);
16645 if (PyErr_Occurred()) SWIG_fail;
16646 }
16647 resultobj = result;
16648 return resultobj;
16649 fail:
16650 return NULL;
16651 }
16652
16653
16654 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16655 PyObject *resultobj;
16656 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16657 PyObject *result;
16658 PyObject * obj0 = 0 ;
16659 char *kwnames[] = {
16660 (char *) "self", NULL
16661 };
16662
16663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16665 if (SWIG_arg_fail(1)) SWIG_fail;
16666 {
16667 PyThreadState* __tstate = wxPyBeginAllowThreads();
16668 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16669
16670 wxPyEndAllowThreads(__tstate);
16671 if (PyErr_Occurred()) SWIG_fail;
16672 }
16673 resultobj = result;
16674 return resultobj;
16675 fail:
16676 return NULL;
16677 }
16678
16679
16680 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16681 PyObject *resultobj;
16682 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16683 long arg2 ;
16684 PyObject *result;
16685 PyObject * obj0 = 0 ;
16686 PyObject * obj1 = 0 ;
16687 char *kwnames[] = {
16688 (char *) "self",(char *) "index", NULL
16689 };
16690
16691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16693 if (SWIG_arg_fail(1)) SWIG_fail;
16694 {
16695 arg2 = (long)(SWIG_As_long(obj1));
16696 if (SWIG_arg_fail(2)) SWIG_fail;
16697 }
16698 {
16699 PyThreadState* __tstate = wxPyBeginAllowThreads();
16700 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16701
16702 wxPyEndAllowThreads(__tstate);
16703 if (PyErr_Occurred()) SWIG_fail;
16704 }
16705 resultobj = result;
16706 return resultobj;
16707 fail:
16708 return NULL;
16709 }
16710
16711
16712 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16713 PyObject *resultobj;
16714 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16715 bool arg2 = (bool) false ;
16716 size_t result;
16717 PyObject * obj0 = 0 ;
16718 PyObject * obj1 = 0 ;
16719 char *kwnames[] = {
16720 (char *) "self",(char *) "recursive", NULL
16721 };
16722
16723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16725 if (SWIG_arg_fail(1)) SWIG_fail;
16726 if (obj1) {
16727 {
16728 arg2 = (bool)(SWIG_As_bool(obj1));
16729 if (SWIG_arg_fail(2)) SWIG_fail;
16730 }
16731 }
16732 {
16733 PyThreadState* __tstate = wxPyBeginAllowThreads();
16734 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16735
16736 wxPyEndAllowThreads(__tstate);
16737 if (PyErr_Occurred()) SWIG_fail;
16738 }
16739 {
16740 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16741 }
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj;
16750 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16751 bool arg2 = (bool) false ;
16752 size_t result;
16753 PyObject * obj0 = 0 ;
16754 PyObject * obj1 = 0 ;
16755 char *kwnames[] = {
16756 (char *) "self",(char *) "recursive", NULL
16757 };
16758
16759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
16760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16761 if (SWIG_arg_fail(1)) SWIG_fail;
16762 if (obj1) {
16763 {
16764 arg2 = (bool)(SWIG_As_bool(obj1));
16765 if (SWIG_arg_fail(2)) SWIG_fail;
16766 }
16767 }
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
16771
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 {
16776 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16777 }
16778 return resultobj;
16779 fail:
16780 return NULL;
16781 }
16782
16783
16784 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16785 PyObject *resultobj;
16786 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16787 wxString *arg2 = 0 ;
16788 bool result;
16789 bool temp2 = false ;
16790 PyObject * obj0 = 0 ;
16791 PyObject * obj1 = 0 ;
16792 char *kwnames[] = {
16793 (char *) "self",(char *) "name", NULL
16794 };
16795
16796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
16797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16798 if (SWIG_arg_fail(1)) SWIG_fail;
16799 {
16800 arg2 = wxString_in_helper(obj1);
16801 if (arg2 == NULL) SWIG_fail;
16802 temp2 = true;
16803 }
16804 {
16805 PyThreadState* __tstate = wxPyBeginAllowThreads();
16806 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
16807
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 {
16812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16813 }
16814 {
16815 if (temp2)
16816 delete arg2;
16817 }
16818 return resultobj;
16819 fail:
16820 {
16821 if (temp2)
16822 delete arg2;
16823 }
16824 return NULL;
16825 }
16826
16827
16828 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16829 PyObject *resultobj;
16830 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16831 wxString *arg2 = 0 ;
16832 bool result;
16833 bool temp2 = false ;
16834 PyObject * obj0 = 0 ;
16835 PyObject * obj1 = 0 ;
16836 char *kwnames[] = {
16837 (char *) "self",(char *) "name", NULL
16838 };
16839
16840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
16841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16842 if (SWIG_arg_fail(1)) SWIG_fail;
16843 {
16844 arg2 = wxString_in_helper(obj1);
16845 if (arg2 == NULL) SWIG_fail;
16846 temp2 = true;
16847 }
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 {
16856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16857 }
16858 {
16859 if (temp2)
16860 delete arg2;
16861 }
16862 return resultobj;
16863 fail:
16864 {
16865 if (temp2)
16866 delete arg2;
16867 }
16868 return NULL;
16869 }
16870
16871
16872 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
16873 PyObject *resultobj;
16874 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16875 wxString *arg2 = 0 ;
16876 bool result;
16877 bool temp2 = false ;
16878 PyObject * obj0 = 0 ;
16879 PyObject * obj1 = 0 ;
16880 char *kwnames[] = {
16881 (char *) "self",(char *) "name", NULL
16882 };
16883
16884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
16885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16886 if (SWIG_arg_fail(1)) SWIG_fail;
16887 {
16888 arg2 = wxString_in_helper(obj1);
16889 if (arg2 == NULL) SWIG_fail;
16890 temp2 = true;
16891 }
16892 {
16893 PyThreadState* __tstate = wxPyBeginAllowThreads();
16894 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
16895
16896 wxPyEndAllowThreads(__tstate);
16897 if (PyErr_Occurred()) SWIG_fail;
16898 }
16899 {
16900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16901 }
16902 {
16903 if (temp2)
16904 delete arg2;
16905 }
16906 return resultobj;
16907 fail:
16908 {
16909 if (temp2)
16910 delete arg2;
16911 }
16912 return NULL;
16913 }
16914
16915
16916 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
16917 PyObject *resultobj;
16918 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16919 wxString *arg2 = 0 ;
16920 wxConfigBase::EntryType result;
16921 bool temp2 = false ;
16922 PyObject * obj0 = 0 ;
16923 PyObject * obj1 = 0 ;
16924 char *kwnames[] = {
16925 (char *) "self",(char *) "name", NULL
16926 };
16927
16928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
16929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16930 if (SWIG_arg_fail(1)) SWIG_fail;
16931 {
16932 arg2 = wxString_in_helper(obj1);
16933 if (arg2 == NULL) SWIG_fail;
16934 temp2 = true;
16935 }
16936 {
16937 PyThreadState* __tstate = wxPyBeginAllowThreads();
16938 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
16939
16940 wxPyEndAllowThreads(__tstate);
16941 if (PyErr_Occurred()) SWIG_fail;
16942 }
16943 resultobj = SWIG_From_int((result));
16944 {
16945 if (temp2)
16946 delete arg2;
16947 }
16948 return resultobj;
16949 fail:
16950 {
16951 if (temp2)
16952 delete arg2;
16953 }
16954 return NULL;
16955 }
16956
16957
16958 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
16959 PyObject *resultobj;
16960 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16961 wxString *arg2 = 0 ;
16962 wxString const &arg3_defvalue = wxPyEmptyString ;
16963 wxString *arg3 = (wxString *) &arg3_defvalue ;
16964 wxString result;
16965 bool temp2 = false ;
16966 bool temp3 = false ;
16967 PyObject * obj0 = 0 ;
16968 PyObject * obj1 = 0 ;
16969 PyObject * obj2 = 0 ;
16970 char *kwnames[] = {
16971 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
16972 };
16973
16974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
16975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16976 if (SWIG_arg_fail(1)) SWIG_fail;
16977 {
16978 arg2 = wxString_in_helper(obj1);
16979 if (arg2 == NULL) SWIG_fail;
16980 temp2 = true;
16981 }
16982 if (obj2) {
16983 {
16984 arg3 = wxString_in_helper(obj2);
16985 if (arg3 == NULL) SWIG_fail;
16986 temp3 = true;
16987 }
16988 }
16989 {
16990 PyThreadState* __tstate = wxPyBeginAllowThreads();
16991 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
16992
16993 wxPyEndAllowThreads(__tstate);
16994 if (PyErr_Occurred()) SWIG_fail;
16995 }
16996 {
16997 #if wxUSE_UNICODE
16998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16999 #else
17000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17001 #endif
17002 }
17003 {
17004 if (temp2)
17005 delete arg2;
17006 }
17007 {
17008 if (temp3)
17009 delete arg3;
17010 }
17011 return resultobj;
17012 fail:
17013 {
17014 if (temp2)
17015 delete arg2;
17016 }
17017 {
17018 if (temp3)
17019 delete arg3;
17020 }
17021 return NULL;
17022 }
17023
17024
17025 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17026 PyObject *resultobj;
17027 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17028 wxString *arg2 = 0 ;
17029 long arg3 = (long) 0 ;
17030 long result;
17031 bool temp2 = false ;
17032 PyObject * obj0 = 0 ;
17033 PyObject * obj1 = 0 ;
17034 PyObject * obj2 = 0 ;
17035 char *kwnames[] = {
17036 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17037 };
17038
17039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17041 if (SWIG_arg_fail(1)) SWIG_fail;
17042 {
17043 arg2 = wxString_in_helper(obj1);
17044 if (arg2 == NULL) SWIG_fail;
17045 temp2 = true;
17046 }
17047 if (obj2) {
17048 {
17049 arg3 = (long)(SWIG_As_long(obj2));
17050 if (SWIG_arg_fail(3)) SWIG_fail;
17051 }
17052 }
17053 {
17054 PyThreadState* __tstate = wxPyBeginAllowThreads();
17055 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17056
17057 wxPyEndAllowThreads(__tstate);
17058 if (PyErr_Occurred()) SWIG_fail;
17059 }
17060 {
17061 resultobj = SWIG_From_long((long)(result));
17062 }
17063 {
17064 if (temp2)
17065 delete arg2;
17066 }
17067 return resultobj;
17068 fail:
17069 {
17070 if (temp2)
17071 delete arg2;
17072 }
17073 return NULL;
17074 }
17075
17076
17077 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17078 PyObject *resultobj;
17079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17080 wxString *arg2 = 0 ;
17081 double arg3 = (double) 0.0 ;
17082 double result;
17083 bool temp2 = false ;
17084 PyObject * obj0 = 0 ;
17085 PyObject * obj1 = 0 ;
17086 PyObject * obj2 = 0 ;
17087 char *kwnames[] = {
17088 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17089 };
17090
17091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17093 if (SWIG_arg_fail(1)) SWIG_fail;
17094 {
17095 arg2 = wxString_in_helper(obj1);
17096 if (arg2 == NULL) SWIG_fail;
17097 temp2 = true;
17098 }
17099 if (obj2) {
17100 {
17101 arg3 = (double)(SWIG_As_double(obj2));
17102 if (SWIG_arg_fail(3)) SWIG_fail;
17103 }
17104 }
17105 {
17106 PyThreadState* __tstate = wxPyBeginAllowThreads();
17107 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17108
17109 wxPyEndAllowThreads(__tstate);
17110 if (PyErr_Occurred()) SWIG_fail;
17111 }
17112 {
17113 resultobj = SWIG_From_double((double)(result));
17114 }
17115 {
17116 if (temp2)
17117 delete arg2;
17118 }
17119 return resultobj;
17120 fail:
17121 {
17122 if (temp2)
17123 delete arg2;
17124 }
17125 return NULL;
17126 }
17127
17128
17129 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17130 PyObject *resultobj;
17131 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17132 wxString *arg2 = 0 ;
17133 bool arg3 = (bool) false ;
17134 bool result;
17135 bool temp2 = false ;
17136 PyObject * obj0 = 0 ;
17137 PyObject * obj1 = 0 ;
17138 PyObject * obj2 = 0 ;
17139 char *kwnames[] = {
17140 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17141 };
17142
17143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17145 if (SWIG_arg_fail(1)) SWIG_fail;
17146 {
17147 arg2 = wxString_in_helper(obj1);
17148 if (arg2 == NULL) SWIG_fail;
17149 temp2 = true;
17150 }
17151 if (obj2) {
17152 {
17153 arg3 = (bool)(SWIG_As_bool(obj2));
17154 if (SWIG_arg_fail(3)) SWIG_fail;
17155 }
17156 }
17157 {
17158 PyThreadState* __tstate = wxPyBeginAllowThreads();
17159 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17160
17161 wxPyEndAllowThreads(__tstate);
17162 if (PyErr_Occurred()) SWIG_fail;
17163 }
17164 {
17165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17166 }
17167 {
17168 if (temp2)
17169 delete arg2;
17170 }
17171 return resultobj;
17172 fail:
17173 {
17174 if (temp2)
17175 delete arg2;
17176 }
17177 return NULL;
17178 }
17179
17180
17181 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17182 PyObject *resultobj;
17183 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17184 wxString *arg2 = 0 ;
17185 wxString *arg3 = 0 ;
17186 bool result;
17187 bool temp2 = false ;
17188 bool temp3 = false ;
17189 PyObject * obj0 = 0 ;
17190 PyObject * obj1 = 0 ;
17191 PyObject * obj2 = 0 ;
17192 char *kwnames[] = {
17193 (char *) "self",(char *) "key",(char *) "value", NULL
17194 };
17195
17196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17198 if (SWIG_arg_fail(1)) SWIG_fail;
17199 {
17200 arg2 = wxString_in_helper(obj1);
17201 if (arg2 == NULL) SWIG_fail;
17202 temp2 = true;
17203 }
17204 {
17205 arg3 = wxString_in_helper(obj2);
17206 if (arg3 == NULL) SWIG_fail;
17207 temp3 = true;
17208 }
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17212
17213 wxPyEndAllowThreads(__tstate);
17214 if (PyErr_Occurred()) SWIG_fail;
17215 }
17216 {
17217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17218 }
17219 {
17220 if (temp2)
17221 delete arg2;
17222 }
17223 {
17224 if (temp3)
17225 delete arg3;
17226 }
17227 return resultobj;
17228 fail:
17229 {
17230 if (temp2)
17231 delete arg2;
17232 }
17233 {
17234 if (temp3)
17235 delete arg3;
17236 }
17237 return NULL;
17238 }
17239
17240
17241 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17242 PyObject *resultobj;
17243 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17244 wxString *arg2 = 0 ;
17245 long arg3 ;
17246 bool result;
17247 bool temp2 = false ;
17248 PyObject * obj0 = 0 ;
17249 PyObject * obj1 = 0 ;
17250 PyObject * obj2 = 0 ;
17251 char *kwnames[] = {
17252 (char *) "self",(char *) "key",(char *) "value", NULL
17253 };
17254
17255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17257 if (SWIG_arg_fail(1)) SWIG_fail;
17258 {
17259 arg2 = wxString_in_helper(obj1);
17260 if (arg2 == NULL) SWIG_fail;
17261 temp2 = true;
17262 }
17263 {
17264 arg3 = (long)(SWIG_As_long(obj2));
17265 if (SWIG_arg_fail(3)) SWIG_fail;
17266 }
17267 {
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17270
17271 wxPyEndAllowThreads(__tstate);
17272 if (PyErr_Occurred()) SWIG_fail;
17273 }
17274 {
17275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17276 }
17277 {
17278 if (temp2)
17279 delete arg2;
17280 }
17281 return resultobj;
17282 fail:
17283 {
17284 if (temp2)
17285 delete arg2;
17286 }
17287 return NULL;
17288 }
17289
17290
17291 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17292 PyObject *resultobj;
17293 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17294 wxString *arg2 = 0 ;
17295 double arg3 ;
17296 bool result;
17297 bool temp2 = false ;
17298 PyObject * obj0 = 0 ;
17299 PyObject * obj1 = 0 ;
17300 PyObject * obj2 = 0 ;
17301 char *kwnames[] = {
17302 (char *) "self",(char *) "key",(char *) "value", NULL
17303 };
17304
17305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17307 if (SWIG_arg_fail(1)) SWIG_fail;
17308 {
17309 arg2 = wxString_in_helper(obj1);
17310 if (arg2 == NULL) SWIG_fail;
17311 temp2 = true;
17312 }
17313 {
17314 arg3 = (double)(SWIG_As_double(obj2));
17315 if (SWIG_arg_fail(3)) SWIG_fail;
17316 }
17317 {
17318 PyThreadState* __tstate = wxPyBeginAllowThreads();
17319 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17320
17321 wxPyEndAllowThreads(__tstate);
17322 if (PyErr_Occurred()) SWIG_fail;
17323 }
17324 {
17325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17326 }
17327 {
17328 if (temp2)
17329 delete arg2;
17330 }
17331 return resultobj;
17332 fail:
17333 {
17334 if (temp2)
17335 delete arg2;
17336 }
17337 return NULL;
17338 }
17339
17340
17341 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17342 PyObject *resultobj;
17343 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17344 wxString *arg2 = 0 ;
17345 bool arg3 ;
17346 bool result;
17347 bool temp2 = false ;
17348 PyObject * obj0 = 0 ;
17349 PyObject * obj1 = 0 ;
17350 PyObject * obj2 = 0 ;
17351 char *kwnames[] = {
17352 (char *) "self",(char *) "key",(char *) "value", NULL
17353 };
17354
17355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17357 if (SWIG_arg_fail(1)) SWIG_fail;
17358 {
17359 arg2 = wxString_in_helper(obj1);
17360 if (arg2 == NULL) SWIG_fail;
17361 temp2 = true;
17362 }
17363 {
17364 arg3 = (bool)(SWIG_As_bool(obj2));
17365 if (SWIG_arg_fail(3)) SWIG_fail;
17366 }
17367 {
17368 PyThreadState* __tstate = wxPyBeginAllowThreads();
17369 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17370
17371 wxPyEndAllowThreads(__tstate);
17372 if (PyErr_Occurred()) SWIG_fail;
17373 }
17374 {
17375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17376 }
17377 {
17378 if (temp2)
17379 delete arg2;
17380 }
17381 return resultobj;
17382 fail:
17383 {
17384 if (temp2)
17385 delete arg2;
17386 }
17387 return NULL;
17388 }
17389
17390
17391 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17392 PyObject *resultobj;
17393 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17394 bool arg2 = (bool) false ;
17395 bool result;
17396 PyObject * obj0 = 0 ;
17397 PyObject * obj1 = 0 ;
17398 char *kwnames[] = {
17399 (char *) "self",(char *) "currentOnly", NULL
17400 };
17401
17402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17404 if (SWIG_arg_fail(1)) SWIG_fail;
17405 if (obj1) {
17406 {
17407 arg2 = (bool)(SWIG_As_bool(obj1));
17408 if (SWIG_arg_fail(2)) SWIG_fail;
17409 }
17410 }
17411 {
17412 PyThreadState* __tstate = wxPyBeginAllowThreads();
17413 result = (bool)(arg1)->Flush(arg2);
17414
17415 wxPyEndAllowThreads(__tstate);
17416 if (PyErr_Occurred()) SWIG_fail;
17417 }
17418 {
17419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17420 }
17421 return resultobj;
17422 fail:
17423 return NULL;
17424 }
17425
17426
17427 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17428 PyObject *resultobj;
17429 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17430 wxString *arg2 = 0 ;
17431 wxString *arg3 = 0 ;
17432 bool result;
17433 bool temp2 = false ;
17434 bool temp3 = false ;
17435 PyObject * obj0 = 0 ;
17436 PyObject * obj1 = 0 ;
17437 PyObject * obj2 = 0 ;
17438 char *kwnames[] = {
17439 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17440 };
17441
17442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17444 if (SWIG_arg_fail(1)) SWIG_fail;
17445 {
17446 arg2 = wxString_in_helper(obj1);
17447 if (arg2 == NULL) SWIG_fail;
17448 temp2 = true;
17449 }
17450 {
17451 arg3 = wxString_in_helper(obj2);
17452 if (arg3 == NULL) SWIG_fail;
17453 temp3 = true;
17454 }
17455 {
17456 PyThreadState* __tstate = wxPyBeginAllowThreads();
17457 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17458
17459 wxPyEndAllowThreads(__tstate);
17460 if (PyErr_Occurred()) SWIG_fail;
17461 }
17462 {
17463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17464 }
17465 {
17466 if (temp2)
17467 delete arg2;
17468 }
17469 {
17470 if (temp3)
17471 delete arg3;
17472 }
17473 return resultobj;
17474 fail:
17475 {
17476 if (temp2)
17477 delete arg2;
17478 }
17479 {
17480 if (temp3)
17481 delete arg3;
17482 }
17483 return NULL;
17484 }
17485
17486
17487 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17488 PyObject *resultobj;
17489 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17490 wxString *arg2 = 0 ;
17491 wxString *arg3 = 0 ;
17492 bool result;
17493 bool temp2 = false ;
17494 bool temp3 = false ;
17495 PyObject * obj0 = 0 ;
17496 PyObject * obj1 = 0 ;
17497 PyObject * obj2 = 0 ;
17498 char *kwnames[] = {
17499 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17500 };
17501
17502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17504 if (SWIG_arg_fail(1)) SWIG_fail;
17505 {
17506 arg2 = wxString_in_helper(obj1);
17507 if (arg2 == NULL) SWIG_fail;
17508 temp2 = true;
17509 }
17510 {
17511 arg3 = wxString_in_helper(obj2);
17512 if (arg3 == NULL) SWIG_fail;
17513 temp3 = true;
17514 }
17515 {
17516 PyThreadState* __tstate = wxPyBeginAllowThreads();
17517 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17518
17519 wxPyEndAllowThreads(__tstate);
17520 if (PyErr_Occurred()) SWIG_fail;
17521 }
17522 {
17523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17524 }
17525 {
17526 if (temp2)
17527 delete arg2;
17528 }
17529 {
17530 if (temp3)
17531 delete arg3;
17532 }
17533 return resultobj;
17534 fail:
17535 {
17536 if (temp2)
17537 delete arg2;
17538 }
17539 {
17540 if (temp3)
17541 delete arg3;
17542 }
17543 return NULL;
17544 }
17545
17546
17547 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17548 PyObject *resultobj;
17549 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17550 wxString *arg2 = 0 ;
17551 bool arg3 = (bool) true ;
17552 bool result;
17553 bool temp2 = false ;
17554 PyObject * obj0 = 0 ;
17555 PyObject * obj1 = 0 ;
17556 PyObject * obj2 = 0 ;
17557 char *kwnames[] = {
17558 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17559 };
17560
17561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17563 if (SWIG_arg_fail(1)) SWIG_fail;
17564 {
17565 arg2 = wxString_in_helper(obj1);
17566 if (arg2 == NULL) SWIG_fail;
17567 temp2 = true;
17568 }
17569 if (obj2) {
17570 {
17571 arg3 = (bool)(SWIG_As_bool(obj2));
17572 if (SWIG_arg_fail(3)) SWIG_fail;
17573 }
17574 }
17575 {
17576 PyThreadState* __tstate = wxPyBeginAllowThreads();
17577 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17578
17579 wxPyEndAllowThreads(__tstate);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 }
17582 {
17583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17584 }
17585 {
17586 if (temp2)
17587 delete arg2;
17588 }
17589 return resultobj;
17590 fail:
17591 {
17592 if (temp2)
17593 delete arg2;
17594 }
17595 return NULL;
17596 }
17597
17598
17599 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj;
17601 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17602 wxString *arg2 = 0 ;
17603 bool result;
17604 bool temp2 = false ;
17605 PyObject * obj0 = 0 ;
17606 PyObject * obj1 = 0 ;
17607 char *kwnames[] = {
17608 (char *) "self",(char *) "key", NULL
17609 };
17610
17611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17613 if (SWIG_arg_fail(1)) SWIG_fail;
17614 {
17615 arg2 = wxString_in_helper(obj1);
17616 if (arg2 == NULL) SWIG_fail;
17617 temp2 = true;
17618 }
17619 {
17620 PyThreadState* __tstate = wxPyBeginAllowThreads();
17621 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17622
17623 wxPyEndAllowThreads(__tstate);
17624 if (PyErr_Occurred()) SWIG_fail;
17625 }
17626 {
17627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17628 }
17629 {
17630 if (temp2)
17631 delete arg2;
17632 }
17633 return resultobj;
17634 fail:
17635 {
17636 if (temp2)
17637 delete arg2;
17638 }
17639 return NULL;
17640 }
17641
17642
17643 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17644 PyObject *resultobj;
17645 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17646 bool result;
17647 PyObject * obj0 = 0 ;
17648 char *kwnames[] = {
17649 (char *) "self", NULL
17650 };
17651
17652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17654 if (SWIG_arg_fail(1)) SWIG_fail;
17655 {
17656 PyThreadState* __tstate = wxPyBeginAllowThreads();
17657 result = (bool)(arg1)->DeleteAll();
17658
17659 wxPyEndAllowThreads(__tstate);
17660 if (PyErr_Occurred()) SWIG_fail;
17661 }
17662 {
17663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17664 }
17665 return resultobj;
17666 fail:
17667 return NULL;
17668 }
17669
17670
17671 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17672 PyObject *resultobj;
17673 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17674 bool arg2 = (bool) true ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 char *kwnames[] = {
17678 (char *) "self",(char *) "doIt", NULL
17679 };
17680
17681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17683 if (SWIG_arg_fail(1)) SWIG_fail;
17684 if (obj1) {
17685 {
17686 arg2 = (bool)(SWIG_As_bool(obj1));
17687 if (SWIG_arg_fail(2)) SWIG_fail;
17688 }
17689 }
17690 {
17691 PyThreadState* __tstate = wxPyBeginAllowThreads();
17692 (arg1)->SetExpandEnvVars(arg2);
17693
17694 wxPyEndAllowThreads(__tstate);
17695 if (PyErr_Occurred()) SWIG_fail;
17696 }
17697 Py_INCREF(Py_None); resultobj = Py_None;
17698 return resultobj;
17699 fail:
17700 return NULL;
17701 }
17702
17703
17704 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17705 PyObject *resultobj;
17706 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17707 bool result;
17708 PyObject * obj0 = 0 ;
17709 char *kwnames[] = {
17710 (char *) "self", NULL
17711 };
17712
17713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17715 if (SWIG_arg_fail(1)) SWIG_fail;
17716 {
17717 PyThreadState* __tstate = wxPyBeginAllowThreads();
17718 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17719
17720 wxPyEndAllowThreads(__tstate);
17721 if (PyErr_Occurred()) SWIG_fail;
17722 }
17723 {
17724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17725 }
17726 return resultobj;
17727 fail:
17728 return NULL;
17729 }
17730
17731
17732 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17733 PyObject *resultobj;
17734 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17735 bool arg2 = (bool) true ;
17736 PyObject * obj0 = 0 ;
17737 PyObject * obj1 = 0 ;
17738 char *kwnames[] = {
17739 (char *) "self",(char *) "doIt", NULL
17740 };
17741
17742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17744 if (SWIG_arg_fail(1)) SWIG_fail;
17745 if (obj1) {
17746 {
17747 arg2 = (bool)(SWIG_As_bool(obj1));
17748 if (SWIG_arg_fail(2)) SWIG_fail;
17749 }
17750 }
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 (arg1)->SetRecordDefaults(arg2);
17754
17755 wxPyEndAllowThreads(__tstate);
17756 if (PyErr_Occurred()) SWIG_fail;
17757 }
17758 Py_INCREF(Py_None); resultobj = Py_None;
17759 return resultobj;
17760 fail:
17761 return NULL;
17762 }
17763
17764
17765 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj;
17767 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17768 bool result;
17769 PyObject * obj0 = 0 ;
17770 char *kwnames[] = {
17771 (char *) "self", NULL
17772 };
17773
17774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
17775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17776 if (SWIG_arg_fail(1)) SWIG_fail;
17777 {
17778 PyThreadState* __tstate = wxPyBeginAllowThreads();
17779 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
17780
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 {
17785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17786 }
17787 return resultobj;
17788 fail:
17789 return NULL;
17790 }
17791
17792
17793 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17794 PyObject *resultobj;
17795 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17796 wxString *arg2 = 0 ;
17797 wxString result;
17798 bool temp2 = false ;
17799 PyObject * obj0 = 0 ;
17800 PyObject * obj1 = 0 ;
17801 char *kwnames[] = {
17802 (char *) "self",(char *) "str", NULL
17803 };
17804
17805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17807 if (SWIG_arg_fail(1)) SWIG_fail;
17808 {
17809 arg2 = wxString_in_helper(obj1);
17810 if (arg2 == NULL) SWIG_fail;
17811 temp2 = true;
17812 }
17813 {
17814 PyThreadState* __tstate = wxPyBeginAllowThreads();
17815 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
17816
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 #if wxUSE_UNICODE
17822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17823 #else
17824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17825 #endif
17826 }
17827 {
17828 if (temp2)
17829 delete arg2;
17830 }
17831 return resultobj;
17832 fail:
17833 {
17834 if (temp2)
17835 delete arg2;
17836 }
17837 return NULL;
17838 }
17839
17840
17841 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17842 PyObject *resultobj;
17843 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17844 wxString result;
17845 PyObject * obj0 = 0 ;
17846 char *kwnames[] = {
17847 (char *) "self", NULL
17848 };
17849
17850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
17851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17852 if (SWIG_arg_fail(1)) SWIG_fail;
17853 {
17854 PyThreadState* __tstate = wxPyBeginAllowThreads();
17855 result = ((wxConfigBase const *)arg1)->GetAppName();
17856
17857 wxPyEndAllowThreads(__tstate);
17858 if (PyErr_Occurred()) SWIG_fail;
17859 }
17860 {
17861 #if wxUSE_UNICODE
17862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17863 #else
17864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17865 #endif
17866 }
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj;
17875 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17876 wxString result;
17877 PyObject * obj0 = 0 ;
17878 char *kwnames[] = {
17879 (char *) "self", NULL
17880 };
17881
17882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
17883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17884 if (SWIG_arg_fail(1)) SWIG_fail;
17885 {
17886 PyThreadState* __tstate = wxPyBeginAllowThreads();
17887 result = ((wxConfigBase const *)arg1)->GetVendorName();
17888
17889 wxPyEndAllowThreads(__tstate);
17890 if (PyErr_Occurred()) SWIG_fail;
17891 }
17892 {
17893 #if wxUSE_UNICODE
17894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17895 #else
17896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17897 #endif
17898 }
17899 return resultobj;
17900 fail:
17901 return NULL;
17902 }
17903
17904
17905 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17906 PyObject *resultobj;
17907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17908 wxString *arg2 = 0 ;
17909 bool temp2 = false ;
17910 PyObject * obj0 = 0 ;
17911 PyObject * obj1 = 0 ;
17912 char *kwnames[] = {
17913 (char *) "self",(char *) "appName", NULL
17914 };
17915
17916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
17917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17918 if (SWIG_arg_fail(1)) SWIG_fail;
17919 {
17920 arg2 = wxString_in_helper(obj1);
17921 if (arg2 == NULL) SWIG_fail;
17922 temp2 = true;
17923 }
17924 {
17925 PyThreadState* __tstate = wxPyBeginAllowThreads();
17926 (arg1)->SetAppName((wxString const &)*arg2);
17927
17928 wxPyEndAllowThreads(__tstate);
17929 if (PyErr_Occurred()) SWIG_fail;
17930 }
17931 Py_INCREF(Py_None); resultobj = Py_None;
17932 {
17933 if (temp2)
17934 delete arg2;
17935 }
17936 return resultobj;
17937 fail:
17938 {
17939 if (temp2)
17940 delete arg2;
17941 }
17942 return NULL;
17943 }
17944
17945
17946 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17947 PyObject *resultobj;
17948 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17949 wxString *arg2 = 0 ;
17950 bool temp2 = false ;
17951 PyObject * obj0 = 0 ;
17952 PyObject * obj1 = 0 ;
17953 char *kwnames[] = {
17954 (char *) "self",(char *) "vendorName", NULL
17955 };
17956
17957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
17958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17959 if (SWIG_arg_fail(1)) SWIG_fail;
17960 {
17961 arg2 = wxString_in_helper(obj1);
17962 if (arg2 == NULL) SWIG_fail;
17963 temp2 = true;
17964 }
17965 {
17966 PyThreadState* __tstate = wxPyBeginAllowThreads();
17967 (arg1)->SetVendorName((wxString const &)*arg2);
17968
17969 wxPyEndAllowThreads(__tstate);
17970 if (PyErr_Occurred()) SWIG_fail;
17971 }
17972 Py_INCREF(Py_None); resultobj = Py_None;
17973 {
17974 if (temp2)
17975 delete arg2;
17976 }
17977 return resultobj;
17978 fail:
17979 {
17980 if (temp2)
17981 delete arg2;
17982 }
17983 return NULL;
17984 }
17985
17986
17987 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
17988 PyObject *resultobj;
17989 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17990 long arg2 ;
17991 PyObject * obj0 = 0 ;
17992 PyObject * obj1 = 0 ;
17993 char *kwnames[] = {
17994 (char *) "self",(char *) "style", NULL
17995 };
17996
17997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
17998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17999 if (SWIG_arg_fail(1)) SWIG_fail;
18000 {
18001 arg2 = (long)(SWIG_As_long(obj1));
18002 if (SWIG_arg_fail(2)) SWIG_fail;
18003 }
18004 {
18005 PyThreadState* __tstate = wxPyBeginAllowThreads();
18006 (arg1)->SetStyle(arg2);
18007
18008 wxPyEndAllowThreads(__tstate);
18009 if (PyErr_Occurred()) SWIG_fail;
18010 }
18011 Py_INCREF(Py_None); resultobj = Py_None;
18012 return resultobj;
18013 fail:
18014 return NULL;
18015 }
18016
18017
18018 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18019 PyObject *resultobj;
18020 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18021 long result;
18022 PyObject * obj0 = 0 ;
18023 char *kwnames[] = {
18024 (char *) "self", NULL
18025 };
18026
18027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18029 if (SWIG_arg_fail(1)) SWIG_fail;
18030 {
18031 PyThreadState* __tstate = wxPyBeginAllowThreads();
18032 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18033
18034 wxPyEndAllowThreads(__tstate);
18035 if (PyErr_Occurred()) SWIG_fail;
18036 }
18037 {
18038 resultobj = SWIG_From_long((long)(result));
18039 }
18040 return resultobj;
18041 fail:
18042 return NULL;
18043 }
18044
18045
18046 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18047 PyObject *obj;
18048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18049 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18050 Py_INCREF(obj);
18051 return Py_BuildValue((char *)"");
18052 }
18053 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18054 PyObject *resultobj;
18055 wxString const &arg1_defvalue = wxPyEmptyString ;
18056 wxString *arg1 = (wxString *) &arg1_defvalue ;
18057 wxString const &arg2_defvalue = wxPyEmptyString ;
18058 wxString *arg2 = (wxString *) &arg2_defvalue ;
18059 wxString const &arg3_defvalue = wxPyEmptyString ;
18060 wxString *arg3 = (wxString *) &arg3_defvalue ;
18061 wxString const &arg4_defvalue = wxPyEmptyString ;
18062 wxString *arg4 = (wxString *) &arg4_defvalue ;
18063 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18064 wxConfig *result;
18065 bool temp1 = false ;
18066 bool temp2 = false ;
18067 bool temp3 = false ;
18068 bool temp4 = false ;
18069 PyObject * obj0 = 0 ;
18070 PyObject * obj1 = 0 ;
18071 PyObject * obj2 = 0 ;
18072 PyObject * obj3 = 0 ;
18073 PyObject * obj4 = 0 ;
18074 char *kwnames[] = {
18075 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18076 };
18077
18078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18079 if (obj0) {
18080 {
18081 arg1 = wxString_in_helper(obj0);
18082 if (arg1 == NULL) SWIG_fail;
18083 temp1 = true;
18084 }
18085 }
18086 if (obj1) {
18087 {
18088 arg2 = wxString_in_helper(obj1);
18089 if (arg2 == NULL) SWIG_fail;
18090 temp2 = true;
18091 }
18092 }
18093 if (obj2) {
18094 {
18095 arg3 = wxString_in_helper(obj2);
18096 if (arg3 == NULL) SWIG_fail;
18097 temp3 = true;
18098 }
18099 }
18100 if (obj3) {
18101 {
18102 arg4 = wxString_in_helper(obj3);
18103 if (arg4 == NULL) SWIG_fail;
18104 temp4 = true;
18105 }
18106 }
18107 if (obj4) {
18108 {
18109 arg5 = (long)(SWIG_As_long(obj4));
18110 if (SWIG_arg_fail(5)) SWIG_fail;
18111 }
18112 }
18113 {
18114 PyThreadState* __tstate = wxPyBeginAllowThreads();
18115 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18116
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18121 {
18122 if (temp1)
18123 delete arg1;
18124 }
18125 {
18126 if (temp2)
18127 delete arg2;
18128 }
18129 {
18130 if (temp3)
18131 delete arg3;
18132 }
18133 {
18134 if (temp4)
18135 delete arg4;
18136 }
18137 return resultobj;
18138 fail:
18139 {
18140 if (temp1)
18141 delete arg1;
18142 }
18143 {
18144 if (temp2)
18145 delete arg2;
18146 }
18147 {
18148 if (temp3)
18149 delete arg3;
18150 }
18151 {
18152 if (temp4)
18153 delete arg4;
18154 }
18155 return NULL;
18156 }
18157
18158
18159 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18160 PyObject *resultobj;
18161 wxConfig *arg1 = (wxConfig *) 0 ;
18162 PyObject * obj0 = 0 ;
18163 char *kwnames[] = {
18164 (char *) "self", NULL
18165 };
18166
18167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18169 if (SWIG_arg_fail(1)) SWIG_fail;
18170 {
18171 PyThreadState* __tstate = wxPyBeginAllowThreads();
18172 delete arg1;
18173
18174 wxPyEndAllowThreads(__tstate);
18175 if (PyErr_Occurred()) SWIG_fail;
18176 }
18177 Py_INCREF(Py_None); resultobj = Py_None;
18178 return resultobj;
18179 fail:
18180 return NULL;
18181 }
18182
18183
18184 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18185 PyObject *obj;
18186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18187 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18188 Py_INCREF(obj);
18189 return Py_BuildValue((char *)"");
18190 }
18191 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18192 PyObject *resultobj;
18193 wxString const &arg1_defvalue = wxPyEmptyString ;
18194 wxString *arg1 = (wxString *) &arg1_defvalue ;
18195 wxString const &arg2_defvalue = wxPyEmptyString ;
18196 wxString *arg2 = (wxString *) &arg2_defvalue ;
18197 wxString const &arg3_defvalue = wxPyEmptyString ;
18198 wxString *arg3 = (wxString *) &arg3_defvalue ;
18199 wxString const &arg4_defvalue = wxPyEmptyString ;
18200 wxString *arg4 = (wxString *) &arg4_defvalue ;
18201 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18202 wxFileConfig *result;
18203 bool temp1 = false ;
18204 bool temp2 = false ;
18205 bool temp3 = false ;
18206 bool temp4 = false ;
18207 PyObject * obj0 = 0 ;
18208 PyObject * obj1 = 0 ;
18209 PyObject * obj2 = 0 ;
18210 PyObject * obj3 = 0 ;
18211 PyObject * obj4 = 0 ;
18212 char *kwnames[] = {
18213 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18214 };
18215
18216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18217 if (obj0) {
18218 {
18219 arg1 = wxString_in_helper(obj0);
18220 if (arg1 == NULL) SWIG_fail;
18221 temp1 = true;
18222 }
18223 }
18224 if (obj1) {
18225 {
18226 arg2 = wxString_in_helper(obj1);
18227 if (arg2 == NULL) SWIG_fail;
18228 temp2 = true;
18229 }
18230 }
18231 if (obj2) {
18232 {
18233 arg3 = wxString_in_helper(obj2);
18234 if (arg3 == NULL) SWIG_fail;
18235 temp3 = true;
18236 }
18237 }
18238 if (obj3) {
18239 {
18240 arg4 = wxString_in_helper(obj3);
18241 if (arg4 == NULL) SWIG_fail;
18242 temp4 = true;
18243 }
18244 }
18245 if (obj4) {
18246 {
18247 arg5 = (long)(SWIG_As_long(obj4));
18248 if (SWIG_arg_fail(5)) SWIG_fail;
18249 }
18250 }
18251 {
18252 PyThreadState* __tstate = wxPyBeginAllowThreads();
18253 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18254
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18259 {
18260 if (temp1)
18261 delete arg1;
18262 }
18263 {
18264 if (temp2)
18265 delete arg2;
18266 }
18267 {
18268 if (temp3)
18269 delete arg3;
18270 }
18271 {
18272 if (temp4)
18273 delete arg4;
18274 }
18275 return resultobj;
18276 fail:
18277 {
18278 if (temp1)
18279 delete arg1;
18280 }
18281 {
18282 if (temp2)
18283 delete arg2;
18284 }
18285 {
18286 if (temp3)
18287 delete arg3;
18288 }
18289 {
18290 if (temp4)
18291 delete arg4;
18292 }
18293 return NULL;
18294 }
18295
18296
18297 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18298 PyObject *resultobj;
18299 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18300 PyObject * obj0 = 0 ;
18301 char *kwnames[] = {
18302 (char *) "self", NULL
18303 };
18304
18305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18307 if (SWIG_arg_fail(1)) SWIG_fail;
18308 {
18309 PyThreadState* __tstate = wxPyBeginAllowThreads();
18310 delete arg1;
18311
18312 wxPyEndAllowThreads(__tstate);
18313 if (PyErr_Occurred()) SWIG_fail;
18314 }
18315 Py_INCREF(Py_None); resultobj = Py_None;
18316 return resultobj;
18317 fail:
18318 return NULL;
18319 }
18320
18321
18322 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18323 PyObject *obj;
18324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18325 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18326 Py_INCREF(obj);
18327 return Py_BuildValue((char *)"");
18328 }
18329 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18330 PyObject *resultobj;
18331 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18332 wxString *arg2 = 0 ;
18333 wxConfigPathChanger *result;
18334 bool temp2 = false ;
18335 PyObject * obj0 = 0 ;
18336 PyObject * obj1 = 0 ;
18337 char *kwnames[] = {
18338 (char *) "config",(char *) "entry", NULL
18339 };
18340
18341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18343 if (SWIG_arg_fail(1)) SWIG_fail;
18344 {
18345 arg2 = wxString_in_helper(obj1);
18346 if (arg2 == NULL) SWIG_fail;
18347 temp2 = true;
18348 }
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18352
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18357 {
18358 if (temp2)
18359 delete arg2;
18360 }
18361 return resultobj;
18362 fail:
18363 {
18364 if (temp2)
18365 delete arg2;
18366 }
18367 return NULL;
18368 }
18369
18370
18371 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18372 PyObject *resultobj;
18373 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18374 PyObject * obj0 = 0 ;
18375 char *kwnames[] = {
18376 (char *) "self", NULL
18377 };
18378
18379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18381 if (SWIG_arg_fail(1)) SWIG_fail;
18382 {
18383 PyThreadState* __tstate = wxPyBeginAllowThreads();
18384 delete arg1;
18385
18386 wxPyEndAllowThreads(__tstate);
18387 if (PyErr_Occurred()) SWIG_fail;
18388 }
18389 Py_INCREF(Py_None); resultobj = Py_None;
18390 return resultobj;
18391 fail:
18392 return NULL;
18393 }
18394
18395
18396 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18397 PyObject *resultobj;
18398 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18399 wxString *result;
18400 PyObject * obj0 = 0 ;
18401 char *kwnames[] = {
18402 (char *) "self", NULL
18403 };
18404
18405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18407 if (SWIG_arg_fail(1)) SWIG_fail;
18408 {
18409 PyThreadState* __tstate = wxPyBeginAllowThreads();
18410 {
18411 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18412 result = (wxString *) &_result_ref;
18413 }
18414
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 {
18419 #if wxUSE_UNICODE
18420 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18421 #else
18422 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18423 #endif
18424 }
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18432 PyObject *obj;
18433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18434 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18435 Py_INCREF(obj);
18436 return Py_BuildValue((char *)"");
18437 }
18438 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18439 PyObject *resultobj;
18440 wxString *arg1 = 0 ;
18441 wxString result;
18442 bool temp1 = false ;
18443 PyObject * obj0 = 0 ;
18444 char *kwnames[] = {
18445 (char *) "sz", NULL
18446 };
18447
18448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18449 {
18450 arg1 = wxString_in_helper(obj0);
18451 if (arg1 == NULL) SWIG_fail;
18452 temp1 = true;
18453 }
18454 {
18455 PyThreadState* __tstate = wxPyBeginAllowThreads();
18456 result = wxExpandEnvVars((wxString const &)*arg1);
18457
18458 wxPyEndAllowThreads(__tstate);
18459 if (PyErr_Occurred()) SWIG_fail;
18460 }
18461 {
18462 #if wxUSE_UNICODE
18463 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18464 #else
18465 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18466 #endif
18467 }
18468 {
18469 if (temp1)
18470 delete arg1;
18471 }
18472 return resultobj;
18473 fail:
18474 {
18475 if (temp1)
18476 delete arg1;
18477 }
18478 return NULL;
18479 }
18480
18481
18482 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18483 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18484 return 1;
18485 }
18486
18487
18488 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18489 PyObject *pyobj;
18490
18491 {
18492 #if wxUSE_UNICODE
18493 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18494 #else
18495 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18496 #endif
18497 }
18498 return pyobj;
18499 }
18500
18501
18502 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18503 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18504 return 1;
18505 }
18506
18507
18508 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18509 PyObject *pyobj;
18510
18511 {
18512 #if wxUSE_UNICODE
18513 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18514 #else
18515 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18516 #endif
18517 }
18518 return pyobj;
18519 }
18520
18521
18522 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18523 PyObject *resultobj;
18524 wxDateTime::Country arg1 ;
18525 PyObject * obj0 = 0 ;
18526 char *kwnames[] = {
18527 (char *) "country", NULL
18528 };
18529
18530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18531 {
18532 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18533 if (SWIG_arg_fail(1)) SWIG_fail;
18534 }
18535 {
18536 PyThreadState* __tstate = wxPyBeginAllowThreads();
18537 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18538
18539 wxPyEndAllowThreads(__tstate);
18540 if (PyErr_Occurred()) SWIG_fail;
18541 }
18542 Py_INCREF(Py_None); resultobj = Py_None;
18543 return resultobj;
18544 fail:
18545 return NULL;
18546 }
18547
18548
18549 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18550 PyObject *resultobj;
18551 wxDateTime::Country result;
18552 char *kwnames[] = {
18553 NULL
18554 };
18555
18556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18557 {
18558 PyThreadState* __tstate = wxPyBeginAllowThreads();
18559 result = (wxDateTime::Country)wxDateTime::GetCountry();
18560
18561 wxPyEndAllowThreads(__tstate);
18562 if (PyErr_Occurred()) SWIG_fail;
18563 }
18564 resultobj = SWIG_From_int((result));
18565 return resultobj;
18566 fail:
18567 return NULL;
18568 }
18569
18570
18571 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18572 PyObject *resultobj;
18573 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18574 bool result;
18575 PyObject * obj0 = 0 ;
18576 char *kwnames[] = {
18577 (char *) "country", NULL
18578 };
18579
18580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18581 if (obj0) {
18582 {
18583 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18584 if (SWIG_arg_fail(1)) SWIG_fail;
18585 }
18586 }
18587 {
18588 PyThreadState* __tstate = wxPyBeginAllowThreads();
18589 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18590
18591 wxPyEndAllowThreads(__tstate);
18592 if (PyErr_Occurred()) SWIG_fail;
18593 }
18594 {
18595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18596 }
18597 return resultobj;
18598 fail:
18599 return NULL;
18600 }
18601
18602
18603 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18604 PyObject *resultobj;
18605 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18606 int result;
18607 PyObject * obj0 = 0 ;
18608 char *kwnames[] = {
18609 (char *) "cal", NULL
18610 };
18611
18612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18613 if (obj0) {
18614 {
18615 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18616 if (SWIG_arg_fail(1)) SWIG_fail;
18617 }
18618 }
18619 {
18620 PyThreadState* __tstate = wxPyBeginAllowThreads();
18621 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18622
18623 wxPyEndAllowThreads(__tstate);
18624 if (PyErr_Occurred()) SWIG_fail;
18625 }
18626 {
18627 resultobj = SWIG_From_int((int)(result));
18628 }
18629 return resultobj;
18630 fail:
18631 return NULL;
18632 }
18633
18634
18635 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18636 PyObject *resultobj;
18637 int arg1 ;
18638 int result;
18639 PyObject * obj0 = 0 ;
18640 char *kwnames[] = {
18641 (char *) "year", NULL
18642 };
18643
18644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18645 {
18646 arg1 = (int)(SWIG_As_int(obj0));
18647 if (SWIG_arg_fail(1)) SWIG_fail;
18648 }
18649 {
18650 PyThreadState* __tstate = wxPyBeginAllowThreads();
18651 result = (int)wxDateTime::ConvertYearToBC(arg1);
18652
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 {
18657 resultobj = SWIG_From_int((int)(result));
18658 }
18659 return resultobj;
18660 fail:
18661 return NULL;
18662 }
18663
18664
18665 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18666 PyObject *resultobj;
18667 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18668 wxDateTime::Month result;
18669 PyObject * obj0 = 0 ;
18670 char *kwnames[] = {
18671 (char *) "cal", NULL
18672 };
18673
18674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18675 if (obj0) {
18676 {
18677 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18678 if (SWIG_arg_fail(1)) SWIG_fail;
18679 }
18680 }
18681 {
18682 PyThreadState* __tstate = wxPyBeginAllowThreads();
18683 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18684
18685 wxPyEndAllowThreads(__tstate);
18686 if (PyErr_Occurred()) SWIG_fail;
18687 }
18688 resultobj = SWIG_From_int((result));
18689 return resultobj;
18690 fail:
18691 return NULL;
18692 }
18693
18694
18695 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18696 PyObject *resultobj;
18697 int arg1 = (int) wxDateTime::Inv_Year ;
18698 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18699 bool result;
18700 PyObject * obj0 = 0 ;
18701 PyObject * obj1 = 0 ;
18702 char *kwnames[] = {
18703 (char *) "year",(char *) "cal", NULL
18704 };
18705
18706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18707 if (obj0) {
18708 {
18709 arg1 = (int)(SWIG_As_int(obj0));
18710 if (SWIG_arg_fail(1)) SWIG_fail;
18711 }
18712 }
18713 if (obj1) {
18714 {
18715 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18716 if (SWIG_arg_fail(2)) SWIG_fail;
18717 }
18718 }
18719 {
18720 PyThreadState* __tstate = wxPyBeginAllowThreads();
18721 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18722
18723 wxPyEndAllowThreads(__tstate);
18724 if (PyErr_Occurred()) SWIG_fail;
18725 }
18726 {
18727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18728 }
18729 return resultobj;
18730 fail:
18731 return NULL;
18732 }
18733
18734
18735 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18736 PyObject *resultobj;
18737 int arg1 = (int) wxDateTime::Inv_Year ;
18738 int result;
18739 PyObject * obj0 = 0 ;
18740 char *kwnames[] = {
18741 (char *) "year", NULL
18742 };
18743
18744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18745 if (obj0) {
18746 {
18747 arg1 = (int)(SWIG_As_int(obj0));
18748 if (SWIG_arg_fail(1)) SWIG_fail;
18749 }
18750 }
18751 {
18752 PyThreadState* __tstate = wxPyBeginAllowThreads();
18753 result = (int)wxDateTime::GetCentury(arg1);
18754
18755 wxPyEndAllowThreads(__tstate);
18756 if (PyErr_Occurred()) SWIG_fail;
18757 }
18758 {
18759 resultobj = SWIG_From_int((int)(result));
18760 }
18761 return resultobj;
18762 fail:
18763 return NULL;
18764 }
18765
18766
18767 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
18768 PyObject *resultobj;
18769 int arg1 ;
18770 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18771 int result;
18772 PyObject * obj0 = 0 ;
18773 PyObject * obj1 = 0 ;
18774 char *kwnames[] = {
18775 (char *) "year",(char *) "cal", NULL
18776 };
18777
18778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
18779 {
18780 arg1 = (int)(SWIG_As_int(obj0));
18781 if (SWIG_arg_fail(1)) SWIG_fail;
18782 }
18783 if (obj1) {
18784 {
18785 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18786 if (SWIG_arg_fail(2)) SWIG_fail;
18787 }
18788 }
18789 {
18790 PyThreadState* __tstate = wxPyBeginAllowThreads();
18791 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
18792
18793 wxPyEndAllowThreads(__tstate);
18794 if (PyErr_Occurred()) SWIG_fail;
18795 }
18796 {
18797 resultobj = SWIG_From_int((int)(result));
18798 }
18799 return resultobj;
18800 fail:
18801 return NULL;
18802 }
18803
18804
18805 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18806 PyObject *resultobj;
18807 wxDateTime::Month arg1 ;
18808 int arg2 = (int) wxDateTime::Inv_Year ;
18809 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18810 int result;
18811 PyObject * obj0 = 0 ;
18812 PyObject * obj1 = 0 ;
18813 PyObject * obj2 = 0 ;
18814 char *kwnames[] = {
18815 (char *) "month",(char *) "year",(char *) "cal", NULL
18816 };
18817
18818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
18819 {
18820 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18821 if (SWIG_arg_fail(1)) SWIG_fail;
18822 }
18823 if (obj1) {
18824 {
18825 arg2 = (int)(SWIG_As_int(obj1));
18826 if (SWIG_arg_fail(2)) SWIG_fail;
18827 }
18828 }
18829 if (obj2) {
18830 {
18831 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
18832 if (SWIG_arg_fail(3)) SWIG_fail;
18833 }
18834 }
18835 {
18836 PyThreadState* __tstate = wxPyBeginAllowThreads();
18837 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
18838
18839 wxPyEndAllowThreads(__tstate);
18840 if (PyErr_Occurred()) SWIG_fail;
18841 }
18842 {
18843 resultobj = SWIG_From_int((int)(result));
18844 }
18845 return resultobj;
18846 fail:
18847 return NULL;
18848 }
18849
18850
18851 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj;
18853 wxDateTime::Month arg1 ;
18854 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18855 wxString result;
18856 PyObject * obj0 = 0 ;
18857 PyObject * obj1 = 0 ;
18858 char *kwnames[] = {
18859 (char *) "month",(char *) "flags", NULL
18860 };
18861
18862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
18863 {
18864 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18865 if (SWIG_arg_fail(1)) SWIG_fail;
18866 }
18867 if (obj1) {
18868 {
18869 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18870 if (SWIG_arg_fail(2)) SWIG_fail;
18871 }
18872 }
18873 {
18874 PyThreadState* __tstate = wxPyBeginAllowThreads();
18875 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
18876
18877 wxPyEndAllowThreads(__tstate);
18878 if (PyErr_Occurred()) SWIG_fail;
18879 }
18880 {
18881 #if wxUSE_UNICODE
18882 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18883 #else
18884 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18885 #endif
18886 }
18887 return resultobj;
18888 fail:
18889 return NULL;
18890 }
18891
18892
18893 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
18894 PyObject *resultobj;
18895 wxDateTime::WeekDay arg1 ;
18896 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18897 wxString result;
18898 PyObject * obj0 = 0 ;
18899 PyObject * obj1 = 0 ;
18900 char *kwnames[] = {
18901 (char *) "weekday",(char *) "flags", NULL
18902 };
18903
18904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
18905 {
18906 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 }
18909 if (obj1) {
18910 {
18911 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18912 if (SWIG_arg_fail(2)) SWIG_fail;
18913 }
18914 }
18915 {
18916 PyThreadState* __tstate = wxPyBeginAllowThreads();
18917 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
18918
18919 wxPyEndAllowThreads(__tstate);
18920 if (PyErr_Occurred()) SWIG_fail;
18921 }
18922 {
18923 #if wxUSE_UNICODE
18924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18925 #else
18926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18927 #endif
18928 }
18929 return resultobj;
18930 fail:
18931 return NULL;
18932 }
18933
18934
18935 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
18936 PyObject *resultobj;
18937 wxString *arg1 = (wxString *) 0 ;
18938 wxString *arg2 = (wxString *) 0 ;
18939 bool temp1 = false ;
18940 bool temp2 = false ;
18941 PyObject * obj0 = 0 ;
18942 PyObject * obj1 = 0 ;
18943 char *kwnames[] = {
18944 (char *) "OUTPUT",(char *) "OUTPUT", NULL
18945 };
18946
18947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
18948 {
18949 arg1 = wxString_in_helper(obj0);
18950 if (arg1 == NULL) SWIG_fail;
18951 temp1 = true;
18952 }
18953 {
18954 arg2 = wxString_in_helper(obj1);
18955 if (arg2 == NULL) SWIG_fail;
18956 temp2 = true;
18957 }
18958 {
18959 PyThreadState* __tstate = wxPyBeginAllowThreads();
18960 wxDateTime::GetAmPmStrings(arg1,arg2);
18961
18962 wxPyEndAllowThreads(__tstate);
18963 if (PyErr_Occurred()) SWIG_fail;
18964 }
18965 Py_INCREF(Py_None); resultobj = Py_None;
18966 {
18967 if (temp1)
18968 delete arg1;
18969 }
18970 {
18971 if (temp2)
18972 delete arg2;
18973 }
18974 return resultobj;
18975 fail:
18976 {
18977 if (temp1)
18978 delete arg1;
18979 }
18980 {
18981 if (temp2)
18982 delete arg2;
18983 }
18984 return NULL;
18985 }
18986
18987
18988 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
18989 PyObject *resultobj;
18990 int arg1 = (int) wxDateTime::Inv_Year ;
18991 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
18992 bool result;
18993 PyObject * obj0 = 0 ;
18994 PyObject * obj1 = 0 ;
18995 char *kwnames[] = {
18996 (char *) "year",(char *) "country", NULL
18997 };
18998
18999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19000 if (obj0) {
19001 {
19002 arg1 = (int)(SWIG_As_int(obj0));
19003 if (SWIG_arg_fail(1)) SWIG_fail;
19004 }
19005 }
19006 if (obj1) {
19007 {
19008 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19009 if (SWIG_arg_fail(2)) SWIG_fail;
19010 }
19011 }
19012 {
19013 PyThreadState* __tstate = wxPyBeginAllowThreads();
19014 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19015
19016 wxPyEndAllowThreads(__tstate);
19017 if (PyErr_Occurred()) SWIG_fail;
19018 }
19019 {
19020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19021 }
19022 return resultobj;
19023 fail:
19024 return NULL;
19025 }
19026
19027
19028 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19029 PyObject *resultobj;
19030 int arg1 = (int) wxDateTime::Inv_Year ;
19031 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19032 wxDateTime result;
19033 PyObject * obj0 = 0 ;
19034 PyObject * obj1 = 0 ;
19035 char *kwnames[] = {
19036 (char *) "year",(char *) "country", NULL
19037 };
19038
19039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19040 if (obj0) {
19041 {
19042 arg1 = (int)(SWIG_As_int(obj0));
19043 if (SWIG_arg_fail(1)) SWIG_fail;
19044 }
19045 }
19046 if (obj1) {
19047 {
19048 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19049 if (SWIG_arg_fail(2)) SWIG_fail;
19050 }
19051 }
19052 {
19053 PyThreadState* __tstate = wxPyBeginAllowThreads();
19054 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19055
19056 wxPyEndAllowThreads(__tstate);
19057 if (PyErr_Occurred()) SWIG_fail;
19058 }
19059 {
19060 wxDateTime * resultptr;
19061 resultptr = new wxDateTime((wxDateTime &)(result));
19062 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19063 }
19064 return resultobj;
19065 fail:
19066 return NULL;
19067 }
19068
19069
19070 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19071 PyObject *resultobj;
19072 int arg1 = (int) wxDateTime::Inv_Year ;
19073 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19074 wxDateTime result;
19075 PyObject * obj0 = 0 ;
19076 PyObject * obj1 = 0 ;
19077 char *kwnames[] = {
19078 (char *) "year",(char *) "country", NULL
19079 };
19080
19081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19082 if (obj0) {
19083 {
19084 arg1 = (int)(SWIG_As_int(obj0));
19085 if (SWIG_arg_fail(1)) SWIG_fail;
19086 }
19087 }
19088 if (obj1) {
19089 {
19090 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19091 if (SWIG_arg_fail(2)) SWIG_fail;
19092 }
19093 }
19094 {
19095 PyThreadState* __tstate = wxPyBeginAllowThreads();
19096 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19097
19098 wxPyEndAllowThreads(__tstate);
19099 if (PyErr_Occurred()) SWIG_fail;
19100 }
19101 {
19102 wxDateTime * resultptr;
19103 resultptr = new wxDateTime((wxDateTime &)(result));
19104 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19105 }
19106 return resultobj;
19107 fail:
19108 return NULL;
19109 }
19110
19111
19112 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19113 PyObject *resultobj;
19114 wxDateTime result;
19115 char *kwnames[] = {
19116 NULL
19117 };
19118
19119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19120 {
19121 PyThreadState* __tstate = wxPyBeginAllowThreads();
19122 result = wxDateTime::Now();
19123
19124 wxPyEndAllowThreads(__tstate);
19125 if (PyErr_Occurred()) SWIG_fail;
19126 }
19127 {
19128 wxDateTime * resultptr;
19129 resultptr = new wxDateTime((wxDateTime &)(result));
19130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19131 }
19132 return resultobj;
19133 fail:
19134 return NULL;
19135 }
19136
19137
19138 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19139 PyObject *resultobj;
19140 wxDateTime result;
19141 char *kwnames[] = {
19142 NULL
19143 };
19144
19145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19146 {
19147 PyThreadState* __tstate = wxPyBeginAllowThreads();
19148 result = wxDateTime::UNow();
19149
19150 wxPyEndAllowThreads(__tstate);
19151 if (PyErr_Occurred()) SWIG_fail;
19152 }
19153 {
19154 wxDateTime * resultptr;
19155 resultptr = new wxDateTime((wxDateTime &)(result));
19156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19157 }
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19165 PyObject *resultobj;
19166 wxDateTime result;
19167 char *kwnames[] = {
19168 NULL
19169 };
19170
19171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19172 {
19173 PyThreadState* __tstate = wxPyBeginAllowThreads();
19174 result = wxDateTime::Today();
19175
19176 wxPyEndAllowThreads(__tstate);
19177 if (PyErr_Occurred()) SWIG_fail;
19178 }
19179 {
19180 wxDateTime * resultptr;
19181 resultptr = new wxDateTime((wxDateTime &)(result));
19182 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19183 }
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19191 PyObject *resultobj;
19192 wxDateTime *result;
19193 char *kwnames[] = {
19194 NULL
19195 };
19196
19197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19198 {
19199 PyThreadState* __tstate = wxPyBeginAllowThreads();
19200 result = (wxDateTime *)new wxDateTime();
19201
19202 wxPyEndAllowThreads(__tstate);
19203 if (PyErr_Occurred()) SWIG_fail;
19204 }
19205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19206 return resultobj;
19207 fail:
19208 return NULL;
19209 }
19210
19211
19212 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19213 PyObject *resultobj;
19214 time_t arg1 ;
19215 wxDateTime *result;
19216 PyObject * obj0 = 0 ;
19217 char *kwnames[] = {
19218 (char *) "timet", NULL
19219 };
19220
19221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19222 {
19223 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19224 if (SWIG_arg_fail(1)) SWIG_fail;
19225 }
19226 {
19227 PyThreadState* __tstate = wxPyBeginAllowThreads();
19228 result = (wxDateTime *)new wxDateTime(arg1);
19229
19230 wxPyEndAllowThreads(__tstate);
19231 if (PyErr_Occurred()) SWIG_fail;
19232 }
19233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19234 return resultobj;
19235 fail:
19236 return NULL;
19237 }
19238
19239
19240 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19241 PyObject *resultobj;
19242 double arg1 ;
19243 wxDateTime *result;
19244 PyObject * obj0 = 0 ;
19245 char *kwnames[] = {
19246 (char *) "jdn", NULL
19247 };
19248
19249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19250 {
19251 arg1 = (double)(SWIG_As_double(obj0));
19252 if (SWIG_arg_fail(1)) SWIG_fail;
19253 }
19254 {
19255 PyThreadState* __tstate = wxPyBeginAllowThreads();
19256 result = (wxDateTime *)new wxDateTime(arg1);
19257
19258 wxPyEndAllowThreads(__tstate);
19259 if (PyErr_Occurred()) SWIG_fail;
19260 }
19261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19262 return resultobj;
19263 fail:
19264 return NULL;
19265 }
19266
19267
19268 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19269 PyObject *resultobj;
19270 int arg1 ;
19271 int arg2 = (int) 0 ;
19272 int arg3 = (int) 0 ;
19273 int arg4 = (int) 0 ;
19274 wxDateTime *result;
19275 PyObject * obj0 = 0 ;
19276 PyObject * obj1 = 0 ;
19277 PyObject * obj2 = 0 ;
19278 PyObject * obj3 = 0 ;
19279 char *kwnames[] = {
19280 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19281 };
19282
19283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19284 {
19285 arg1 = (int)(SWIG_As_int(obj0));
19286 if (SWIG_arg_fail(1)) SWIG_fail;
19287 }
19288 if (obj1) {
19289 {
19290 arg2 = (int)(SWIG_As_int(obj1));
19291 if (SWIG_arg_fail(2)) SWIG_fail;
19292 }
19293 }
19294 if (obj2) {
19295 {
19296 arg3 = (int)(SWIG_As_int(obj2));
19297 if (SWIG_arg_fail(3)) SWIG_fail;
19298 }
19299 }
19300 if (obj3) {
19301 {
19302 arg4 = (int)(SWIG_As_int(obj3));
19303 if (SWIG_arg_fail(4)) SWIG_fail;
19304 }
19305 }
19306 {
19307 PyThreadState* __tstate = wxPyBeginAllowThreads();
19308 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19309
19310 wxPyEndAllowThreads(__tstate);
19311 if (PyErr_Occurred()) SWIG_fail;
19312 }
19313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19314 return resultobj;
19315 fail:
19316 return NULL;
19317 }
19318
19319
19320 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19321 PyObject *resultobj;
19322 int arg1 ;
19323 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19324 int arg3 = (int) wxDateTime::Inv_Year ;
19325 int arg4 = (int) 0 ;
19326 int arg5 = (int) 0 ;
19327 int arg6 = (int) 0 ;
19328 int arg7 = (int) 0 ;
19329 wxDateTime *result;
19330 PyObject * obj0 = 0 ;
19331 PyObject * obj1 = 0 ;
19332 PyObject * obj2 = 0 ;
19333 PyObject * obj3 = 0 ;
19334 PyObject * obj4 = 0 ;
19335 PyObject * obj5 = 0 ;
19336 PyObject * obj6 = 0 ;
19337 char *kwnames[] = {
19338 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19339 };
19340
19341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19342 {
19343 arg1 = (int)(SWIG_As_int(obj0));
19344 if (SWIG_arg_fail(1)) SWIG_fail;
19345 }
19346 if (obj1) {
19347 {
19348 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19349 if (SWIG_arg_fail(2)) SWIG_fail;
19350 }
19351 }
19352 if (obj2) {
19353 {
19354 arg3 = (int)(SWIG_As_int(obj2));
19355 if (SWIG_arg_fail(3)) SWIG_fail;
19356 }
19357 }
19358 if (obj3) {
19359 {
19360 arg4 = (int)(SWIG_As_int(obj3));
19361 if (SWIG_arg_fail(4)) SWIG_fail;
19362 }
19363 }
19364 if (obj4) {
19365 {
19366 arg5 = (int)(SWIG_As_int(obj4));
19367 if (SWIG_arg_fail(5)) SWIG_fail;
19368 }
19369 }
19370 if (obj5) {
19371 {
19372 arg6 = (int)(SWIG_As_int(obj5));
19373 if (SWIG_arg_fail(6)) SWIG_fail;
19374 }
19375 }
19376 if (obj6) {
19377 {
19378 arg7 = (int)(SWIG_As_int(obj6));
19379 if (SWIG_arg_fail(7)) SWIG_fail;
19380 }
19381 }
19382 {
19383 PyThreadState* __tstate = wxPyBeginAllowThreads();
19384 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19385
19386 wxPyEndAllowThreads(__tstate);
19387 if (PyErr_Occurred()) SWIG_fail;
19388 }
19389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19390 return resultobj;
19391 fail:
19392 return NULL;
19393 }
19394
19395
19396 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19397 PyObject *resultobj;
19398 wxDateTime *arg1 = (wxDateTime *) 0 ;
19399 PyObject * obj0 = 0 ;
19400 char *kwnames[] = {
19401 (char *) "self", NULL
19402 };
19403
19404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19406 if (SWIG_arg_fail(1)) SWIG_fail;
19407 {
19408 PyThreadState* __tstate = wxPyBeginAllowThreads();
19409 delete arg1;
19410
19411 wxPyEndAllowThreads(__tstate);
19412 if (PyErr_Occurred()) SWIG_fail;
19413 }
19414 Py_INCREF(Py_None); resultobj = Py_None;
19415 return resultobj;
19416 fail:
19417 return NULL;
19418 }
19419
19420
19421 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19422 PyObject *resultobj;
19423 wxDateTime *arg1 = (wxDateTime *) 0 ;
19424 wxDateTime *result;
19425 PyObject * obj0 = 0 ;
19426 char *kwnames[] = {
19427 (char *) "self", NULL
19428 };
19429
19430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19432 if (SWIG_arg_fail(1)) SWIG_fail;
19433 {
19434 PyThreadState* __tstate = wxPyBeginAllowThreads();
19435 {
19436 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19437 result = (wxDateTime *) &_result_ref;
19438 }
19439
19440 wxPyEndAllowThreads(__tstate);
19441 if (PyErr_Occurred()) SWIG_fail;
19442 }
19443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19444 return resultobj;
19445 fail:
19446 return NULL;
19447 }
19448
19449
19450 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19451 PyObject *resultobj;
19452 wxDateTime *arg1 = (wxDateTime *) 0 ;
19453 time_t arg2 ;
19454 wxDateTime *result;
19455 PyObject * obj0 = 0 ;
19456 PyObject * obj1 = 0 ;
19457 char *kwnames[] = {
19458 (char *) "self",(char *) "timet", NULL
19459 };
19460
19461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19463 if (SWIG_arg_fail(1)) SWIG_fail;
19464 {
19465 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19466 if (SWIG_arg_fail(2)) SWIG_fail;
19467 }
19468 {
19469 PyThreadState* __tstate = wxPyBeginAllowThreads();
19470 {
19471 wxDateTime &_result_ref = (arg1)->Set(arg2);
19472 result = (wxDateTime *) &_result_ref;
19473 }
19474
19475 wxPyEndAllowThreads(__tstate);
19476 if (PyErr_Occurred()) SWIG_fail;
19477 }
19478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19479 return resultobj;
19480 fail:
19481 return NULL;
19482 }
19483
19484
19485 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19486 PyObject *resultobj;
19487 wxDateTime *arg1 = (wxDateTime *) 0 ;
19488 double arg2 ;
19489 wxDateTime *result;
19490 PyObject * obj0 = 0 ;
19491 PyObject * obj1 = 0 ;
19492 char *kwnames[] = {
19493 (char *) "self",(char *) "jdn", NULL
19494 };
19495
19496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19498 if (SWIG_arg_fail(1)) SWIG_fail;
19499 {
19500 arg2 = (double)(SWIG_As_double(obj1));
19501 if (SWIG_arg_fail(2)) SWIG_fail;
19502 }
19503 {
19504 PyThreadState* __tstate = wxPyBeginAllowThreads();
19505 {
19506 wxDateTime &_result_ref = (arg1)->Set(arg2);
19507 result = (wxDateTime *) &_result_ref;
19508 }
19509
19510 wxPyEndAllowThreads(__tstate);
19511 if (PyErr_Occurred()) SWIG_fail;
19512 }
19513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19521 PyObject *resultobj;
19522 wxDateTime *arg1 = (wxDateTime *) 0 ;
19523 int arg2 ;
19524 int arg3 = (int) 0 ;
19525 int arg4 = (int) 0 ;
19526 int arg5 = (int) 0 ;
19527 wxDateTime *result;
19528 PyObject * obj0 = 0 ;
19529 PyObject * obj1 = 0 ;
19530 PyObject * obj2 = 0 ;
19531 PyObject * obj3 = 0 ;
19532 PyObject * obj4 = 0 ;
19533 char *kwnames[] = {
19534 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19535 };
19536
19537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19539 if (SWIG_arg_fail(1)) SWIG_fail;
19540 {
19541 arg2 = (int)(SWIG_As_int(obj1));
19542 if (SWIG_arg_fail(2)) SWIG_fail;
19543 }
19544 if (obj2) {
19545 {
19546 arg3 = (int)(SWIG_As_int(obj2));
19547 if (SWIG_arg_fail(3)) SWIG_fail;
19548 }
19549 }
19550 if (obj3) {
19551 {
19552 arg4 = (int)(SWIG_As_int(obj3));
19553 if (SWIG_arg_fail(4)) SWIG_fail;
19554 }
19555 }
19556 if (obj4) {
19557 {
19558 arg5 = (int)(SWIG_As_int(obj4));
19559 if (SWIG_arg_fail(5)) SWIG_fail;
19560 }
19561 }
19562 {
19563 PyThreadState* __tstate = wxPyBeginAllowThreads();
19564 {
19565 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19566 result = (wxDateTime *) &_result_ref;
19567 }
19568
19569 wxPyEndAllowThreads(__tstate);
19570 if (PyErr_Occurred()) SWIG_fail;
19571 }
19572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19573 return resultobj;
19574 fail:
19575 return NULL;
19576 }
19577
19578
19579 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19580 PyObject *resultobj;
19581 wxDateTime *arg1 = (wxDateTime *) 0 ;
19582 int arg2 ;
19583 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19584 int arg4 = (int) wxDateTime::Inv_Year ;
19585 int arg5 = (int) 0 ;
19586 int arg6 = (int) 0 ;
19587 int arg7 = (int) 0 ;
19588 int arg8 = (int) 0 ;
19589 wxDateTime *result;
19590 PyObject * obj0 = 0 ;
19591 PyObject * obj1 = 0 ;
19592 PyObject * obj2 = 0 ;
19593 PyObject * obj3 = 0 ;
19594 PyObject * obj4 = 0 ;
19595 PyObject * obj5 = 0 ;
19596 PyObject * obj6 = 0 ;
19597 PyObject * obj7 = 0 ;
19598 char *kwnames[] = {
19599 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19600 };
19601
19602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19604 if (SWIG_arg_fail(1)) SWIG_fail;
19605 {
19606 arg2 = (int)(SWIG_As_int(obj1));
19607 if (SWIG_arg_fail(2)) SWIG_fail;
19608 }
19609 if (obj2) {
19610 {
19611 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19612 if (SWIG_arg_fail(3)) SWIG_fail;
19613 }
19614 }
19615 if (obj3) {
19616 {
19617 arg4 = (int)(SWIG_As_int(obj3));
19618 if (SWIG_arg_fail(4)) SWIG_fail;
19619 }
19620 }
19621 if (obj4) {
19622 {
19623 arg5 = (int)(SWIG_As_int(obj4));
19624 if (SWIG_arg_fail(5)) SWIG_fail;
19625 }
19626 }
19627 if (obj5) {
19628 {
19629 arg6 = (int)(SWIG_As_int(obj5));
19630 if (SWIG_arg_fail(6)) SWIG_fail;
19631 }
19632 }
19633 if (obj6) {
19634 {
19635 arg7 = (int)(SWIG_As_int(obj6));
19636 if (SWIG_arg_fail(7)) SWIG_fail;
19637 }
19638 }
19639 if (obj7) {
19640 {
19641 arg8 = (int)(SWIG_As_int(obj7));
19642 if (SWIG_arg_fail(8)) SWIG_fail;
19643 }
19644 }
19645 {
19646 PyThreadState* __tstate = wxPyBeginAllowThreads();
19647 {
19648 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19649 result = (wxDateTime *) &_result_ref;
19650 }
19651
19652 wxPyEndAllowThreads(__tstate);
19653 if (PyErr_Occurred()) SWIG_fail;
19654 }
19655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19656 return resultobj;
19657 fail:
19658 return NULL;
19659 }
19660
19661
19662 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19663 PyObject *resultobj;
19664 wxDateTime *arg1 = (wxDateTime *) 0 ;
19665 wxDateTime *result;
19666 PyObject * obj0 = 0 ;
19667 char *kwnames[] = {
19668 (char *) "self", NULL
19669 };
19670
19671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19673 if (SWIG_arg_fail(1)) SWIG_fail;
19674 {
19675 PyThreadState* __tstate = wxPyBeginAllowThreads();
19676 {
19677 wxDateTime &_result_ref = (arg1)->ResetTime();
19678 result = (wxDateTime *) &_result_ref;
19679 }
19680
19681 wxPyEndAllowThreads(__tstate);
19682 if (PyErr_Occurred()) SWIG_fail;
19683 }
19684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19685 return resultobj;
19686 fail:
19687 return NULL;
19688 }
19689
19690
19691 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19692 PyObject *resultobj;
19693 wxDateTime *arg1 = (wxDateTime *) 0 ;
19694 int arg2 ;
19695 wxDateTime *result;
19696 PyObject * obj0 = 0 ;
19697 PyObject * obj1 = 0 ;
19698 char *kwnames[] = {
19699 (char *) "self",(char *) "year", NULL
19700 };
19701
19702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19704 if (SWIG_arg_fail(1)) SWIG_fail;
19705 {
19706 arg2 = (int)(SWIG_As_int(obj1));
19707 if (SWIG_arg_fail(2)) SWIG_fail;
19708 }
19709 {
19710 PyThreadState* __tstate = wxPyBeginAllowThreads();
19711 {
19712 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19713 result = (wxDateTime *) &_result_ref;
19714 }
19715
19716 wxPyEndAllowThreads(__tstate);
19717 if (PyErr_Occurred()) SWIG_fail;
19718 }
19719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19720 return resultobj;
19721 fail:
19722 return NULL;
19723 }
19724
19725
19726 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19727 PyObject *resultobj;
19728 wxDateTime *arg1 = (wxDateTime *) 0 ;
19729 wxDateTime::Month arg2 ;
19730 wxDateTime *result;
19731 PyObject * obj0 = 0 ;
19732 PyObject * obj1 = 0 ;
19733 char *kwnames[] = {
19734 (char *) "self",(char *) "month", NULL
19735 };
19736
19737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19739 if (SWIG_arg_fail(1)) SWIG_fail;
19740 {
19741 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19742 if (SWIG_arg_fail(2)) SWIG_fail;
19743 }
19744 {
19745 PyThreadState* __tstate = wxPyBeginAllowThreads();
19746 {
19747 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19748 result = (wxDateTime *) &_result_ref;
19749 }
19750
19751 wxPyEndAllowThreads(__tstate);
19752 if (PyErr_Occurred()) SWIG_fail;
19753 }
19754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 wxDateTime *arg1 = (wxDateTime *) 0 ;
19764 int arg2 ;
19765 wxDateTime *result;
19766 PyObject * obj0 = 0 ;
19767 PyObject * obj1 = 0 ;
19768 char *kwnames[] = {
19769 (char *) "self",(char *) "day", NULL
19770 };
19771
19772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
19773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19774 if (SWIG_arg_fail(1)) SWIG_fail;
19775 {
19776 arg2 = (int)(SWIG_As_int(obj1));
19777 if (SWIG_arg_fail(2)) SWIG_fail;
19778 }
19779 {
19780 PyThreadState* __tstate = wxPyBeginAllowThreads();
19781 {
19782 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
19783 result = (wxDateTime *) &_result_ref;
19784 }
19785
19786 wxPyEndAllowThreads(__tstate);
19787 if (PyErr_Occurred()) SWIG_fail;
19788 }
19789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19790 return resultobj;
19791 fail:
19792 return NULL;
19793 }
19794
19795
19796 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
19797 PyObject *resultobj;
19798 wxDateTime *arg1 = (wxDateTime *) 0 ;
19799 int arg2 ;
19800 wxDateTime *result;
19801 PyObject * obj0 = 0 ;
19802 PyObject * obj1 = 0 ;
19803 char *kwnames[] = {
19804 (char *) "self",(char *) "hour", NULL
19805 };
19806
19807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
19808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19809 if (SWIG_arg_fail(1)) SWIG_fail;
19810 {
19811 arg2 = (int)(SWIG_As_int(obj1));
19812 if (SWIG_arg_fail(2)) SWIG_fail;
19813 }
19814 {
19815 PyThreadState* __tstate = wxPyBeginAllowThreads();
19816 {
19817 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
19818 result = (wxDateTime *) &_result_ref;
19819 }
19820
19821 wxPyEndAllowThreads(__tstate);
19822 if (PyErr_Occurred()) SWIG_fail;
19823 }
19824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19825 return resultobj;
19826 fail:
19827 return NULL;
19828 }
19829
19830
19831 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
19832 PyObject *resultobj;
19833 wxDateTime *arg1 = (wxDateTime *) 0 ;
19834 int arg2 ;
19835 wxDateTime *result;
19836 PyObject * obj0 = 0 ;
19837 PyObject * obj1 = 0 ;
19838 char *kwnames[] = {
19839 (char *) "self",(char *) "minute", NULL
19840 };
19841
19842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
19843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19844 if (SWIG_arg_fail(1)) SWIG_fail;
19845 {
19846 arg2 = (int)(SWIG_As_int(obj1));
19847 if (SWIG_arg_fail(2)) SWIG_fail;
19848 }
19849 {
19850 PyThreadState* __tstate = wxPyBeginAllowThreads();
19851 {
19852 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
19853 result = (wxDateTime *) &_result_ref;
19854 }
19855
19856 wxPyEndAllowThreads(__tstate);
19857 if (PyErr_Occurred()) SWIG_fail;
19858 }
19859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19860 return resultobj;
19861 fail:
19862 return NULL;
19863 }
19864
19865
19866 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
19867 PyObject *resultobj;
19868 wxDateTime *arg1 = (wxDateTime *) 0 ;
19869 int arg2 ;
19870 wxDateTime *result;
19871 PyObject * obj0 = 0 ;
19872 PyObject * obj1 = 0 ;
19873 char *kwnames[] = {
19874 (char *) "self",(char *) "second", NULL
19875 };
19876
19877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
19878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19879 if (SWIG_arg_fail(1)) SWIG_fail;
19880 {
19881 arg2 = (int)(SWIG_As_int(obj1));
19882 if (SWIG_arg_fail(2)) SWIG_fail;
19883 }
19884 {
19885 PyThreadState* __tstate = wxPyBeginAllowThreads();
19886 {
19887 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
19888 result = (wxDateTime *) &_result_ref;
19889 }
19890
19891 wxPyEndAllowThreads(__tstate);
19892 if (PyErr_Occurred()) SWIG_fail;
19893 }
19894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19895 return resultobj;
19896 fail:
19897 return NULL;
19898 }
19899
19900
19901 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
19902 PyObject *resultobj;
19903 wxDateTime *arg1 = (wxDateTime *) 0 ;
19904 int arg2 ;
19905 wxDateTime *result;
19906 PyObject * obj0 = 0 ;
19907 PyObject * obj1 = 0 ;
19908 char *kwnames[] = {
19909 (char *) "self",(char *) "millisecond", NULL
19910 };
19911
19912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
19913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19914 if (SWIG_arg_fail(1)) SWIG_fail;
19915 {
19916 arg2 = (int)(SWIG_As_int(obj1));
19917 if (SWIG_arg_fail(2)) SWIG_fail;
19918 }
19919 {
19920 PyThreadState* __tstate = wxPyBeginAllowThreads();
19921 {
19922 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
19923 result = (wxDateTime *) &_result_ref;
19924 }
19925
19926 wxPyEndAllowThreads(__tstate);
19927 if (PyErr_Occurred()) SWIG_fail;
19928 }
19929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19930 return resultobj;
19931 fail:
19932 return NULL;
19933 }
19934
19935
19936 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19937 PyObject *resultobj;
19938 wxDateTime *arg1 = (wxDateTime *) 0 ;
19939 wxDateTime::WeekDay arg2 ;
19940 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19941 wxDateTime *result;
19942 PyObject * obj0 = 0 ;
19943 PyObject * obj1 = 0 ;
19944 PyObject * obj2 = 0 ;
19945 char *kwnames[] = {
19946 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19947 };
19948
19949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19951 if (SWIG_arg_fail(1)) SWIG_fail;
19952 {
19953 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
19954 if (SWIG_arg_fail(2)) SWIG_fail;
19955 }
19956 if (obj2) {
19957 {
19958 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
19959 if (SWIG_arg_fail(3)) SWIG_fail;
19960 }
19961 }
19962 {
19963 PyThreadState* __tstate = wxPyBeginAllowThreads();
19964 {
19965 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
19966 result = (wxDateTime *) &_result_ref;
19967 }
19968
19969 wxPyEndAllowThreads(__tstate);
19970 if (PyErr_Occurred()) SWIG_fail;
19971 }
19972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19980 PyObject *resultobj;
19981 wxDateTime *arg1 = (wxDateTime *) 0 ;
19982 wxDateTime::WeekDay arg2 ;
19983 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19984 wxDateTime result;
19985 PyObject * obj0 = 0 ;
19986 PyObject * obj1 = 0 ;
19987 PyObject * obj2 = 0 ;
19988 char *kwnames[] = {
19989 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19990 };
19991
19992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19994 if (SWIG_arg_fail(1)) SWIG_fail;
19995 {
19996 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
19997 if (SWIG_arg_fail(2)) SWIG_fail;
19998 }
19999 if (obj2) {
20000 {
20001 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20002 if (SWIG_arg_fail(3)) SWIG_fail;
20003 }
20004 }
20005 {
20006 PyThreadState* __tstate = wxPyBeginAllowThreads();
20007 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20008
20009 wxPyEndAllowThreads(__tstate);
20010 if (PyErr_Occurred()) SWIG_fail;
20011 }
20012 {
20013 wxDateTime * resultptr;
20014 resultptr = new wxDateTime((wxDateTime &)(result));
20015 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20016 }
20017 return resultobj;
20018 fail:
20019 return NULL;
20020 }
20021
20022
20023 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20024 PyObject *resultobj;
20025 wxDateTime *arg1 = (wxDateTime *) 0 ;
20026 wxDateTime::WeekDay arg2 ;
20027 wxDateTime *result;
20028 PyObject * obj0 = 0 ;
20029 PyObject * obj1 = 0 ;
20030 char *kwnames[] = {
20031 (char *) "self",(char *) "weekday", NULL
20032 };
20033
20034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20036 if (SWIG_arg_fail(1)) SWIG_fail;
20037 {
20038 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20039 if (SWIG_arg_fail(2)) SWIG_fail;
20040 }
20041 {
20042 PyThreadState* __tstate = wxPyBeginAllowThreads();
20043 {
20044 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20045 result = (wxDateTime *) &_result_ref;
20046 }
20047
20048 wxPyEndAllowThreads(__tstate);
20049 if (PyErr_Occurred()) SWIG_fail;
20050 }
20051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20059 PyObject *resultobj;
20060 wxDateTime *arg1 = (wxDateTime *) 0 ;
20061 wxDateTime::WeekDay arg2 ;
20062 wxDateTime result;
20063 PyObject * obj0 = 0 ;
20064 PyObject * obj1 = 0 ;
20065 char *kwnames[] = {
20066 (char *) "self",(char *) "weekday", NULL
20067 };
20068
20069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20071 if (SWIG_arg_fail(1)) SWIG_fail;
20072 {
20073 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20074 if (SWIG_arg_fail(2)) SWIG_fail;
20075 }
20076 {
20077 PyThreadState* __tstate = wxPyBeginAllowThreads();
20078 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20079
20080 wxPyEndAllowThreads(__tstate);
20081 if (PyErr_Occurred()) SWIG_fail;
20082 }
20083 {
20084 wxDateTime * resultptr;
20085 resultptr = new wxDateTime((wxDateTime &)(result));
20086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20087 }
20088 return resultobj;
20089 fail:
20090 return NULL;
20091 }
20092
20093
20094 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20095 PyObject *resultobj;
20096 wxDateTime *arg1 = (wxDateTime *) 0 ;
20097 wxDateTime::WeekDay arg2 ;
20098 wxDateTime *result;
20099 PyObject * obj0 = 0 ;
20100 PyObject * obj1 = 0 ;
20101 char *kwnames[] = {
20102 (char *) "self",(char *) "weekday", NULL
20103 };
20104
20105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20107 if (SWIG_arg_fail(1)) SWIG_fail;
20108 {
20109 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20110 if (SWIG_arg_fail(2)) SWIG_fail;
20111 }
20112 {
20113 PyThreadState* __tstate = wxPyBeginAllowThreads();
20114 {
20115 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20116 result = (wxDateTime *) &_result_ref;
20117 }
20118
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20123 return resultobj;
20124 fail:
20125 return NULL;
20126 }
20127
20128
20129 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20130 PyObject *resultobj;
20131 wxDateTime *arg1 = (wxDateTime *) 0 ;
20132 wxDateTime::WeekDay arg2 ;
20133 wxDateTime result;
20134 PyObject * obj0 = 0 ;
20135 PyObject * obj1 = 0 ;
20136 char *kwnames[] = {
20137 (char *) "self",(char *) "weekday", NULL
20138 };
20139
20140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20142 if (SWIG_arg_fail(1)) SWIG_fail;
20143 {
20144 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20145 if (SWIG_arg_fail(2)) SWIG_fail;
20146 }
20147 {
20148 PyThreadState* __tstate = wxPyBeginAllowThreads();
20149 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20150
20151 wxPyEndAllowThreads(__tstate);
20152 if (PyErr_Occurred()) SWIG_fail;
20153 }
20154 {
20155 wxDateTime * resultptr;
20156 resultptr = new wxDateTime((wxDateTime &)(result));
20157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20158 }
20159 return resultobj;
20160 fail:
20161 return NULL;
20162 }
20163
20164
20165 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20166 PyObject *resultobj;
20167 wxDateTime *arg1 = (wxDateTime *) 0 ;
20168 wxDateTime::WeekDay arg2 ;
20169 int arg3 = (int) 1 ;
20170 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20171 int arg5 = (int) wxDateTime::Inv_Year ;
20172 bool result;
20173 PyObject * obj0 = 0 ;
20174 PyObject * obj1 = 0 ;
20175 PyObject * obj2 = 0 ;
20176 PyObject * obj3 = 0 ;
20177 PyObject * obj4 = 0 ;
20178 char *kwnames[] = {
20179 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20180 };
20181
20182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20184 if (SWIG_arg_fail(1)) SWIG_fail;
20185 {
20186 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20187 if (SWIG_arg_fail(2)) SWIG_fail;
20188 }
20189 if (obj2) {
20190 {
20191 arg3 = (int)(SWIG_As_int(obj2));
20192 if (SWIG_arg_fail(3)) SWIG_fail;
20193 }
20194 }
20195 if (obj3) {
20196 {
20197 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20198 if (SWIG_arg_fail(4)) SWIG_fail;
20199 }
20200 }
20201 if (obj4) {
20202 {
20203 arg5 = (int)(SWIG_As_int(obj4));
20204 if (SWIG_arg_fail(5)) SWIG_fail;
20205 }
20206 }
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20210
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 {
20215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20216 }
20217 return resultobj;
20218 fail:
20219 return NULL;
20220 }
20221
20222
20223 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20224 PyObject *resultobj;
20225 wxDateTime *arg1 = (wxDateTime *) 0 ;
20226 wxDateTime::WeekDay arg2 ;
20227 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20228 int arg4 = (int) wxDateTime::Inv_Year ;
20229 bool result;
20230 PyObject * obj0 = 0 ;
20231 PyObject * obj1 = 0 ;
20232 PyObject * obj2 = 0 ;
20233 PyObject * obj3 = 0 ;
20234 char *kwnames[] = {
20235 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20236 };
20237
20238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20240 if (SWIG_arg_fail(1)) SWIG_fail;
20241 {
20242 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20243 if (SWIG_arg_fail(2)) SWIG_fail;
20244 }
20245 if (obj2) {
20246 {
20247 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20248 if (SWIG_arg_fail(3)) SWIG_fail;
20249 }
20250 }
20251 if (obj3) {
20252 {
20253 arg4 = (int)(SWIG_As_int(obj3));
20254 if (SWIG_arg_fail(4)) SWIG_fail;
20255 }
20256 }
20257 {
20258 PyThreadState* __tstate = wxPyBeginAllowThreads();
20259 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20260
20261 wxPyEndAllowThreads(__tstate);
20262 if (PyErr_Occurred()) SWIG_fail;
20263 }
20264 {
20265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20266 }
20267 return resultobj;
20268 fail:
20269 return NULL;
20270 }
20271
20272
20273 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20274 PyObject *resultobj;
20275 wxDateTime *arg1 = (wxDateTime *) 0 ;
20276 wxDateTime::WeekDay arg2 ;
20277 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20278 int arg4 = (int) wxDateTime::Inv_Year ;
20279 wxDateTime result;
20280 PyObject * obj0 = 0 ;
20281 PyObject * obj1 = 0 ;
20282 PyObject * obj2 = 0 ;
20283 PyObject * obj3 = 0 ;
20284 char *kwnames[] = {
20285 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20286 };
20287
20288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20290 if (SWIG_arg_fail(1)) SWIG_fail;
20291 {
20292 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20293 if (SWIG_arg_fail(2)) SWIG_fail;
20294 }
20295 if (obj2) {
20296 {
20297 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20298 if (SWIG_arg_fail(3)) SWIG_fail;
20299 }
20300 }
20301 if (obj3) {
20302 {
20303 arg4 = (int)(SWIG_As_int(obj3));
20304 if (SWIG_arg_fail(4)) SWIG_fail;
20305 }
20306 }
20307 {
20308 PyThreadState* __tstate = wxPyBeginAllowThreads();
20309 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20310
20311 wxPyEndAllowThreads(__tstate);
20312 if (PyErr_Occurred()) SWIG_fail;
20313 }
20314 {
20315 wxDateTime * resultptr;
20316 resultptr = new wxDateTime((wxDateTime &)(result));
20317 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20318 }
20319 return resultobj;
20320 fail:
20321 return NULL;
20322 }
20323
20324
20325 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20326 PyObject *resultobj;
20327 wxDateTime *arg1 = (wxDateTime *) 0 ;
20328 int arg2 ;
20329 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20330 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20331 bool result;
20332 PyObject * obj0 = 0 ;
20333 PyObject * obj1 = 0 ;
20334 PyObject * obj2 = 0 ;
20335 PyObject * obj3 = 0 ;
20336 char *kwnames[] = {
20337 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20338 };
20339
20340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20342 if (SWIG_arg_fail(1)) SWIG_fail;
20343 {
20344 arg2 = (int)(SWIG_As_int(obj1));
20345 if (SWIG_arg_fail(2)) SWIG_fail;
20346 }
20347 if (obj2) {
20348 {
20349 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20350 if (SWIG_arg_fail(3)) SWIG_fail;
20351 }
20352 }
20353 if (obj3) {
20354 {
20355 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20356 if (SWIG_arg_fail(4)) SWIG_fail;
20357 }
20358 }
20359 {
20360 PyThreadState* __tstate = wxPyBeginAllowThreads();
20361 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20362
20363 wxPyEndAllowThreads(__tstate);
20364 if (PyErr_Occurred()) SWIG_fail;
20365 }
20366 {
20367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20368 }
20369 return resultobj;
20370 fail:
20371 return NULL;
20372 }
20373
20374
20375 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20376 PyObject *resultobj;
20377 wxDateTime *arg1 = (wxDateTime *) 0 ;
20378 int arg2 ;
20379 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20380 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20381 wxDateTime result;
20382 PyObject * obj0 = 0 ;
20383 PyObject * obj1 = 0 ;
20384 PyObject * obj2 = 0 ;
20385 PyObject * obj3 = 0 ;
20386 char *kwnames[] = {
20387 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20388 };
20389
20390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 = (int)(SWIG_As_int(obj1));
20395 if (SWIG_arg_fail(2)) SWIG_fail;
20396 }
20397 if (obj2) {
20398 {
20399 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20400 if (SWIG_arg_fail(3)) SWIG_fail;
20401 }
20402 }
20403 if (obj3) {
20404 {
20405 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20406 if (SWIG_arg_fail(4)) SWIG_fail;
20407 }
20408 }
20409 {
20410 PyThreadState* __tstate = wxPyBeginAllowThreads();
20411 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20412
20413 wxPyEndAllowThreads(__tstate);
20414 if (PyErr_Occurred()) SWIG_fail;
20415 }
20416 {
20417 wxDateTime * resultptr;
20418 resultptr = new wxDateTime((wxDateTime &)(result));
20419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20420 }
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20428 PyObject *resultobj;
20429 int arg1 ;
20430 int arg2 ;
20431 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20432 wxDateTime result;
20433 PyObject * obj0 = 0 ;
20434 PyObject * obj1 = 0 ;
20435 PyObject * obj2 = 0 ;
20436 char *kwnames[] = {
20437 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20438 };
20439
20440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20441 {
20442 arg1 = (int)(SWIG_As_int(obj0));
20443 if (SWIG_arg_fail(1)) SWIG_fail;
20444 }
20445 {
20446 arg2 = (int)(SWIG_As_int(obj1));
20447 if (SWIG_arg_fail(2)) SWIG_fail;
20448 }
20449 if (obj2) {
20450 {
20451 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20452 if (SWIG_arg_fail(3)) SWIG_fail;
20453 }
20454 }
20455 {
20456 PyThreadState* __tstate = wxPyBeginAllowThreads();
20457 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20458
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 {
20463 wxDateTime * resultptr;
20464 resultptr = new wxDateTime((wxDateTime &)(result));
20465 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20466 }
20467 return resultobj;
20468 fail:
20469 return NULL;
20470 }
20471
20472
20473 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20474 PyObject *resultobj;
20475 wxDateTime *arg1 = (wxDateTime *) 0 ;
20476 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20477 int arg3 = (int) wxDateTime::Inv_Year ;
20478 wxDateTime *result;
20479 PyObject * obj0 = 0 ;
20480 PyObject * obj1 = 0 ;
20481 PyObject * obj2 = 0 ;
20482 char *kwnames[] = {
20483 (char *) "self",(char *) "month",(char *) "year", NULL
20484 };
20485
20486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20488 if (SWIG_arg_fail(1)) SWIG_fail;
20489 if (obj1) {
20490 {
20491 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20492 if (SWIG_arg_fail(2)) SWIG_fail;
20493 }
20494 }
20495 if (obj2) {
20496 {
20497 arg3 = (int)(SWIG_As_int(obj2));
20498 if (SWIG_arg_fail(3)) SWIG_fail;
20499 }
20500 }
20501 {
20502 PyThreadState* __tstate = wxPyBeginAllowThreads();
20503 {
20504 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20505 result = (wxDateTime *) &_result_ref;
20506 }
20507
20508 wxPyEndAllowThreads(__tstate);
20509 if (PyErr_Occurred()) SWIG_fail;
20510 }
20511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20512 return resultobj;
20513 fail:
20514 return NULL;
20515 }
20516
20517
20518 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20519 PyObject *resultobj;
20520 wxDateTime *arg1 = (wxDateTime *) 0 ;
20521 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20522 int arg3 = (int) wxDateTime::Inv_Year ;
20523 wxDateTime result;
20524 PyObject * obj0 = 0 ;
20525 PyObject * obj1 = 0 ;
20526 PyObject * obj2 = 0 ;
20527 char *kwnames[] = {
20528 (char *) "self",(char *) "month",(char *) "year", NULL
20529 };
20530
20531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20533 if (SWIG_arg_fail(1)) SWIG_fail;
20534 if (obj1) {
20535 {
20536 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20537 if (SWIG_arg_fail(2)) SWIG_fail;
20538 }
20539 }
20540 if (obj2) {
20541 {
20542 arg3 = (int)(SWIG_As_int(obj2));
20543 if (SWIG_arg_fail(3)) SWIG_fail;
20544 }
20545 }
20546 {
20547 PyThreadState* __tstate = wxPyBeginAllowThreads();
20548 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20549
20550 wxPyEndAllowThreads(__tstate);
20551 if (PyErr_Occurred()) SWIG_fail;
20552 }
20553 {
20554 wxDateTime * resultptr;
20555 resultptr = new wxDateTime((wxDateTime &)(result));
20556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20557 }
20558 return resultobj;
20559 fail:
20560 return NULL;
20561 }
20562
20563
20564 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20565 PyObject *resultobj;
20566 wxDateTime *arg1 = (wxDateTime *) 0 ;
20567 int arg2 ;
20568 wxDateTime *result;
20569 PyObject * obj0 = 0 ;
20570 PyObject * obj1 = 0 ;
20571 char *kwnames[] = {
20572 (char *) "self",(char *) "yday", NULL
20573 };
20574
20575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20577 if (SWIG_arg_fail(1)) SWIG_fail;
20578 {
20579 arg2 = (int)(SWIG_As_int(obj1));
20580 if (SWIG_arg_fail(2)) SWIG_fail;
20581 }
20582 {
20583 PyThreadState* __tstate = wxPyBeginAllowThreads();
20584 {
20585 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20586 result = (wxDateTime *) &_result_ref;
20587 }
20588
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20593 return resultobj;
20594 fail:
20595 return NULL;
20596 }
20597
20598
20599 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20600 PyObject *resultobj;
20601 wxDateTime *arg1 = (wxDateTime *) 0 ;
20602 int arg2 ;
20603 wxDateTime result;
20604 PyObject * obj0 = 0 ;
20605 PyObject * obj1 = 0 ;
20606 char *kwnames[] = {
20607 (char *) "self",(char *) "yday", NULL
20608 };
20609
20610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20612 if (SWIG_arg_fail(1)) SWIG_fail;
20613 {
20614 arg2 = (int)(SWIG_As_int(obj1));
20615 if (SWIG_arg_fail(2)) SWIG_fail;
20616 }
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 result = (arg1)->GetYearDay(arg2);
20620
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 wxDateTime * resultptr;
20626 resultptr = new wxDateTime((wxDateTime &)(result));
20627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20628 }
20629 return resultobj;
20630 fail:
20631 return NULL;
20632 }
20633
20634
20635 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20636 PyObject *resultobj;
20637 wxDateTime *arg1 = (wxDateTime *) 0 ;
20638 double result;
20639 PyObject * obj0 = 0 ;
20640 char *kwnames[] = {
20641 (char *) "self", NULL
20642 };
20643
20644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20646 if (SWIG_arg_fail(1)) SWIG_fail;
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 result = (double)(arg1)->GetJulianDayNumber();
20650
20651 wxPyEndAllowThreads(__tstate);
20652 if (PyErr_Occurred()) SWIG_fail;
20653 }
20654 {
20655 resultobj = SWIG_From_double((double)(result));
20656 }
20657 return resultobj;
20658 fail:
20659 return NULL;
20660 }
20661
20662
20663 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20664 PyObject *resultobj;
20665 wxDateTime *arg1 = (wxDateTime *) 0 ;
20666 double result;
20667 PyObject * obj0 = 0 ;
20668 char *kwnames[] = {
20669 (char *) "self", NULL
20670 };
20671
20672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20674 if (SWIG_arg_fail(1)) SWIG_fail;
20675 {
20676 PyThreadState* __tstate = wxPyBeginAllowThreads();
20677 result = (double)(arg1)->GetJDN();
20678
20679 wxPyEndAllowThreads(__tstate);
20680 if (PyErr_Occurred()) SWIG_fail;
20681 }
20682 {
20683 resultobj = SWIG_From_double((double)(result));
20684 }
20685 return resultobj;
20686 fail:
20687 return NULL;
20688 }
20689
20690
20691 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20692 PyObject *resultobj;
20693 wxDateTime *arg1 = (wxDateTime *) 0 ;
20694 double result;
20695 PyObject * obj0 = 0 ;
20696 char *kwnames[] = {
20697 (char *) "self", NULL
20698 };
20699
20700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20702 if (SWIG_arg_fail(1)) SWIG_fail;
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20706
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 {
20711 resultobj = SWIG_From_double((double)(result));
20712 }
20713 return resultobj;
20714 fail:
20715 return NULL;
20716 }
20717
20718
20719 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20720 PyObject *resultobj;
20721 wxDateTime *arg1 = (wxDateTime *) 0 ;
20722 double result;
20723 PyObject * obj0 = 0 ;
20724 char *kwnames[] = {
20725 (char *) "self", NULL
20726 };
20727
20728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20730 if (SWIG_arg_fail(1)) SWIG_fail;
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = (double)(arg1)->GetMJD();
20734
20735 wxPyEndAllowThreads(__tstate);
20736 if (PyErr_Occurred()) SWIG_fail;
20737 }
20738 {
20739 resultobj = SWIG_From_double((double)(result));
20740 }
20741 return resultobj;
20742 fail:
20743 return NULL;
20744 }
20745
20746
20747 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20748 PyObject *resultobj;
20749 wxDateTime *arg1 = (wxDateTime *) 0 ;
20750 double result;
20751 PyObject * obj0 = 0 ;
20752 char *kwnames[] = {
20753 (char *) "self", NULL
20754 };
20755
20756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20758 if (SWIG_arg_fail(1)) SWIG_fail;
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 result = (double)(arg1)->GetRataDie();
20762
20763 wxPyEndAllowThreads(__tstate);
20764 if (PyErr_Occurred()) SWIG_fail;
20765 }
20766 {
20767 resultobj = SWIG_From_double((double)(result));
20768 }
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20776 PyObject *resultobj;
20777 wxDateTime *arg1 = (wxDateTime *) 0 ;
20778 wxDateTime::TimeZone *arg2 = 0 ;
20779 bool arg3 = (bool) false ;
20780 wxDateTime result;
20781 bool temp2 = false ;
20782 PyObject * obj0 = 0 ;
20783 PyObject * obj1 = 0 ;
20784 PyObject * obj2 = 0 ;
20785 char *kwnames[] = {
20786 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20787 };
20788
20789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20791 if (SWIG_arg_fail(1)) SWIG_fail;
20792 {
20793 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20794 temp2 = true;
20795 }
20796 if (obj2) {
20797 {
20798 arg3 = (bool)(SWIG_As_bool(obj2));
20799 if (SWIG_arg_fail(3)) SWIG_fail;
20800 }
20801 }
20802 {
20803 PyThreadState* __tstate = wxPyBeginAllowThreads();
20804 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20805
20806 wxPyEndAllowThreads(__tstate);
20807 if (PyErr_Occurred()) SWIG_fail;
20808 }
20809 {
20810 wxDateTime * resultptr;
20811 resultptr = new wxDateTime((wxDateTime &)(result));
20812 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20813 }
20814 {
20815 if (temp2) delete arg2;
20816 }
20817 return resultobj;
20818 fail:
20819 {
20820 if (temp2) delete arg2;
20821 }
20822 return NULL;
20823 }
20824
20825
20826 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj;
20828 wxDateTime *arg1 = (wxDateTime *) 0 ;
20829 wxDateTime::TimeZone *arg2 = 0 ;
20830 bool arg3 = (bool) false ;
20831 wxDateTime *result;
20832 bool temp2 = false ;
20833 PyObject * obj0 = 0 ;
20834 PyObject * obj1 = 0 ;
20835 PyObject * obj2 = 0 ;
20836 char *kwnames[] = {
20837 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20838 };
20839
20840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20842 if (SWIG_arg_fail(1)) SWIG_fail;
20843 {
20844 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20845 temp2 = true;
20846 }
20847 if (obj2) {
20848 {
20849 arg3 = (bool)(SWIG_As_bool(obj2));
20850 if (SWIG_arg_fail(3)) SWIG_fail;
20851 }
20852 }
20853 {
20854 PyThreadState* __tstate = wxPyBeginAllowThreads();
20855 {
20856 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20857 result = (wxDateTime *) &_result_ref;
20858 }
20859
20860 wxPyEndAllowThreads(__tstate);
20861 if (PyErr_Occurred()) SWIG_fail;
20862 }
20863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20864 {
20865 if (temp2) delete arg2;
20866 }
20867 return resultobj;
20868 fail:
20869 {
20870 if (temp2) delete arg2;
20871 }
20872 return NULL;
20873 }
20874
20875
20876 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20877 PyObject *resultobj;
20878 wxDateTime *arg1 = (wxDateTime *) 0 ;
20879 bool arg2 = (bool) false ;
20880 wxDateTime result;
20881 PyObject * obj0 = 0 ;
20882 PyObject * obj1 = 0 ;
20883 char *kwnames[] = {
20884 (char *) "self",(char *) "noDST", NULL
20885 };
20886
20887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
20888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20889 if (SWIG_arg_fail(1)) SWIG_fail;
20890 if (obj1) {
20891 {
20892 arg2 = (bool)(SWIG_As_bool(obj1));
20893 if (SWIG_arg_fail(2)) SWIG_fail;
20894 }
20895 }
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 result = (arg1)->ToGMT(arg2);
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_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20915 PyObject *resultobj;
20916 wxDateTime *arg1 = (wxDateTime *) 0 ;
20917 bool arg2 = (bool) false ;
20918 wxDateTime *result;
20919 PyObject * obj0 = 0 ;
20920 PyObject * obj1 = 0 ;
20921 char *kwnames[] = {
20922 (char *) "self",(char *) "noDST", NULL
20923 };
20924
20925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
20926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20927 if (SWIG_arg_fail(1)) SWIG_fail;
20928 if (obj1) {
20929 {
20930 arg2 = (bool)(SWIG_As_bool(obj1));
20931 if (SWIG_arg_fail(2)) SWIG_fail;
20932 }
20933 }
20934 {
20935 PyThreadState* __tstate = wxPyBeginAllowThreads();
20936 {
20937 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
20938 result = (wxDateTime *) &_result_ref;
20939 }
20940
20941 wxPyEndAllowThreads(__tstate);
20942 if (PyErr_Occurred()) SWIG_fail;
20943 }
20944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20945 return resultobj;
20946 fail:
20947 return NULL;
20948 }
20949
20950
20951 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
20952 PyObject *resultobj;
20953 wxDateTime *arg1 = (wxDateTime *) 0 ;
20954 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20955 int result;
20956 PyObject * obj0 = 0 ;
20957 PyObject * obj1 = 0 ;
20958 char *kwnames[] = {
20959 (char *) "self",(char *) "country", NULL
20960 };
20961
20962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
20963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20964 if (SWIG_arg_fail(1)) SWIG_fail;
20965 if (obj1) {
20966 {
20967 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
20968 if (SWIG_arg_fail(2)) SWIG_fail;
20969 }
20970 }
20971 {
20972 PyThreadState* __tstate = wxPyBeginAllowThreads();
20973 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
20974
20975 wxPyEndAllowThreads(__tstate);
20976 if (PyErr_Occurred()) SWIG_fail;
20977 }
20978 {
20979 resultobj = SWIG_From_int((int)(result));
20980 }
20981 return resultobj;
20982 fail:
20983 return NULL;
20984 }
20985
20986
20987 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
20988 PyObject *resultobj;
20989 wxDateTime *arg1 = (wxDateTime *) 0 ;
20990 bool result;
20991 PyObject * obj0 = 0 ;
20992 char *kwnames[] = {
20993 (char *) "self", NULL
20994 };
20995
20996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
20997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20998 if (SWIG_arg_fail(1)) SWIG_fail;
20999 {
21000 PyThreadState* __tstate = wxPyBeginAllowThreads();
21001 result = (bool)((wxDateTime const *)arg1)->IsValid();
21002
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 {
21007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21008 }
21009 return resultobj;
21010 fail:
21011 return NULL;
21012 }
21013
21014
21015 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21016 PyObject *resultobj;
21017 wxDateTime *arg1 = (wxDateTime *) 0 ;
21018 time_t result;
21019 PyObject * obj0 = 0 ;
21020 char *kwnames[] = {
21021 (char *) "self", NULL
21022 };
21023
21024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21026 if (SWIG_arg_fail(1)) SWIG_fail;
21027 {
21028 PyThreadState* __tstate = wxPyBeginAllowThreads();
21029 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21030
21031 wxPyEndAllowThreads(__tstate);
21032 if (PyErr_Occurred()) SWIG_fail;
21033 }
21034 {
21035 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21036 }
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21044 PyObject *resultobj;
21045 wxDateTime *arg1 = (wxDateTime *) 0 ;
21046 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21047 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21048 int result;
21049 bool temp2 = false ;
21050 PyObject * obj0 = 0 ;
21051 PyObject * obj1 = 0 ;
21052 char *kwnames[] = {
21053 (char *) "self",(char *) "tz", NULL
21054 };
21055
21056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21058 if (SWIG_arg_fail(1)) SWIG_fail;
21059 if (obj1) {
21060 {
21061 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21062 temp2 = true;
21063 }
21064 }
21065 {
21066 PyThreadState* __tstate = wxPyBeginAllowThreads();
21067 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21068
21069 wxPyEndAllowThreads(__tstate);
21070 if (PyErr_Occurred()) SWIG_fail;
21071 }
21072 {
21073 resultobj = SWIG_From_int((int)(result));
21074 }
21075 {
21076 if (temp2) delete arg2;
21077 }
21078 return resultobj;
21079 fail:
21080 {
21081 if (temp2) delete arg2;
21082 }
21083 return NULL;
21084 }
21085
21086
21087 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21088 PyObject *resultobj;
21089 wxDateTime *arg1 = (wxDateTime *) 0 ;
21090 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21091 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21092 wxDateTime::Month result;
21093 bool temp2 = false ;
21094 PyObject * obj0 = 0 ;
21095 PyObject * obj1 = 0 ;
21096 char *kwnames[] = {
21097 (char *) "self",(char *) "tz", NULL
21098 };
21099
21100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21102 if (SWIG_arg_fail(1)) SWIG_fail;
21103 if (obj1) {
21104 {
21105 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21106 temp2 = true;
21107 }
21108 }
21109 {
21110 PyThreadState* __tstate = wxPyBeginAllowThreads();
21111 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21112
21113 wxPyEndAllowThreads(__tstate);
21114 if (PyErr_Occurred()) SWIG_fail;
21115 }
21116 resultobj = SWIG_From_int((result));
21117 {
21118 if (temp2) delete arg2;
21119 }
21120 return resultobj;
21121 fail:
21122 {
21123 if (temp2) delete arg2;
21124 }
21125 return NULL;
21126 }
21127
21128
21129 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21130 PyObject *resultobj;
21131 wxDateTime *arg1 = (wxDateTime *) 0 ;
21132 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21133 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21134 int result;
21135 bool temp2 = false ;
21136 PyObject * obj0 = 0 ;
21137 PyObject * obj1 = 0 ;
21138 char *kwnames[] = {
21139 (char *) "self",(char *) "tz", NULL
21140 };
21141
21142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21144 if (SWIG_arg_fail(1)) SWIG_fail;
21145 if (obj1) {
21146 {
21147 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21148 temp2 = true;
21149 }
21150 }
21151 {
21152 PyThreadState* __tstate = wxPyBeginAllowThreads();
21153 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21154
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 {
21159 resultobj = SWIG_From_int((int)(result));
21160 }
21161 {
21162 if (temp2) delete arg2;
21163 }
21164 return resultobj;
21165 fail:
21166 {
21167 if (temp2) delete arg2;
21168 }
21169 return NULL;
21170 }
21171
21172
21173 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21174 PyObject *resultobj;
21175 wxDateTime *arg1 = (wxDateTime *) 0 ;
21176 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21177 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21178 wxDateTime::WeekDay result;
21179 bool temp2 = false ;
21180 PyObject * obj0 = 0 ;
21181 PyObject * obj1 = 0 ;
21182 char *kwnames[] = {
21183 (char *) "self",(char *) "tz", NULL
21184 };
21185
21186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21188 if (SWIG_arg_fail(1)) SWIG_fail;
21189 if (obj1) {
21190 {
21191 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21192 temp2 = true;
21193 }
21194 }
21195 {
21196 PyThreadState* __tstate = wxPyBeginAllowThreads();
21197 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21198
21199 wxPyEndAllowThreads(__tstate);
21200 if (PyErr_Occurred()) SWIG_fail;
21201 }
21202 resultobj = SWIG_From_int((result));
21203 {
21204 if (temp2) delete arg2;
21205 }
21206 return resultobj;
21207 fail:
21208 {
21209 if (temp2) delete arg2;
21210 }
21211 return NULL;
21212 }
21213
21214
21215 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21216 PyObject *resultobj;
21217 wxDateTime *arg1 = (wxDateTime *) 0 ;
21218 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21219 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21220 int result;
21221 bool temp2 = false ;
21222 PyObject * obj0 = 0 ;
21223 PyObject * obj1 = 0 ;
21224 char *kwnames[] = {
21225 (char *) "self",(char *) "tz", NULL
21226 };
21227
21228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21230 if (SWIG_arg_fail(1)) SWIG_fail;
21231 if (obj1) {
21232 {
21233 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21234 temp2 = true;
21235 }
21236 }
21237 {
21238 PyThreadState* __tstate = wxPyBeginAllowThreads();
21239 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21240
21241 wxPyEndAllowThreads(__tstate);
21242 if (PyErr_Occurred()) SWIG_fail;
21243 }
21244 {
21245 resultobj = SWIG_From_int((int)(result));
21246 }
21247 {
21248 if (temp2) delete arg2;
21249 }
21250 return resultobj;
21251 fail:
21252 {
21253 if (temp2) delete arg2;
21254 }
21255 return NULL;
21256 }
21257
21258
21259 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21260 PyObject *resultobj;
21261 wxDateTime *arg1 = (wxDateTime *) 0 ;
21262 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21263 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21264 int result;
21265 bool temp2 = false ;
21266 PyObject * obj0 = 0 ;
21267 PyObject * obj1 = 0 ;
21268 char *kwnames[] = {
21269 (char *) "self",(char *) "tz", NULL
21270 };
21271
21272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21274 if (SWIG_arg_fail(1)) SWIG_fail;
21275 if (obj1) {
21276 {
21277 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21278 temp2 = true;
21279 }
21280 }
21281 {
21282 PyThreadState* __tstate = wxPyBeginAllowThreads();
21283 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21284
21285 wxPyEndAllowThreads(__tstate);
21286 if (PyErr_Occurred()) SWIG_fail;
21287 }
21288 {
21289 resultobj = SWIG_From_int((int)(result));
21290 }
21291 {
21292 if (temp2) delete arg2;
21293 }
21294 return resultobj;
21295 fail:
21296 {
21297 if (temp2) delete arg2;
21298 }
21299 return NULL;
21300 }
21301
21302
21303 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21304 PyObject *resultobj;
21305 wxDateTime *arg1 = (wxDateTime *) 0 ;
21306 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21307 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21308 int result;
21309 bool temp2 = false ;
21310 PyObject * obj0 = 0 ;
21311 PyObject * obj1 = 0 ;
21312 char *kwnames[] = {
21313 (char *) "self",(char *) "tz", NULL
21314 };
21315
21316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21318 if (SWIG_arg_fail(1)) SWIG_fail;
21319 if (obj1) {
21320 {
21321 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21322 temp2 = true;
21323 }
21324 }
21325 {
21326 PyThreadState* __tstate = wxPyBeginAllowThreads();
21327 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21328
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 {
21333 resultobj = SWIG_From_int((int)(result));
21334 }
21335 {
21336 if (temp2) delete arg2;
21337 }
21338 return resultobj;
21339 fail:
21340 {
21341 if (temp2) delete arg2;
21342 }
21343 return NULL;
21344 }
21345
21346
21347 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21348 PyObject *resultobj;
21349 wxDateTime *arg1 = (wxDateTime *) 0 ;
21350 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21351 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21352 int result;
21353 bool temp2 = false ;
21354 PyObject * obj0 = 0 ;
21355 PyObject * obj1 = 0 ;
21356 char *kwnames[] = {
21357 (char *) "self",(char *) "tz", NULL
21358 };
21359
21360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21362 if (SWIG_arg_fail(1)) SWIG_fail;
21363 if (obj1) {
21364 {
21365 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21366 temp2 = true;
21367 }
21368 }
21369 {
21370 PyThreadState* __tstate = wxPyBeginAllowThreads();
21371 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21372
21373 wxPyEndAllowThreads(__tstate);
21374 if (PyErr_Occurred()) SWIG_fail;
21375 }
21376 {
21377 resultobj = SWIG_From_int((int)(result));
21378 }
21379 {
21380 if (temp2) delete arg2;
21381 }
21382 return resultobj;
21383 fail:
21384 {
21385 if (temp2) delete arg2;
21386 }
21387 return NULL;
21388 }
21389
21390
21391 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21392 PyObject *resultobj;
21393 wxDateTime *arg1 = (wxDateTime *) 0 ;
21394 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21395 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21396 int result;
21397 bool temp2 = false ;
21398 PyObject * obj0 = 0 ;
21399 PyObject * obj1 = 0 ;
21400 char *kwnames[] = {
21401 (char *) "self",(char *) "tz", NULL
21402 };
21403
21404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21406 if (SWIG_arg_fail(1)) SWIG_fail;
21407 if (obj1) {
21408 {
21409 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21410 temp2 = true;
21411 }
21412 }
21413 {
21414 PyThreadState* __tstate = wxPyBeginAllowThreads();
21415 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21416
21417 wxPyEndAllowThreads(__tstate);
21418 if (PyErr_Occurred()) SWIG_fail;
21419 }
21420 {
21421 resultobj = SWIG_From_int((int)(result));
21422 }
21423 {
21424 if (temp2) delete arg2;
21425 }
21426 return resultobj;
21427 fail:
21428 {
21429 if (temp2) delete arg2;
21430 }
21431 return NULL;
21432 }
21433
21434
21435 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21436 PyObject *resultobj;
21437 wxDateTime *arg1 = (wxDateTime *) 0 ;
21438 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21439 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21440 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21441 int result;
21442 bool temp3 = false ;
21443 PyObject * obj0 = 0 ;
21444 PyObject * obj1 = 0 ;
21445 PyObject * obj2 = 0 ;
21446 char *kwnames[] = {
21447 (char *) "self",(char *) "flags",(char *) "tz", NULL
21448 };
21449
21450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21452 if (SWIG_arg_fail(1)) SWIG_fail;
21453 if (obj1) {
21454 {
21455 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21456 if (SWIG_arg_fail(2)) SWIG_fail;
21457 }
21458 }
21459 if (obj2) {
21460 {
21461 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21462 temp3 = true;
21463 }
21464 }
21465 {
21466 PyThreadState* __tstate = wxPyBeginAllowThreads();
21467 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21468
21469 wxPyEndAllowThreads(__tstate);
21470 if (PyErr_Occurred()) SWIG_fail;
21471 }
21472 {
21473 resultobj = SWIG_From_int((int)(result));
21474 }
21475 {
21476 if (temp3) delete arg3;
21477 }
21478 return resultobj;
21479 fail:
21480 {
21481 if (temp3) delete arg3;
21482 }
21483 return NULL;
21484 }
21485
21486
21487 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21488 PyObject *resultobj;
21489 wxDateTime *arg1 = (wxDateTime *) 0 ;
21490 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21491 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21492 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21493 int result;
21494 bool temp3 = false ;
21495 PyObject * obj0 = 0 ;
21496 PyObject * obj1 = 0 ;
21497 PyObject * obj2 = 0 ;
21498 char *kwnames[] = {
21499 (char *) "self",(char *) "flags",(char *) "tz", NULL
21500 };
21501
21502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21504 if (SWIG_arg_fail(1)) SWIG_fail;
21505 if (obj1) {
21506 {
21507 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21508 if (SWIG_arg_fail(2)) SWIG_fail;
21509 }
21510 }
21511 if (obj2) {
21512 {
21513 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21514 temp3 = true;
21515 }
21516 }
21517 {
21518 PyThreadState* __tstate = wxPyBeginAllowThreads();
21519 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21520
21521 wxPyEndAllowThreads(__tstate);
21522 if (PyErr_Occurred()) SWIG_fail;
21523 }
21524 {
21525 resultobj = SWIG_From_int((int)(result));
21526 }
21527 {
21528 if (temp3) delete arg3;
21529 }
21530 return resultobj;
21531 fail:
21532 {
21533 if (temp3) delete arg3;
21534 }
21535 return NULL;
21536 }
21537
21538
21539 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21540 PyObject *resultobj;
21541 wxDateTime *arg1 = (wxDateTime *) 0 ;
21542 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21543 bool result;
21544 PyObject * obj0 = 0 ;
21545 PyObject * obj1 = 0 ;
21546 char *kwnames[] = {
21547 (char *) "self",(char *) "country", NULL
21548 };
21549
21550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21552 if (SWIG_arg_fail(1)) SWIG_fail;
21553 if (obj1) {
21554 {
21555 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21556 if (SWIG_arg_fail(2)) SWIG_fail;
21557 }
21558 }
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21562
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 {
21567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21568 }
21569 return resultobj;
21570 fail:
21571 return NULL;
21572 }
21573
21574
21575 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21576 PyObject *resultobj;
21577 wxDateTime *arg1 = (wxDateTime *) 0 ;
21578 wxDateTime *arg2 = 0 ;
21579 bool result;
21580 PyObject * obj0 = 0 ;
21581 PyObject * obj1 = 0 ;
21582 char *kwnames[] = {
21583 (char *) "self",(char *) "datetime", NULL
21584 };
21585
21586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21588 if (SWIG_arg_fail(1)) SWIG_fail;
21589 {
21590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21591 if (SWIG_arg_fail(2)) SWIG_fail;
21592 if (arg2 == NULL) {
21593 SWIG_null_ref("wxDateTime");
21594 }
21595 if (SWIG_arg_fail(2)) SWIG_fail;
21596 }
21597 {
21598 PyThreadState* __tstate = wxPyBeginAllowThreads();
21599 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21600
21601 wxPyEndAllowThreads(__tstate);
21602 if (PyErr_Occurred()) SWIG_fail;
21603 }
21604 {
21605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21606 }
21607 return resultobj;
21608 fail:
21609 return NULL;
21610 }
21611
21612
21613 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21614 PyObject *resultobj;
21615 wxDateTime *arg1 = (wxDateTime *) 0 ;
21616 wxDateTime *arg2 = 0 ;
21617 bool result;
21618 PyObject * obj0 = 0 ;
21619 PyObject * obj1 = 0 ;
21620 char *kwnames[] = {
21621 (char *) "self",(char *) "datetime", NULL
21622 };
21623
21624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21626 if (SWIG_arg_fail(1)) SWIG_fail;
21627 {
21628 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21629 if (SWIG_arg_fail(2)) SWIG_fail;
21630 if (arg2 == NULL) {
21631 SWIG_null_ref("wxDateTime");
21632 }
21633 if (SWIG_arg_fail(2)) SWIG_fail;
21634 }
21635 {
21636 PyThreadState* __tstate = wxPyBeginAllowThreads();
21637 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21638
21639 wxPyEndAllowThreads(__tstate);
21640 if (PyErr_Occurred()) SWIG_fail;
21641 }
21642 {
21643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21644 }
21645 return resultobj;
21646 fail:
21647 return NULL;
21648 }
21649
21650
21651 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21652 PyObject *resultobj;
21653 wxDateTime *arg1 = (wxDateTime *) 0 ;
21654 wxDateTime *arg2 = 0 ;
21655 bool result;
21656 PyObject * obj0 = 0 ;
21657 PyObject * obj1 = 0 ;
21658 char *kwnames[] = {
21659 (char *) "self",(char *) "datetime", NULL
21660 };
21661
21662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21664 if (SWIG_arg_fail(1)) SWIG_fail;
21665 {
21666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21667 if (SWIG_arg_fail(2)) SWIG_fail;
21668 if (arg2 == NULL) {
21669 SWIG_null_ref("wxDateTime");
21670 }
21671 if (SWIG_arg_fail(2)) SWIG_fail;
21672 }
21673 {
21674 PyThreadState* __tstate = wxPyBeginAllowThreads();
21675 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21676
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 {
21681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21682 }
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21690 PyObject *resultobj;
21691 wxDateTime *arg1 = (wxDateTime *) 0 ;
21692 wxDateTime *arg2 = 0 ;
21693 wxDateTime *arg3 = 0 ;
21694 bool result;
21695 PyObject * obj0 = 0 ;
21696 PyObject * obj1 = 0 ;
21697 PyObject * obj2 = 0 ;
21698 char *kwnames[] = {
21699 (char *) "self",(char *) "t1",(char *) "t2", NULL
21700 };
21701
21702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21704 if (SWIG_arg_fail(1)) SWIG_fail;
21705 {
21706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21707 if (SWIG_arg_fail(2)) SWIG_fail;
21708 if (arg2 == NULL) {
21709 SWIG_null_ref("wxDateTime");
21710 }
21711 if (SWIG_arg_fail(2)) SWIG_fail;
21712 }
21713 {
21714 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21715 if (SWIG_arg_fail(3)) SWIG_fail;
21716 if (arg3 == NULL) {
21717 SWIG_null_ref("wxDateTime");
21718 }
21719 if (SWIG_arg_fail(3)) SWIG_fail;
21720 }
21721 {
21722 PyThreadState* __tstate = wxPyBeginAllowThreads();
21723 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21724
21725 wxPyEndAllowThreads(__tstate);
21726 if (PyErr_Occurred()) SWIG_fail;
21727 }
21728 {
21729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21730 }
21731 return resultobj;
21732 fail:
21733 return NULL;
21734 }
21735
21736
21737 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21738 PyObject *resultobj;
21739 wxDateTime *arg1 = (wxDateTime *) 0 ;
21740 wxDateTime *arg2 = 0 ;
21741 wxDateTime *arg3 = 0 ;
21742 bool result;
21743 PyObject * obj0 = 0 ;
21744 PyObject * obj1 = 0 ;
21745 PyObject * obj2 = 0 ;
21746 char *kwnames[] = {
21747 (char *) "self",(char *) "t1",(char *) "t2", NULL
21748 };
21749
21750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21752 if (SWIG_arg_fail(1)) SWIG_fail;
21753 {
21754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21755 if (SWIG_arg_fail(2)) SWIG_fail;
21756 if (arg2 == NULL) {
21757 SWIG_null_ref("wxDateTime");
21758 }
21759 if (SWIG_arg_fail(2)) SWIG_fail;
21760 }
21761 {
21762 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21763 if (SWIG_arg_fail(3)) SWIG_fail;
21764 if (arg3 == NULL) {
21765 SWIG_null_ref("wxDateTime");
21766 }
21767 if (SWIG_arg_fail(3)) SWIG_fail;
21768 }
21769 {
21770 PyThreadState* __tstate = wxPyBeginAllowThreads();
21771 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21772
21773 wxPyEndAllowThreads(__tstate);
21774 if (PyErr_Occurred()) SWIG_fail;
21775 }
21776 {
21777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21778 }
21779 return resultobj;
21780 fail:
21781 return NULL;
21782 }
21783
21784
21785 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
21786 PyObject *resultobj;
21787 wxDateTime *arg1 = (wxDateTime *) 0 ;
21788 wxDateTime *arg2 = 0 ;
21789 bool result;
21790 PyObject * obj0 = 0 ;
21791 PyObject * obj1 = 0 ;
21792 char *kwnames[] = {
21793 (char *) "self",(char *) "dt", NULL
21794 };
21795
21796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
21797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21798 if (SWIG_arg_fail(1)) SWIG_fail;
21799 {
21800 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21801 if (SWIG_arg_fail(2)) SWIG_fail;
21802 if (arg2 == NULL) {
21803 SWIG_null_ref("wxDateTime");
21804 }
21805 if (SWIG_arg_fail(2)) SWIG_fail;
21806 }
21807 {
21808 PyThreadState* __tstate = wxPyBeginAllowThreads();
21809 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
21810
21811 wxPyEndAllowThreads(__tstate);
21812 if (PyErr_Occurred()) SWIG_fail;
21813 }
21814 {
21815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21816 }
21817 return resultobj;
21818 fail:
21819 return NULL;
21820 }
21821
21822
21823 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
21824 PyObject *resultobj;
21825 wxDateTime *arg1 = (wxDateTime *) 0 ;
21826 wxDateTime *arg2 = 0 ;
21827 bool result;
21828 PyObject * obj0 = 0 ;
21829 PyObject * obj1 = 0 ;
21830 char *kwnames[] = {
21831 (char *) "self",(char *) "dt", NULL
21832 };
21833
21834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
21835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21836 if (SWIG_arg_fail(1)) SWIG_fail;
21837 {
21838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21839 if (SWIG_arg_fail(2)) SWIG_fail;
21840 if (arg2 == NULL) {
21841 SWIG_null_ref("wxDateTime");
21842 }
21843 if (SWIG_arg_fail(2)) SWIG_fail;
21844 }
21845 {
21846 PyThreadState* __tstate = wxPyBeginAllowThreads();
21847 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
21848
21849 wxPyEndAllowThreads(__tstate);
21850 if (PyErr_Occurred()) SWIG_fail;
21851 }
21852 {
21853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21854 }
21855 return resultobj;
21856 fail:
21857 return NULL;
21858 }
21859
21860
21861 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
21862 PyObject *resultobj;
21863 wxDateTime *arg1 = (wxDateTime *) 0 ;
21864 wxDateTime *arg2 = 0 ;
21865 wxTimeSpan *arg3 = 0 ;
21866 bool result;
21867 PyObject * obj0 = 0 ;
21868 PyObject * obj1 = 0 ;
21869 PyObject * obj2 = 0 ;
21870 char *kwnames[] = {
21871 (char *) "self",(char *) "dt",(char *) "ts", NULL
21872 };
21873
21874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21876 if (SWIG_arg_fail(1)) SWIG_fail;
21877 {
21878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21879 if (SWIG_arg_fail(2)) SWIG_fail;
21880 if (arg2 == NULL) {
21881 SWIG_null_ref("wxDateTime");
21882 }
21883 if (SWIG_arg_fail(2)) SWIG_fail;
21884 }
21885 {
21886 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21887 if (SWIG_arg_fail(3)) SWIG_fail;
21888 if (arg3 == NULL) {
21889 SWIG_null_ref("wxTimeSpan");
21890 }
21891 if (SWIG_arg_fail(3)) SWIG_fail;
21892 }
21893 {
21894 PyThreadState* __tstate = wxPyBeginAllowThreads();
21895 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
21896
21897 wxPyEndAllowThreads(__tstate);
21898 if (PyErr_Occurred()) SWIG_fail;
21899 }
21900 {
21901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21902 }
21903 return resultobj;
21904 fail:
21905 return NULL;
21906 }
21907
21908
21909 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
21910 PyObject *resultobj;
21911 wxDateTime *arg1 = (wxDateTime *) 0 ;
21912 wxTimeSpan *arg2 = 0 ;
21913 wxDateTime *result;
21914 PyObject * obj0 = 0 ;
21915 PyObject * obj1 = 0 ;
21916 char *kwnames[] = {
21917 (char *) "self",(char *) "diff", NULL
21918 };
21919
21920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
21921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21922 if (SWIG_arg_fail(1)) SWIG_fail;
21923 {
21924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21925 if (SWIG_arg_fail(2)) SWIG_fail;
21926 if (arg2 == NULL) {
21927 SWIG_null_ref("wxTimeSpan");
21928 }
21929 if (SWIG_arg_fail(2)) SWIG_fail;
21930 }
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 {
21934 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
21935 result = (wxDateTime *) &_result_ref;
21936 }
21937
21938 wxPyEndAllowThreads(__tstate);
21939 if (PyErr_Occurred()) SWIG_fail;
21940 }
21941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21942 return resultobj;
21943 fail:
21944 return NULL;
21945 }
21946
21947
21948 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
21949 PyObject *resultobj;
21950 wxDateTime *arg1 = (wxDateTime *) 0 ;
21951 wxDateSpan *arg2 = 0 ;
21952 wxDateTime *result;
21953 PyObject * obj0 = 0 ;
21954 PyObject * obj1 = 0 ;
21955 char *kwnames[] = {
21956 (char *) "self",(char *) "diff", NULL
21957 };
21958
21959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
21960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21961 if (SWIG_arg_fail(1)) SWIG_fail;
21962 {
21963 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
21964 if (SWIG_arg_fail(2)) SWIG_fail;
21965 if (arg2 == NULL) {
21966 SWIG_null_ref("wxDateSpan");
21967 }
21968 if (SWIG_arg_fail(2)) SWIG_fail;
21969 }
21970 {
21971 PyThreadState* __tstate = wxPyBeginAllowThreads();
21972 {
21973 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
21974 result = (wxDateTime *) &_result_ref;
21975 }
21976
21977 wxPyEndAllowThreads(__tstate);
21978 if (PyErr_Occurred()) SWIG_fail;
21979 }
21980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21981 return resultobj;
21982 fail:
21983 return NULL;
21984 }
21985
21986
21987 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
21988 PyObject *resultobj;
21989 wxDateTime *arg1 = (wxDateTime *) 0 ;
21990 wxTimeSpan *arg2 = 0 ;
21991 wxDateTime *result;
21992 PyObject * obj0 = 0 ;
21993 PyObject * obj1 = 0 ;
21994 char *kwnames[] = {
21995 (char *) "self",(char *) "diff", NULL
21996 };
21997
21998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
21999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22000 if (SWIG_arg_fail(1)) SWIG_fail;
22001 {
22002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22003 if (SWIG_arg_fail(2)) SWIG_fail;
22004 if (arg2 == NULL) {
22005 SWIG_null_ref("wxTimeSpan");
22006 }
22007 if (SWIG_arg_fail(2)) SWIG_fail;
22008 }
22009 {
22010 PyThreadState* __tstate = wxPyBeginAllowThreads();
22011 {
22012 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22013 result = (wxDateTime *) &_result_ref;
22014 }
22015
22016 wxPyEndAllowThreads(__tstate);
22017 if (PyErr_Occurred()) SWIG_fail;
22018 }
22019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22027 PyObject *resultobj;
22028 wxDateTime *arg1 = (wxDateTime *) 0 ;
22029 wxDateSpan *arg2 = 0 ;
22030 wxDateTime *result;
22031 PyObject * obj0 = 0 ;
22032 PyObject * obj1 = 0 ;
22033 char *kwnames[] = {
22034 (char *) "self",(char *) "diff", NULL
22035 };
22036
22037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22039 if (SWIG_arg_fail(1)) SWIG_fail;
22040 {
22041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22042 if (SWIG_arg_fail(2)) SWIG_fail;
22043 if (arg2 == NULL) {
22044 SWIG_null_ref("wxDateSpan");
22045 }
22046 if (SWIG_arg_fail(2)) SWIG_fail;
22047 }
22048 {
22049 PyThreadState* __tstate = wxPyBeginAllowThreads();
22050 {
22051 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22052 result = (wxDateTime *) &_result_ref;
22053 }
22054
22055 wxPyEndAllowThreads(__tstate);
22056 if (PyErr_Occurred()) SWIG_fail;
22057 }
22058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22059 return resultobj;
22060 fail:
22061 return NULL;
22062 }
22063
22064
22065 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22066 PyObject *resultobj;
22067 wxDateTime *arg1 = (wxDateTime *) 0 ;
22068 wxDateTime *arg2 = 0 ;
22069 wxTimeSpan result;
22070 PyObject * obj0 = 0 ;
22071 PyObject * obj1 = 0 ;
22072 char *kwnames[] = {
22073 (char *) "self",(char *) "dt", NULL
22074 };
22075
22076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22078 if (SWIG_arg_fail(1)) SWIG_fail;
22079 {
22080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22081 if (SWIG_arg_fail(2)) SWIG_fail;
22082 if (arg2 == NULL) {
22083 SWIG_null_ref("wxDateTime");
22084 }
22085 if (SWIG_arg_fail(2)) SWIG_fail;
22086 }
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22090
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 {
22095 wxTimeSpan * resultptr;
22096 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22098 }
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22106 PyObject *resultobj;
22107 wxDateTime *arg1 = (wxDateTime *) 0 ;
22108 wxTimeSpan *arg2 = 0 ;
22109 wxDateTime *result;
22110 PyObject * obj0 = 0 ;
22111 PyObject * obj1 = 0 ;
22112
22113 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22115 if (SWIG_arg_fail(1)) SWIG_fail;
22116 {
22117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22118 if (SWIG_arg_fail(2)) SWIG_fail;
22119 if (arg2 == NULL) {
22120 SWIG_null_ref("wxTimeSpan");
22121 }
22122 if (SWIG_arg_fail(2)) SWIG_fail;
22123 }
22124 {
22125 PyThreadState* __tstate = wxPyBeginAllowThreads();
22126 {
22127 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22128 result = (wxDateTime *) &_result_ref;
22129 }
22130
22131 wxPyEndAllowThreads(__tstate);
22132 if (PyErr_Occurred()) SWIG_fail;
22133 }
22134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22135 return resultobj;
22136 fail:
22137 return NULL;
22138 }
22139
22140
22141 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22142 PyObject *resultobj;
22143 wxDateTime *arg1 = (wxDateTime *) 0 ;
22144 wxDateSpan *arg2 = 0 ;
22145 wxDateTime *result;
22146 PyObject * obj0 = 0 ;
22147 PyObject * obj1 = 0 ;
22148
22149 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22151 if (SWIG_arg_fail(1)) SWIG_fail;
22152 {
22153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22154 if (SWIG_arg_fail(2)) SWIG_fail;
22155 if (arg2 == NULL) {
22156 SWIG_null_ref("wxDateSpan");
22157 }
22158 if (SWIG_arg_fail(2)) SWIG_fail;
22159 }
22160 {
22161 PyThreadState* __tstate = wxPyBeginAllowThreads();
22162 {
22163 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22164 result = (wxDateTime *) &_result_ref;
22165 }
22166
22167 wxPyEndAllowThreads(__tstate);
22168 if (PyErr_Occurred()) SWIG_fail;
22169 }
22170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22171 return resultobj;
22172 fail:
22173 return NULL;
22174 }
22175
22176
22177 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22178 int argc;
22179 PyObject *argv[3];
22180 int ii;
22181
22182 argc = PyObject_Length(args);
22183 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22184 argv[ii] = PyTuple_GetItem(args,ii);
22185 }
22186 if (argc == 2) {
22187 int _v;
22188 {
22189 void *ptr;
22190 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22191 _v = 0;
22192 PyErr_Clear();
22193 } else {
22194 _v = 1;
22195 }
22196 }
22197 if (_v) {
22198 {
22199 void *ptr = 0;
22200 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22201 _v = 0;
22202 PyErr_Clear();
22203 } else {
22204 _v = (ptr != 0);
22205 }
22206 }
22207 if (_v) {
22208 return _wrap_DateTime___iadd____SWIG_0(self,args);
22209 }
22210 }
22211 }
22212 if (argc == 2) {
22213 int _v;
22214 {
22215 void *ptr;
22216 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22217 _v = 0;
22218 PyErr_Clear();
22219 } else {
22220 _v = 1;
22221 }
22222 }
22223 if (_v) {
22224 {
22225 void *ptr = 0;
22226 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22227 _v = 0;
22228 PyErr_Clear();
22229 } else {
22230 _v = (ptr != 0);
22231 }
22232 }
22233 if (_v) {
22234 return _wrap_DateTime___iadd____SWIG_1(self,args);
22235 }
22236 }
22237 }
22238
22239 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22240 return NULL;
22241 }
22242
22243
22244 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22245 PyObject *resultobj;
22246 wxDateTime *arg1 = (wxDateTime *) 0 ;
22247 wxTimeSpan *arg2 = 0 ;
22248 wxDateTime *result;
22249 PyObject * obj0 = 0 ;
22250 PyObject * obj1 = 0 ;
22251
22252 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22254 if (SWIG_arg_fail(1)) SWIG_fail;
22255 {
22256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22257 if (SWIG_arg_fail(2)) SWIG_fail;
22258 if (arg2 == NULL) {
22259 SWIG_null_ref("wxTimeSpan");
22260 }
22261 if (SWIG_arg_fail(2)) SWIG_fail;
22262 }
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 {
22266 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22267 result = (wxDateTime *) &_result_ref;
22268 }
22269
22270 wxPyEndAllowThreads(__tstate);
22271 if (PyErr_Occurred()) SWIG_fail;
22272 }
22273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22274 return resultobj;
22275 fail:
22276 return NULL;
22277 }
22278
22279
22280 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22281 PyObject *resultobj;
22282 wxDateTime *arg1 = (wxDateTime *) 0 ;
22283 wxDateSpan *arg2 = 0 ;
22284 wxDateTime *result;
22285 PyObject * obj0 = 0 ;
22286 PyObject * obj1 = 0 ;
22287
22288 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22290 if (SWIG_arg_fail(1)) SWIG_fail;
22291 {
22292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22293 if (SWIG_arg_fail(2)) SWIG_fail;
22294 if (arg2 == NULL) {
22295 SWIG_null_ref("wxDateSpan");
22296 }
22297 if (SWIG_arg_fail(2)) SWIG_fail;
22298 }
22299 {
22300 PyThreadState* __tstate = wxPyBeginAllowThreads();
22301 {
22302 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22303 result = (wxDateTime *) &_result_ref;
22304 }
22305
22306 wxPyEndAllowThreads(__tstate);
22307 if (PyErr_Occurred()) SWIG_fail;
22308 }
22309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22310 return resultobj;
22311 fail:
22312 return NULL;
22313 }
22314
22315
22316 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22317 int argc;
22318 PyObject *argv[3];
22319 int ii;
22320
22321 argc = PyObject_Length(args);
22322 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22323 argv[ii] = PyTuple_GetItem(args,ii);
22324 }
22325 if (argc == 2) {
22326 int _v;
22327 {
22328 void *ptr;
22329 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22330 _v = 0;
22331 PyErr_Clear();
22332 } else {
22333 _v = 1;
22334 }
22335 }
22336 if (_v) {
22337 {
22338 void *ptr = 0;
22339 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22340 _v = 0;
22341 PyErr_Clear();
22342 } else {
22343 _v = (ptr != 0);
22344 }
22345 }
22346 if (_v) {
22347 return _wrap_DateTime___isub____SWIG_0(self,args);
22348 }
22349 }
22350 }
22351 if (argc == 2) {
22352 int _v;
22353 {
22354 void *ptr;
22355 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22356 _v = 0;
22357 PyErr_Clear();
22358 } else {
22359 _v = 1;
22360 }
22361 }
22362 if (_v) {
22363 {
22364 void *ptr = 0;
22365 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22366 _v = 0;
22367 PyErr_Clear();
22368 } else {
22369 _v = (ptr != 0);
22370 }
22371 }
22372 if (_v) {
22373 return _wrap_DateTime___isub____SWIG_1(self,args);
22374 }
22375 }
22376 }
22377
22378 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22379 return NULL;
22380 }
22381
22382
22383 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22384 PyObject *resultobj;
22385 wxDateTime *arg1 = (wxDateTime *) 0 ;
22386 wxTimeSpan *arg2 = 0 ;
22387 wxDateTime result;
22388 PyObject * obj0 = 0 ;
22389 PyObject * obj1 = 0 ;
22390
22391 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22393 if (SWIG_arg_fail(1)) SWIG_fail;
22394 {
22395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22396 if (SWIG_arg_fail(2)) SWIG_fail;
22397 if (arg2 == NULL) {
22398 SWIG_null_ref("wxTimeSpan");
22399 }
22400 if (SWIG_arg_fail(2)) SWIG_fail;
22401 }
22402 {
22403 PyThreadState* __tstate = wxPyBeginAllowThreads();
22404 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22405
22406 wxPyEndAllowThreads(__tstate);
22407 if (PyErr_Occurred()) SWIG_fail;
22408 }
22409 {
22410 wxDateTime * resultptr;
22411 resultptr = new wxDateTime((wxDateTime &)(result));
22412 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22413 }
22414 return resultobj;
22415 fail:
22416 return NULL;
22417 }
22418
22419
22420 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22421 PyObject *resultobj;
22422 wxDateTime *arg1 = (wxDateTime *) 0 ;
22423 wxDateSpan *arg2 = 0 ;
22424 wxDateTime result;
22425 PyObject * obj0 = 0 ;
22426 PyObject * obj1 = 0 ;
22427
22428 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22430 if (SWIG_arg_fail(1)) SWIG_fail;
22431 {
22432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22433 if (SWIG_arg_fail(2)) SWIG_fail;
22434 if (arg2 == NULL) {
22435 SWIG_null_ref("wxDateSpan");
22436 }
22437 if (SWIG_arg_fail(2)) SWIG_fail;
22438 }
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22442
22443 wxPyEndAllowThreads(__tstate);
22444 if (PyErr_Occurred()) SWIG_fail;
22445 }
22446 {
22447 wxDateTime * resultptr;
22448 resultptr = new wxDateTime((wxDateTime &)(result));
22449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22450 }
22451 return resultobj;
22452 fail:
22453 return NULL;
22454 }
22455
22456
22457 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22458 int argc;
22459 PyObject *argv[3];
22460 int ii;
22461
22462 argc = PyObject_Length(args);
22463 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22464 argv[ii] = PyTuple_GetItem(args,ii);
22465 }
22466 if (argc == 2) {
22467 int _v;
22468 {
22469 void *ptr;
22470 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22471 _v = 0;
22472 PyErr_Clear();
22473 } else {
22474 _v = 1;
22475 }
22476 }
22477 if (_v) {
22478 {
22479 void *ptr = 0;
22480 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22481 _v = 0;
22482 PyErr_Clear();
22483 } else {
22484 _v = (ptr != 0);
22485 }
22486 }
22487 if (_v) {
22488 return _wrap_DateTime___add____SWIG_0(self,args);
22489 }
22490 }
22491 }
22492 if (argc == 2) {
22493 int _v;
22494 {
22495 void *ptr;
22496 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22497 _v = 0;
22498 PyErr_Clear();
22499 } else {
22500 _v = 1;
22501 }
22502 }
22503 if (_v) {
22504 {
22505 void *ptr = 0;
22506 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22507 _v = 0;
22508 PyErr_Clear();
22509 } else {
22510 _v = (ptr != 0);
22511 }
22512 }
22513 if (_v) {
22514 return _wrap_DateTime___add____SWIG_1(self,args);
22515 }
22516 }
22517 }
22518
22519 Py_INCREF(Py_NotImplemented);
22520 return Py_NotImplemented;
22521 }
22522
22523
22524 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22525 PyObject *resultobj;
22526 wxDateTime *arg1 = (wxDateTime *) 0 ;
22527 wxDateTime *arg2 = 0 ;
22528 wxTimeSpan result;
22529 PyObject * obj0 = 0 ;
22530 PyObject * obj1 = 0 ;
22531
22532 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22534 if (SWIG_arg_fail(1)) SWIG_fail;
22535 {
22536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22537 if (SWIG_arg_fail(2)) SWIG_fail;
22538 if (arg2 == NULL) {
22539 SWIG_null_ref("wxDateTime");
22540 }
22541 if (SWIG_arg_fail(2)) SWIG_fail;
22542 }
22543 {
22544 PyThreadState* __tstate = wxPyBeginAllowThreads();
22545 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22546
22547 wxPyEndAllowThreads(__tstate);
22548 if (PyErr_Occurred()) SWIG_fail;
22549 }
22550 {
22551 wxTimeSpan * resultptr;
22552 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22554 }
22555 return resultobj;
22556 fail:
22557 return NULL;
22558 }
22559
22560
22561 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22562 PyObject *resultobj;
22563 wxDateTime *arg1 = (wxDateTime *) 0 ;
22564 wxTimeSpan *arg2 = 0 ;
22565 wxDateTime result;
22566 PyObject * obj0 = 0 ;
22567 PyObject * obj1 = 0 ;
22568
22569 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22571 if (SWIG_arg_fail(1)) SWIG_fail;
22572 {
22573 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22574 if (SWIG_arg_fail(2)) SWIG_fail;
22575 if (arg2 == NULL) {
22576 SWIG_null_ref("wxTimeSpan");
22577 }
22578 if (SWIG_arg_fail(2)) SWIG_fail;
22579 }
22580 {
22581 PyThreadState* __tstate = wxPyBeginAllowThreads();
22582 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22583
22584 wxPyEndAllowThreads(__tstate);
22585 if (PyErr_Occurred()) SWIG_fail;
22586 }
22587 {
22588 wxDateTime * resultptr;
22589 resultptr = new wxDateTime((wxDateTime &)(result));
22590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22591 }
22592 return resultobj;
22593 fail:
22594 return NULL;
22595 }
22596
22597
22598 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22599 PyObject *resultobj;
22600 wxDateTime *arg1 = (wxDateTime *) 0 ;
22601 wxDateSpan *arg2 = 0 ;
22602 wxDateTime result;
22603 PyObject * obj0 = 0 ;
22604 PyObject * obj1 = 0 ;
22605
22606 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22608 if (SWIG_arg_fail(1)) SWIG_fail;
22609 {
22610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22611 if (SWIG_arg_fail(2)) SWIG_fail;
22612 if (arg2 == NULL) {
22613 SWIG_null_ref("wxDateSpan");
22614 }
22615 if (SWIG_arg_fail(2)) SWIG_fail;
22616 }
22617 {
22618 PyThreadState* __tstate = wxPyBeginAllowThreads();
22619 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22620
22621 wxPyEndAllowThreads(__tstate);
22622 if (PyErr_Occurred()) SWIG_fail;
22623 }
22624 {
22625 wxDateTime * resultptr;
22626 resultptr = new wxDateTime((wxDateTime &)(result));
22627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22628 }
22629 return resultobj;
22630 fail:
22631 return NULL;
22632 }
22633
22634
22635 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22636 int argc;
22637 PyObject *argv[3];
22638 int ii;
22639
22640 argc = PyObject_Length(args);
22641 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22642 argv[ii] = PyTuple_GetItem(args,ii);
22643 }
22644 if (argc == 2) {
22645 int _v;
22646 {
22647 void *ptr;
22648 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22649 _v = 0;
22650 PyErr_Clear();
22651 } else {
22652 _v = 1;
22653 }
22654 }
22655 if (_v) {
22656 {
22657 void *ptr = 0;
22658 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22659 _v = 0;
22660 PyErr_Clear();
22661 } else {
22662 _v = (ptr != 0);
22663 }
22664 }
22665 if (_v) {
22666 return _wrap_DateTime___sub____SWIG_0(self,args);
22667 }
22668 }
22669 }
22670 if (argc == 2) {
22671 int _v;
22672 {
22673 void *ptr;
22674 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22675 _v = 0;
22676 PyErr_Clear();
22677 } else {
22678 _v = 1;
22679 }
22680 }
22681 if (_v) {
22682 {
22683 void *ptr = 0;
22684 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22685 _v = 0;
22686 PyErr_Clear();
22687 } else {
22688 _v = (ptr != 0);
22689 }
22690 }
22691 if (_v) {
22692 return _wrap_DateTime___sub____SWIG_1(self,args);
22693 }
22694 }
22695 }
22696 if (argc == 2) {
22697 int _v;
22698 {
22699 void *ptr;
22700 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22701 _v = 0;
22702 PyErr_Clear();
22703 } else {
22704 _v = 1;
22705 }
22706 }
22707 if (_v) {
22708 {
22709 void *ptr = 0;
22710 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22711 _v = 0;
22712 PyErr_Clear();
22713 } else {
22714 _v = (ptr != 0);
22715 }
22716 }
22717 if (_v) {
22718 return _wrap_DateTime___sub____SWIG_2(self,args);
22719 }
22720 }
22721 }
22722
22723 Py_INCREF(Py_NotImplemented);
22724 return Py_NotImplemented;
22725 }
22726
22727
22728 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
22729 PyObject *resultobj;
22730 wxDateTime *arg1 = (wxDateTime *) 0 ;
22731 wxDateTime *arg2 = (wxDateTime *) 0 ;
22732 bool result;
22733 PyObject * obj0 = 0 ;
22734 PyObject * obj1 = 0 ;
22735 char *kwnames[] = {
22736 (char *) "self",(char *) "other", NULL
22737 };
22738
22739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
22740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22741 if (SWIG_arg_fail(1)) SWIG_fail;
22742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22743 if (SWIG_arg_fail(2)) SWIG_fail;
22744 {
22745 PyThreadState* __tstate = wxPyBeginAllowThreads();
22746 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22747
22748 wxPyEndAllowThreads(__tstate);
22749 if (PyErr_Occurred()) SWIG_fail;
22750 }
22751 {
22752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22753 }
22754 return resultobj;
22755 fail:
22756 return NULL;
22757 }
22758
22759
22760 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
22761 PyObject *resultobj;
22762 wxDateTime *arg1 = (wxDateTime *) 0 ;
22763 wxDateTime *arg2 = (wxDateTime *) 0 ;
22764 bool result;
22765 PyObject * obj0 = 0 ;
22766 PyObject * obj1 = 0 ;
22767 char *kwnames[] = {
22768 (char *) "self",(char *) "other", NULL
22769 };
22770
22771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
22772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22773 if (SWIG_arg_fail(1)) SWIG_fail;
22774 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22775 if (SWIG_arg_fail(2)) SWIG_fail;
22776 {
22777 PyThreadState* __tstate = wxPyBeginAllowThreads();
22778 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
22779
22780 wxPyEndAllowThreads(__tstate);
22781 if (PyErr_Occurred()) SWIG_fail;
22782 }
22783 {
22784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22785 }
22786 return resultobj;
22787 fail:
22788 return NULL;
22789 }
22790
22791
22792 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
22793 PyObject *resultobj;
22794 wxDateTime *arg1 = (wxDateTime *) 0 ;
22795 wxDateTime *arg2 = (wxDateTime *) 0 ;
22796 bool result;
22797 PyObject * obj0 = 0 ;
22798 PyObject * obj1 = 0 ;
22799 char *kwnames[] = {
22800 (char *) "self",(char *) "other", NULL
22801 };
22802
22803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
22804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22805 if (SWIG_arg_fail(1)) SWIG_fail;
22806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22807 if (SWIG_arg_fail(2)) SWIG_fail;
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
22811
22812 wxPyEndAllowThreads(__tstate);
22813 if (PyErr_Occurred()) SWIG_fail;
22814 }
22815 {
22816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22817 }
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
22825 PyObject *resultobj;
22826 wxDateTime *arg1 = (wxDateTime *) 0 ;
22827 wxDateTime *arg2 = (wxDateTime *) 0 ;
22828 bool result;
22829 PyObject * obj0 = 0 ;
22830 PyObject * obj1 = 0 ;
22831 char *kwnames[] = {
22832 (char *) "self",(char *) "other", NULL
22833 };
22834
22835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
22836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22837 if (SWIG_arg_fail(1)) SWIG_fail;
22838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22839 if (SWIG_arg_fail(2)) SWIG_fail;
22840 {
22841 PyThreadState* __tstate = wxPyBeginAllowThreads();
22842 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
22843
22844 wxPyEndAllowThreads(__tstate);
22845 if (PyErr_Occurred()) SWIG_fail;
22846 }
22847 {
22848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22849 }
22850 return resultobj;
22851 fail:
22852 return NULL;
22853 }
22854
22855
22856 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
22857 PyObject *resultobj;
22858 wxDateTime *arg1 = (wxDateTime *) 0 ;
22859 wxDateTime *arg2 = (wxDateTime *) 0 ;
22860 bool result;
22861 PyObject * obj0 = 0 ;
22862 PyObject * obj1 = 0 ;
22863 char *kwnames[] = {
22864 (char *) "self",(char *) "other", NULL
22865 };
22866
22867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
22868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22869 if (SWIG_arg_fail(1)) SWIG_fail;
22870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22871 if (SWIG_arg_fail(2)) SWIG_fail;
22872 {
22873 PyThreadState* __tstate = wxPyBeginAllowThreads();
22874 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
22875
22876 wxPyEndAllowThreads(__tstate);
22877 if (PyErr_Occurred()) SWIG_fail;
22878 }
22879 {
22880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22881 }
22882 return resultobj;
22883 fail:
22884 return NULL;
22885 }
22886
22887
22888 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
22889 PyObject *resultobj;
22890 wxDateTime *arg1 = (wxDateTime *) 0 ;
22891 wxDateTime *arg2 = (wxDateTime *) 0 ;
22892 bool result;
22893 PyObject * obj0 = 0 ;
22894 PyObject * obj1 = 0 ;
22895 char *kwnames[] = {
22896 (char *) "self",(char *) "other", NULL
22897 };
22898
22899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
22900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22901 if (SWIG_arg_fail(1)) SWIG_fail;
22902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22903 if (SWIG_arg_fail(2)) SWIG_fail;
22904 {
22905 PyThreadState* __tstate = wxPyBeginAllowThreads();
22906 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
22907
22908 wxPyEndAllowThreads(__tstate);
22909 if (PyErr_Occurred()) SWIG_fail;
22910 }
22911 {
22912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22913 }
22914 return resultobj;
22915 fail:
22916 return NULL;
22917 }
22918
22919
22920 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
22921 PyObject *resultobj;
22922 wxDateTime *arg1 = (wxDateTime *) 0 ;
22923 wxString *arg2 = 0 ;
22924 int result;
22925 bool temp2 = false ;
22926 PyObject * obj0 = 0 ;
22927 PyObject * obj1 = 0 ;
22928 char *kwnames[] = {
22929 (char *) "self",(char *) "date", NULL
22930 };
22931
22932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
22933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22934 if (SWIG_arg_fail(1)) SWIG_fail;
22935 {
22936 arg2 = wxString_in_helper(obj1);
22937 if (arg2 == NULL) SWIG_fail;
22938 temp2 = true;
22939 }
22940 {
22941 PyThreadState* __tstate = wxPyBeginAllowThreads();
22942 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
22943
22944 wxPyEndAllowThreads(__tstate);
22945 if (PyErr_Occurred()) SWIG_fail;
22946 }
22947 {
22948 resultobj = SWIG_From_int((int)(result));
22949 }
22950 {
22951 if (temp2)
22952 delete arg2;
22953 }
22954 return resultobj;
22955 fail:
22956 {
22957 if (temp2)
22958 delete arg2;
22959 }
22960 return NULL;
22961 }
22962
22963
22964 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
22965 PyObject *resultobj;
22966 wxDateTime *arg1 = (wxDateTime *) 0 ;
22967 wxString *arg2 = 0 ;
22968 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
22969 wxString *arg3 = (wxString *) &arg3_defvalue ;
22970 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
22971 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
22972 int result;
22973 bool temp2 = false ;
22974 bool temp3 = false ;
22975 PyObject * obj0 = 0 ;
22976 PyObject * obj1 = 0 ;
22977 PyObject * obj2 = 0 ;
22978 PyObject * obj3 = 0 ;
22979 char *kwnames[] = {
22980 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
22981 };
22982
22983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22985 if (SWIG_arg_fail(1)) SWIG_fail;
22986 {
22987 arg2 = wxString_in_helper(obj1);
22988 if (arg2 == NULL) SWIG_fail;
22989 temp2 = true;
22990 }
22991 if (obj2) {
22992 {
22993 arg3 = wxString_in_helper(obj2);
22994 if (arg3 == NULL) SWIG_fail;
22995 temp3 = true;
22996 }
22997 }
22998 if (obj3) {
22999 {
23000 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23001 if (SWIG_arg_fail(4)) SWIG_fail;
23002 if (arg4 == NULL) {
23003 SWIG_null_ref("wxDateTime");
23004 }
23005 if (SWIG_arg_fail(4)) SWIG_fail;
23006 }
23007 }
23008 {
23009 PyThreadState* __tstate = wxPyBeginAllowThreads();
23010 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23011
23012 wxPyEndAllowThreads(__tstate);
23013 if (PyErr_Occurred()) SWIG_fail;
23014 }
23015 {
23016 resultobj = SWIG_From_int((int)(result));
23017 }
23018 {
23019 if (temp2)
23020 delete arg2;
23021 }
23022 {
23023 if (temp3)
23024 delete arg3;
23025 }
23026 return resultobj;
23027 fail:
23028 {
23029 if (temp2)
23030 delete arg2;
23031 }
23032 {
23033 if (temp3)
23034 delete arg3;
23035 }
23036 return NULL;
23037 }
23038
23039
23040 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23041 PyObject *resultobj;
23042 wxDateTime *arg1 = (wxDateTime *) 0 ;
23043 wxString *arg2 = 0 ;
23044 int result;
23045 bool temp2 = false ;
23046 PyObject * obj0 = 0 ;
23047 PyObject * obj1 = 0 ;
23048 char *kwnames[] = {
23049 (char *) "self",(char *) "datetime", NULL
23050 };
23051
23052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23054 if (SWIG_arg_fail(1)) SWIG_fail;
23055 {
23056 arg2 = wxString_in_helper(obj1);
23057 if (arg2 == NULL) SWIG_fail;
23058 temp2 = true;
23059 }
23060 {
23061 PyThreadState* __tstate = wxPyBeginAllowThreads();
23062 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23063
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 {
23068 resultobj = SWIG_From_int((int)(result));
23069 }
23070 {
23071 if (temp2)
23072 delete arg2;
23073 }
23074 return resultobj;
23075 fail:
23076 {
23077 if (temp2)
23078 delete arg2;
23079 }
23080 return NULL;
23081 }
23082
23083
23084 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23085 PyObject *resultobj;
23086 wxDateTime *arg1 = (wxDateTime *) 0 ;
23087 wxString *arg2 = 0 ;
23088 int result;
23089 bool temp2 = false ;
23090 PyObject * obj0 = 0 ;
23091 PyObject * obj1 = 0 ;
23092 char *kwnames[] = {
23093 (char *) "self",(char *) "date", NULL
23094 };
23095
23096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23098 if (SWIG_arg_fail(1)) SWIG_fail;
23099 {
23100 arg2 = wxString_in_helper(obj1);
23101 if (arg2 == NULL) SWIG_fail;
23102 temp2 = true;
23103 }
23104 {
23105 PyThreadState* __tstate = wxPyBeginAllowThreads();
23106 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23107
23108 wxPyEndAllowThreads(__tstate);
23109 if (PyErr_Occurred()) SWIG_fail;
23110 }
23111 {
23112 resultobj = SWIG_From_int((int)(result));
23113 }
23114 {
23115 if (temp2)
23116 delete arg2;
23117 }
23118 return resultobj;
23119 fail:
23120 {
23121 if (temp2)
23122 delete arg2;
23123 }
23124 return NULL;
23125 }
23126
23127
23128 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23129 PyObject *resultobj;
23130 wxDateTime *arg1 = (wxDateTime *) 0 ;
23131 wxString *arg2 = 0 ;
23132 int result;
23133 bool temp2 = false ;
23134 PyObject * obj0 = 0 ;
23135 PyObject * obj1 = 0 ;
23136 char *kwnames[] = {
23137 (char *) "self",(char *) "time", NULL
23138 };
23139
23140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23142 if (SWIG_arg_fail(1)) SWIG_fail;
23143 {
23144 arg2 = wxString_in_helper(obj1);
23145 if (arg2 == NULL) SWIG_fail;
23146 temp2 = true;
23147 }
23148 {
23149 PyThreadState* __tstate = wxPyBeginAllowThreads();
23150 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23151
23152 wxPyEndAllowThreads(__tstate);
23153 if (PyErr_Occurred()) SWIG_fail;
23154 }
23155 {
23156 resultobj = SWIG_From_int((int)(result));
23157 }
23158 {
23159 if (temp2)
23160 delete arg2;
23161 }
23162 return resultobj;
23163 fail:
23164 {
23165 if (temp2)
23166 delete arg2;
23167 }
23168 return NULL;
23169 }
23170
23171
23172 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23173 PyObject *resultobj;
23174 wxDateTime *arg1 = (wxDateTime *) 0 ;
23175 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23176 wxString *arg2 = (wxString *) &arg2_defvalue ;
23177 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23178 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23179 wxString result;
23180 bool temp2 = false ;
23181 bool temp3 = false ;
23182 PyObject * obj0 = 0 ;
23183 PyObject * obj1 = 0 ;
23184 PyObject * obj2 = 0 ;
23185 char *kwnames[] = {
23186 (char *) "self",(char *) "format",(char *) "tz", NULL
23187 };
23188
23189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23191 if (SWIG_arg_fail(1)) SWIG_fail;
23192 if (obj1) {
23193 {
23194 arg2 = wxString_in_helper(obj1);
23195 if (arg2 == NULL) SWIG_fail;
23196 temp2 = true;
23197 }
23198 }
23199 if (obj2) {
23200 {
23201 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23202 temp3 = true;
23203 }
23204 }
23205 {
23206 PyThreadState* __tstate = wxPyBeginAllowThreads();
23207 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23208
23209 wxPyEndAllowThreads(__tstate);
23210 if (PyErr_Occurred()) SWIG_fail;
23211 }
23212 {
23213 #if wxUSE_UNICODE
23214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23215 #else
23216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23217 #endif
23218 }
23219 {
23220 if (temp2)
23221 delete arg2;
23222 }
23223 {
23224 if (temp3) delete arg3;
23225 }
23226 return resultobj;
23227 fail:
23228 {
23229 if (temp2)
23230 delete arg2;
23231 }
23232 {
23233 if (temp3) delete arg3;
23234 }
23235 return NULL;
23236 }
23237
23238
23239 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23240 PyObject *resultobj;
23241 wxDateTime *arg1 = (wxDateTime *) 0 ;
23242 wxString result;
23243 PyObject * obj0 = 0 ;
23244 char *kwnames[] = {
23245 (char *) "self", NULL
23246 };
23247
23248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23250 if (SWIG_arg_fail(1)) SWIG_fail;
23251 {
23252 PyThreadState* __tstate = wxPyBeginAllowThreads();
23253 result = ((wxDateTime const *)arg1)->FormatDate();
23254
23255 wxPyEndAllowThreads(__tstate);
23256 if (PyErr_Occurred()) SWIG_fail;
23257 }
23258 {
23259 #if wxUSE_UNICODE
23260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23261 #else
23262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23263 #endif
23264 }
23265 return resultobj;
23266 fail:
23267 return NULL;
23268 }
23269
23270
23271 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23272 PyObject *resultobj;
23273 wxDateTime *arg1 = (wxDateTime *) 0 ;
23274 wxString result;
23275 PyObject * obj0 = 0 ;
23276 char *kwnames[] = {
23277 (char *) "self", NULL
23278 };
23279
23280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23282 if (SWIG_arg_fail(1)) SWIG_fail;
23283 {
23284 PyThreadState* __tstate = wxPyBeginAllowThreads();
23285 result = ((wxDateTime const *)arg1)->FormatTime();
23286
23287 wxPyEndAllowThreads(__tstate);
23288 if (PyErr_Occurred()) SWIG_fail;
23289 }
23290 {
23291 #if wxUSE_UNICODE
23292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23293 #else
23294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23295 #endif
23296 }
23297 return resultobj;
23298 fail:
23299 return NULL;
23300 }
23301
23302
23303 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23304 PyObject *resultobj;
23305 wxDateTime *arg1 = (wxDateTime *) 0 ;
23306 wxString result;
23307 PyObject * obj0 = 0 ;
23308 char *kwnames[] = {
23309 (char *) "self", NULL
23310 };
23311
23312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23314 if (SWIG_arg_fail(1)) SWIG_fail;
23315 {
23316 PyThreadState* __tstate = wxPyBeginAllowThreads();
23317 result = ((wxDateTime const *)arg1)->FormatISODate();
23318
23319 wxPyEndAllowThreads(__tstate);
23320 if (PyErr_Occurred()) SWIG_fail;
23321 }
23322 {
23323 #if wxUSE_UNICODE
23324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23325 #else
23326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23327 #endif
23328 }
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23336 PyObject *resultobj;
23337 wxDateTime *arg1 = (wxDateTime *) 0 ;
23338 wxString result;
23339 PyObject * obj0 = 0 ;
23340 char *kwnames[] = {
23341 (char *) "self", NULL
23342 };
23343
23344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23346 if (SWIG_arg_fail(1)) SWIG_fail;
23347 {
23348 PyThreadState* __tstate = wxPyBeginAllowThreads();
23349 result = ((wxDateTime const *)arg1)->FormatISOTime();
23350
23351 wxPyEndAllowThreads(__tstate);
23352 if (PyErr_Occurred()) SWIG_fail;
23353 }
23354 {
23355 #if wxUSE_UNICODE
23356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23357 #else
23358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23359 #endif
23360 }
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23368 PyObject *obj;
23369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23370 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23371 Py_INCREF(obj);
23372 return Py_BuildValue((char *)"");
23373 }
23374 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23375 PyObject *resultobj;
23376 long arg1 ;
23377 wxTimeSpan result;
23378 PyObject * obj0 = 0 ;
23379 char *kwnames[] = {
23380 (char *) "sec", NULL
23381 };
23382
23383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23384 {
23385 arg1 = (long)(SWIG_As_long(obj0));
23386 if (SWIG_arg_fail(1)) SWIG_fail;
23387 }
23388 {
23389 PyThreadState* __tstate = wxPyBeginAllowThreads();
23390 result = wxTimeSpan::Seconds(arg1);
23391
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 {
23396 wxTimeSpan * resultptr;
23397 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23398 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23399 }
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23407 PyObject *resultobj;
23408 wxTimeSpan result;
23409 char *kwnames[] = {
23410 NULL
23411 };
23412
23413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23414 {
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 result = wxTimeSpan::Second();
23417
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 {
23422 wxTimeSpan * resultptr;
23423 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23424 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23425 }
23426 return resultobj;
23427 fail:
23428 return NULL;
23429 }
23430
23431
23432 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23433 PyObject *resultobj;
23434 long arg1 ;
23435 wxTimeSpan result;
23436 PyObject * obj0 = 0 ;
23437 char *kwnames[] = {
23438 (char *) "min", NULL
23439 };
23440
23441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23442 {
23443 arg1 = (long)(SWIG_As_long(obj0));
23444 if (SWIG_arg_fail(1)) SWIG_fail;
23445 }
23446 {
23447 PyThreadState* __tstate = wxPyBeginAllowThreads();
23448 result = wxTimeSpan::Minutes(arg1);
23449
23450 wxPyEndAllowThreads(__tstate);
23451 if (PyErr_Occurred()) SWIG_fail;
23452 }
23453 {
23454 wxTimeSpan * resultptr;
23455 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23457 }
23458 return resultobj;
23459 fail:
23460 return NULL;
23461 }
23462
23463
23464 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23465 PyObject *resultobj;
23466 wxTimeSpan result;
23467 char *kwnames[] = {
23468 NULL
23469 };
23470
23471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = wxTimeSpan::Minute();
23475
23476 wxPyEndAllowThreads(__tstate);
23477 if (PyErr_Occurred()) SWIG_fail;
23478 }
23479 {
23480 wxTimeSpan * resultptr;
23481 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23482 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23483 }
23484 return resultobj;
23485 fail:
23486 return NULL;
23487 }
23488
23489
23490 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23491 PyObject *resultobj;
23492 long arg1 ;
23493 wxTimeSpan result;
23494 PyObject * obj0 = 0 ;
23495 char *kwnames[] = {
23496 (char *) "hours", NULL
23497 };
23498
23499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23500 {
23501 arg1 = (long)(SWIG_As_long(obj0));
23502 if (SWIG_arg_fail(1)) SWIG_fail;
23503 }
23504 {
23505 PyThreadState* __tstate = wxPyBeginAllowThreads();
23506 result = wxTimeSpan::Hours(arg1);
23507
23508 wxPyEndAllowThreads(__tstate);
23509 if (PyErr_Occurred()) SWIG_fail;
23510 }
23511 {
23512 wxTimeSpan * resultptr;
23513 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23514 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23515 }
23516 return resultobj;
23517 fail:
23518 return NULL;
23519 }
23520
23521
23522 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23523 PyObject *resultobj;
23524 wxTimeSpan result;
23525 char *kwnames[] = {
23526 NULL
23527 };
23528
23529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23530 {
23531 PyThreadState* __tstate = wxPyBeginAllowThreads();
23532 result = wxTimeSpan::Hour();
23533
23534 wxPyEndAllowThreads(__tstate);
23535 if (PyErr_Occurred()) SWIG_fail;
23536 }
23537 {
23538 wxTimeSpan * resultptr;
23539 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23541 }
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23549 PyObject *resultobj;
23550 long arg1 ;
23551 wxTimeSpan result;
23552 PyObject * obj0 = 0 ;
23553 char *kwnames[] = {
23554 (char *) "days", NULL
23555 };
23556
23557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23558 {
23559 arg1 = (long)(SWIG_As_long(obj0));
23560 if (SWIG_arg_fail(1)) SWIG_fail;
23561 }
23562 {
23563 PyThreadState* __tstate = wxPyBeginAllowThreads();
23564 result = wxTimeSpan::Days(arg1);
23565
23566 wxPyEndAllowThreads(__tstate);
23567 if (PyErr_Occurred()) SWIG_fail;
23568 }
23569 {
23570 wxTimeSpan * resultptr;
23571 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23573 }
23574 return resultobj;
23575 fail:
23576 return NULL;
23577 }
23578
23579
23580 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23581 PyObject *resultobj;
23582 wxTimeSpan result;
23583 char *kwnames[] = {
23584 NULL
23585 };
23586
23587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23588 {
23589 PyThreadState* __tstate = wxPyBeginAllowThreads();
23590 result = wxTimeSpan::Day();
23591
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 {
23596 wxTimeSpan * resultptr;
23597 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23599 }
23600 return resultobj;
23601 fail:
23602 return NULL;
23603 }
23604
23605
23606 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23607 PyObject *resultobj;
23608 long arg1 ;
23609 wxTimeSpan result;
23610 PyObject * obj0 = 0 ;
23611 char *kwnames[] = {
23612 (char *) "days", NULL
23613 };
23614
23615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23616 {
23617 arg1 = (long)(SWIG_As_long(obj0));
23618 if (SWIG_arg_fail(1)) SWIG_fail;
23619 }
23620 {
23621 PyThreadState* __tstate = wxPyBeginAllowThreads();
23622 result = wxTimeSpan::Weeks(arg1);
23623
23624 wxPyEndAllowThreads(__tstate);
23625 if (PyErr_Occurred()) SWIG_fail;
23626 }
23627 {
23628 wxTimeSpan * resultptr;
23629 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23630 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23631 }
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj;
23640 wxTimeSpan result;
23641 char *kwnames[] = {
23642 NULL
23643 };
23644
23645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23646 {
23647 PyThreadState* __tstate = wxPyBeginAllowThreads();
23648 result = wxTimeSpan::Week();
23649
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 {
23654 wxTimeSpan * resultptr;
23655 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23657 }
23658 return resultobj;
23659 fail:
23660 return NULL;
23661 }
23662
23663
23664 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23665 PyObject *resultobj;
23666 long arg1 = (long) 0 ;
23667 long arg2 = (long) 0 ;
23668 long arg3 = (long) 0 ;
23669 long arg4 = (long) 0 ;
23670 wxTimeSpan *result;
23671 PyObject * obj0 = 0 ;
23672 PyObject * obj1 = 0 ;
23673 PyObject * obj2 = 0 ;
23674 PyObject * obj3 = 0 ;
23675 char *kwnames[] = {
23676 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23677 };
23678
23679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23680 if (obj0) {
23681 {
23682 arg1 = (long)(SWIG_As_long(obj0));
23683 if (SWIG_arg_fail(1)) SWIG_fail;
23684 }
23685 }
23686 if (obj1) {
23687 {
23688 arg2 = (long)(SWIG_As_long(obj1));
23689 if (SWIG_arg_fail(2)) SWIG_fail;
23690 }
23691 }
23692 if (obj2) {
23693 {
23694 arg3 = (long)(SWIG_As_long(obj2));
23695 if (SWIG_arg_fail(3)) SWIG_fail;
23696 }
23697 }
23698 if (obj3) {
23699 {
23700 arg4 = (long)(SWIG_As_long(obj3));
23701 if (SWIG_arg_fail(4)) SWIG_fail;
23702 }
23703 }
23704 {
23705 PyThreadState* __tstate = wxPyBeginAllowThreads();
23706 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23707
23708 wxPyEndAllowThreads(__tstate);
23709 if (PyErr_Occurred()) SWIG_fail;
23710 }
23711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23712 return resultobj;
23713 fail:
23714 return NULL;
23715 }
23716
23717
23718 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23719 PyObject *resultobj;
23720 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23721 PyObject * obj0 = 0 ;
23722 char *kwnames[] = {
23723 (char *) "self", NULL
23724 };
23725
23726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23728 if (SWIG_arg_fail(1)) SWIG_fail;
23729 {
23730 PyThreadState* __tstate = wxPyBeginAllowThreads();
23731 delete arg1;
23732
23733 wxPyEndAllowThreads(__tstate);
23734 if (PyErr_Occurred()) SWIG_fail;
23735 }
23736 Py_INCREF(Py_None); resultobj = Py_None;
23737 return resultobj;
23738 fail:
23739 return NULL;
23740 }
23741
23742
23743 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23744 PyObject *resultobj;
23745 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23746 wxTimeSpan *arg2 = 0 ;
23747 wxTimeSpan *result;
23748 PyObject * obj0 = 0 ;
23749 PyObject * obj1 = 0 ;
23750 char *kwnames[] = {
23751 (char *) "self",(char *) "diff", NULL
23752 };
23753
23754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23756 if (SWIG_arg_fail(1)) SWIG_fail;
23757 {
23758 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23759 if (SWIG_arg_fail(2)) SWIG_fail;
23760 if (arg2 == NULL) {
23761 SWIG_null_ref("wxTimeSpan");
23762 }
23763 if (SWIG_arg_fail(2)) SWIG_fail;
23764 }
23765 {
23766 PyThreadState* __tstate = wxPyBeginAllowThreads();
23767 {
23768 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23769 result = (wxTimeSpan *) &_result_ref;
23770 }
23771
23772 wxPyEndAllowThreads(__tstate);
23773 if (PyErr_Occurred()) SWIG_fail;
23774 }
23775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23776 return resultobj;
23777 fail:
23778 return NULL;
23779 }
23780
23781
23782 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23783 PyObject *resultobj;
23784 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23785 wxTimeSpan *arg2 = 0 ;
23786 wxTimeSpan *result;
23787 PyObject * obj0 = 0 ;
23788 PyObject * obj1 = 0 ;
23789 char *kwnames[] = {
23790 (char *) "self",(char *) "diff", NULL
23791 };
23792
23793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
23794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23795 if (SWIG_arg_fail(1)) SWIG_fail;
23796 {
23797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23798 if (SWIG_arg_fail(2)) SWIG_fail;
23799 if (arg2 == NULL) {
23800 SWIG_null_ref("wxTimeSpan");
23801 }
23802 if (SWIG_arg_fail(2)) SWIG_fail;
23803 }
23804 {
23805 PyThreadState* __tstate = wxPyBeginAllowThreads();
23806 {
23807 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23808 result = (wxTimeSpan *) &_result_ref;
23809 }
23810
23811 wxPyEndAllowThreads(__tstate);
23812 if (PyErr_Occurred()) SWIG_fail;
23813 }
23814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23815 return resultobj;
23816 fail:
23817 return NULL;
23818 }
23819
23820
23821 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj;
23823 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23824 int arg2 ;
23825 wxTimeSpan *result;
23826 PyObject * obj0 = 0 ;
23827 PyObject * obj1 = 0 ;
23828 char *kwnames[] = {
23829 (char *) "self",(char *) "n", NULL
23830 };
23831
23832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
23833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23834 if (SWIG_arg_fail(1)) SWIG_fail;
23835 {
23836 arg2 = (int)(SWIG_As_int(obj1));
23837 if (SWIG_arg_fail(2)) SWIG_fail;
23838 }
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 {
23842 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
23843 result = (wxTimeSpan *) &_result_ref;
23844 }
23845
23846 wxPyEndAllowThreads(__tstate);
23847 if (PyErr_Occurred()) SWIG_fail;
23848 }
23849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23850 return resultobj;
23851 fail:
23852 return NULL;
23853 }
23854
23855
23856 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj;
23858 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23859 wxTimeSpan *result;
23860 PyObject * obj0 = 0 ;
23861 char *kwnames[] = {
23862 (char *) "self", NULL
23863 };
23864
23865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
23866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23867 if (SWIG_arg_fail(1)) SWIG_fail;
23868 {
23869 PyThreadState* __tstate = wxPyBeginAllowThreads();
23870 {
23871 wxTimeSpan &_result_ref = (arg1)->Neg();
23872 result = (wxTimeSpan *) &_result_ref;
23873 }
23874
23875 wxPyEndAllowThreads(__tstate);
23876 if (PyErr_Occurred()) SWIG_fail;
23877 }
23878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23879 return resultobj;
23880 fail:
23881 return NULL;
23882 }
23883
23884
23885 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
23886 PyObject *resultobj;
23887 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23888 wxTimeSpan result;
23889 PyObject * obj0 = 0 ;
23890 char *kwnames[] = {
23891 (char *) "self", NULL
23892 };
23893
23894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
23895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23896 if (SWIG_arg_fail(1)) SWIG_fail;
23897 {
23898 PyThreadState* __tstate = wxPyBeginAllowThreads();
23899 result = ((wxTimeSpan const *)arg1)->Abs();
23900
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 {
23905 wxTimeSpan * resultptr;
23906 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23908 }
23909 return resultobj;
23910 fail:
23911 return NULL;
23912 }
23913
23914
23915 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
23916 PyObject *resultobj;
23917 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23918 wxTimeSpan *arg2 = 0 ;
23919 wxTimeSpan *result;
23920 PyObject * obj0 = 0 ;
23921 PyObject * obj1 = 0 ;
23922 char *kwnames[] = {
23923 (char *) "self",(char *) "diff", NULL
23924 };
23925
23926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
23927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23928 if (SWIG_arg_fail(1)) SWIG_fail;
23929 {
23930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23931 if (SWIG_arg_fail(2)) SWIG_fail;
23932 if (arg2 == NULL) {
23933 SWIG_null_ref("wxTimeSpan");
23934 }
23935 if (SWIG_arg_fail(2)) SWIG_fail;
23936 }
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 {
23940 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23941 result = (wxTimeSpan *) &_result_ref;
23942 }
23943
23944 wxPyEndAllowThreads(__tstate);
23945 if (PyErr_Occurred()) SWIG_fail;
23946 }
23947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23948 return resultobj;
23949 fail:
23950 return NULL;
23951 }
23952
23953
23954 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
23955 PyObject *resultobj;
23956 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23957 wxTimeSpan *arg2 = 0 ;
23958 wxTimeSpan *result;
23959 PyObject * obj0 = 0 ;
23960 PyObject * obj1 = 0 ;
23961 char *kwnames[] = {
23962 (char *) "self",(char *) "diff", NULL
23963 };
23964
23965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
23966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23967 if (SWIG_arg_fail(1)) SWIG_fail;
23968 {
23969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23970 if (SWIG_arg_fail(2)) SWIG_fail;
23971 if (arg2 == NULL) {
23972 SWIG_null_ref("wxTimeSpan");
23973 }
23974 if (SWIG_arg_fail(2)) SWIG_fail;
23975 }
23976 {
23977 PyThreadState* __tstate = wxPyBeginAllowThreads();
23978 {
23979 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23980 result = (wxTimeSpan *) &_result_ref;
23981 }
23982
23983 wxPyEndAllowThreads(__tstate);
23984 if (PyErr_Occurred()) SWIG_fail;
23985 }
23986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23987 return resultobj;
23988 fail:
23989 return NULL;
23990 }
23991
23992
23993 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
23994 PyObject *resultobj;
23995 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23996 int arg2 ;
23997 wxTimeSpan *result;
23998 PyObject * obj0 = 0 ;
23999 PyObject * obj1 = 0 ;
24000 char *kwnames[] = {
24001 (char *) "self",(char *) "n", NULL
24002 };
24003
24004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24006 if (SWIG_arg_fail(1)) SWIG_fail;
24007 {
24008 arg2 = (int)(SWIG_As_int(obj1));
24009 if (SWIG_arg_fail(2)) SWIG_fail;
24010 }
24011 {
24012 PyThreadState* __tstate = wxPyBeginAllowThreads();
24013 {
24014 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24015 result = (wxTimeSpan *) &_result_ref;
24016 }
24017
24018 wxPyEndAllowThreads(__tstate);
24019 if (PyErr_Occurred()) SWIG_fail;
24020 }
24021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24022 return resultobj;
24023 fail:
24024 return NULL;
24025 }
24026
24027
24028 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24029 PyObject *resultobj;
24030 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24031 wxTimeSpan *result;
24032 PyObject * obj0 = 0 ;
24033 char *kwnames[] = {
24034 (char *) "self", NULL
24035 };
24036
24037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24039 if (SWIG_arg_fail(1)) SWIG_fail;
24040 {
24041 PyThreadState* __tstate = wxPyBeginAllowThreads();
24042 {
24043 wxTimeSpan &_result_ref = (arg1)->operator -();
24044 result = (wxTimeSpan *) &_result_ref;
24045 }
24046
24047 wxPyEndAllowThreads(__tstate);
24048 if (PyErr_Occurred()) SWIG_fail;
24049 }
24050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24051 return resultobj;
24052 fail:
24053 return NULL;
24054 }
24055
24056
24057 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24058 PyObject *resultobj;
24059 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24060 wxTimeSpan *arg2 = 0 ;
24061 wxTimeSpan result;
24062 PyObject * obj0 = 0 ;
24063 PyObject * obj1 = 0 ;
24064 char *kwnames[] = {
24065 (char *) "self",(char *) "other", NULL
24066 };
24067
24068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24070 if (SWIG_arg_fail(1)) SWIG_fail;
24071 {
24072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24073 if (SWIG_arg_fail(2)) SWIG_fail;
24074 if (arg2 == NULL) {
24075 SWIG_null_ref("wxTimeSpan");
24076 }
24077 if (SWIG_arg_fail(2)) SWIG_fail;
24078 }
24079 {
24080 PyThreadState* __tstate = wxPyBeginAllowThreads();
24081 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24082
24083 wxPyEndAllowThreads(__tstate);
24084 if (PyErr_Occurred()) SWIG_fail;
24085 }
24086 {
24087 wxTimeSpan * resultptr;
24088 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24090 }
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj;
24099 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24100 wxTimeSpan *arg2 = 0 ;
24101 wxTimeSpan result;
24102 PyObject * obj0 = 0 ;
24103 PyObject * obj1 = 0 ;
24104 char *kwnames[] = {
24105 (char *) "self",(char *) "other", NULL
24106 };
24107
24108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24110 if (SWIG_arg_fail(1)) SWIG_fail;
24111 {
24112 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24113 if (SWIG_arg_fail(2)) SWIG_fail;
24114 if (arg2 == NULL) {
24115 SWIG_null_ref("wxTimeSpan");
24116 }
24117 if (SWIG_arg_fail(2)) SWIG_fail;
24118 }
24119 {
24120 PyThreadState* __tstate = wxPyBeginAllowThreads();
24121 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24122
24123 wxPyEndAllowThreads(__tstate);
24124 if (PyErr_Occurred()) SWIG_fail;
24125 }
24126 {
24127 wxTimeSpan * resultptr;
24128 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24130 }
24131 return resultobj;
24132 fail:
24133 return NULL;
24134 }
24135
24136
24137 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24138 PyObject *resultobj;
24139 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24140 int arg2 ;
24141 wxTimeSpan result;
24142 PyObject * obj0 = 0 ;
24143 PyObject * obj1 = 0 ;
24144 char *kwnames[] = {
24145 (char *) "self",(char *) "n", NULL
24146 };
24147
24148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24150 if (SWIG_arg_fail(1)) SWIG_fail;
24151 {
24152 arg2 = (int)(SWIG_As_int(obj1));
24153 if (SWIG_arg_fail(2)) SWIG_fail;
24154 }
24155 {
24156 PyThreadState* __tstate = wxPyBeginAllowThreads();
24157 result = wxTimeSpan___mul__(arg1,arg2);
24158
24159 wxPyEndAllowThreads(__tstate);
24160 if (PyErr_Occurred()) SWIG_fail;
24161 }
24162 {
24163 wxTimeSpan * resultptr;
24164 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24165 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24166 }
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24174 PyObject *resultobj;
24175 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24176 int arg2 ;
24177 wxTimeSpan result;
24178 PyObject * obj0 = 0 ;
24179 PyObject * obj1 = 0 ;
24180 char *kwnames[] = {
24181 (char *) "self",(char *) "n", NULL
24182 };
24183
24184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24186 if (SWIG_arg_fail(1)) SWIG_fail;
24187 {
24188 arg2 = (int)(SWIG_As_int(obj1));
24189 if (SWIG_arg_fail(2)) SWIG_fail;
24190 }
24191 {
24192 PyThreadState* __tstate = wxPyBeginAllowThreads();
24193 result = wxTimeSpan___rmul__(arg1,arg2);
24194
24195 wxPyEndAllowThreads(__tstate);
24196 if (PyErr_Occurred()) SWIG_fail;
24197 }
24198 {
24199 wxTimeSpan * resultptr;
24200 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24202 }
24203 return resultobj;
24204 fail:
24205 return NULL;
24206 }
24207
24208
24209 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24210 PyObject *resultobj;
24211 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24212 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24213 bool result;
24214 PyObject * obj0 = 0 ;
24215 PyObject * obj1 = 0 ;
24216 char *kwnames[] = {
24217 (char *) "self",(char *) "other", NULL
24218 };
24219
24220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24222 if (SWIG_arg_fail(1)) SWIG_fail;
24223 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24224 if (SWIG_arg_fail(2)) SWIG_fail;
24225 {
24226 PyThreadState* __tstate = wxPyBeginAllowThreads();
24227 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24228
24229 wxPyEndAllowThreads(__tstate);
24230 if (PyErr_Occurred()) SWIG_fail;
24231 }
24232 {
24233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24234 }
24235 return resultobj;
24236 fail:
24237 return NULL;
24238 }
24239
24240
24241 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24242 PyObject *resultobj;
24243 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24244 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24245 bool result;
24246 PyObject * obj0 = 0 ;
24247 PyObject * obj1 = 0 ;
24248 char *kwnames[] = {
24249 (char *) "self",(char *) "other", NULL
24250 };
24251
24252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24254 if (SWIG_arg_fail(1)) SWIG_fail;
24255 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24256 if (SWIG_arg_fail(2)) SWIG_fail;
24257 {
24258 PyThreadState* __tstate = wxPyBeginAllowThreads();
24259 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24260
24261 wxPyEndAllowThreads(__tstate);
24262 if (PyErr_Occurred()) SWIG_fail;
24263 }
24264 {
24265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24266 }
24267 return resultobj;
24268 fail:
24269 return NULL;
24270 }
24271
24272
24273 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24274 PyObject *resultobj;
24275 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24276 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24277 bool result;
24278 PyObject * obj0 = 0 ;
24279 PyObject * obj1 = 0 ;
24280 char *kwnames[] = {
24281 (char *) "self",(char *) "other", NULL
24282 };
24283
24284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24286 if (SWIG_arg_fail(1)) SWIG_fail;
24287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24288 if (SWIG_arg_fail(2)) SWIG_fail;
24289 {
24290 PyThreadState* __tstate = wxPyBeginAllowThreads();
24291 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24292
24293 wxPyEndAllowThreads(__tstate);
24294 if (PyErr_Occurred()) SWIG_fail;
24295 }
24296 {
24297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24298 }
24299 return resultobj;
24300 fail:
24301 return NULL;
24302 }
24303
24304
24305 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24306 PyObject *resultobj;
24307 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24308 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24309 bool result;
24310 PyObject * obj0 = 0 ;
24311 PyObject * obj1 = 0 ;
24312 char *kwnames[] = {
24313 (char *) "self",(char *) "other", NULL
24314 };
24315
24316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24318 if (SWIG_arg_fail(1)) SWIG_fail;
24319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24320 if (SWIG_arg_fail(2)) SWIG_fail;
24321 {
24322 PyThreadState* __tstate = wxPyBeginAllowThreads();
24323 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24324
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 {
24329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24330 }
24331 return resultobj;
24332 fail:
24333 return NULL;
24334 }
24335
24336
24337 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24338 PyObject *resultobj;
24339 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24340 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24341 bool result;
24342 PyObject * obj0 = 0 ;
24343 PyObject * obj1 = 0 ;
24344 char *kwnames[] = {
24345 (char *) "self",(char *) "other", NULL
24346 };
24347
24348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24350 if (SWIG_arg_fail(1)) SWIG_fail;
24351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24352 if (SWIG_arg_fail(2)) SWIG_fail;
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24356
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 {
24361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24362 }
24363 return resultobj;
24364 fail:
24365 return NULL;
24366 }
24367
24368
24369 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24370 PyObject *resultobj;
24371 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24372 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24373 bool result;
24374 PyObject * obj0 = 0 ;
24375 PyObject * obj1 = 0 ;
24376 char *kwnames[] = {
24377 (char *) "self",(char *) "other", NULL
24378 };
24379
24380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24382 if (SWIG_arg_fail(1)) SWIG_fail;
24383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24384 if (SWIG_arg_fail(2)) SWIG_fail;
24385 {
24386 PyThreadState* __tstate = wxPyBeginAllowThreads();
24387 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24388
24389 wxPyEndAllowThreads(__tstate);
24390 if (PyErr_Occurred()) SWIG_fail;
24391 }
24392 {
24393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24394 }
24395 return resultobj;
24396 fail:
24397 return NULL;
24398 }
24399
24400
24401 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24402 PyObject *resultobj;
24403 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24404 bool result;
24405 PyObject * obj0 = 0 ;
24406 char *kwnames[] = {
24407 (char *) "self", NULL
24408 };
24409
24410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(1)) SWIG_fail;
24413 {
24414 PyThreadState* __tstate = wxPyBeginAllowThreads();
24415 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24416
24417 wxPyEndAllowThreads(__tstate);
24418 if (PyErr_Occurred()) SWIG_fail;
24419 }
24420 {
24421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24422 }
24423 return resultobj;
24424 fail:
24425 return NULL;
24426 }
24427
24428
24429 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24430 PyObject *resultobj;
24431 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24432 bool result;
24433 PyObject * obj0 = 0 ;
24434 char *kwnames[] = {
24435 (char *) "self", NULL
24436 };
24437
24438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24440 if (SWIG_arg_fail(1)) SWIG_fail;
24441 {
24442 PyThreadState* __tstate = wxPyBeginAllowThreads();
24443 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24444
24445 wxPyEndAllowThreads(__tstate);
24446 if (PyErr_Occurred()) SWIG_fail;
24447 }
24448 {
24449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24450 }
24451 return resultobj;
24452 fail:
24453 return NULL;
24454 }
24455
24456
24457 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24458 PyObject *resultobj;
24459 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24460 bool result;
24461 PyObject * obj0 = 0 ;
24462 char *kwnames[] = {
24463 (char *) "self", NULL
24464 };
24465
24466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24468 if (SWIG_arg_fail(1)) SWIG_fail;
24469 {
24470 PyThreadState* __tstate = wxPyBeginAllowThreads();
24471 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24472
24473 wxPyEndAllowThreads(__tstate);
24474 if (PyErr_Occurred()) SWIG_fail;
24475 }
24476 {
24477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24478 }
24479 return resultobj;
24480 fail:
24481 return NULL;
24482 }
24483
24484
24485 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24486 PyObject *resultobj;
24487 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24488 wxTimeSpan *arg2 = 0 ;
24489 bool result;
24490 PyObject * obj0 = 0 ;
24491 PyObject * obj1 = 0 ;
24492 char *kwnames[] = {
24493 (char *) "self",(char *) "ts", NULL
24494 };
24495
24496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24498 if (SWIG_arg_fail(1)) SWIG_fail;
24499 {
24500 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24501 if (SWIG_arg_fail(2)) SWIG_fail;
24502 if (arg2 == NULL) {
24503 SWIG_null_ref("wxTimeSpan");
24504 }
24505 if (SWIG_arg_fail(2)) SWIG_fail;
24506 }
24507 {
24508 PyThreadState* __tstate = wxPyBeginAllowThreads();
24509 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24510
24511 wxPyEndAllowThreads(__tstate);
24512 if (PyErr_Occurred()) SWIG_fail;
24513 }
24514 {
24515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24516 }
24517 return resultobj;
24518 fail:
24519 return NULL;
24520 }
24521
24522
24523 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24524 PyObject *resultobj;
24525 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24526 wxTimeSpan *arg2 = 0 ;
24527 bool result;
24528 PyObject * obj0 = 0 ;
24529 PyObject * obj1 = 0 ;
24530 char *kwnames[] = {
24531 (char *) "self",(char *) "ts", NULL
24532 };
24533
24534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24536 if (SWIG_arg_fail(1)) SWIG_fail;
24537 {
24538 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24539 if (SWIG_arg_fail(2)) SWIG_fail;
24540 if (arg2 == NULL) {
24541 SWIG_null_ref("wxTimeSpan");
24542 }
24543 if (SWIG_arg_fail(2)) SWIG_fail;
24544 }
24545 {
24546 PyThreadState* __tstate = wxPyBeginAllowThreads();
24547 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24548
24549 wxPyEndAllowThreads(__tstate);
24550 if (PyErr_Occurred()) SWIG_fail;
24551 }
24552 {
24553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24554 }
24555 return resultobj;
24556 fail:
24557 return NULL;
24558 }
24559
24560
24561 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24562 PyObject *resultobj;
24563 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24564 wxTimeSpan *arg2 = 0 ;
24565 bool result;
24566 PyObject * obj0 = 0 ;
24567 PyObject * obj1 = 0 ;
24568 char *kwnames[] = {
24569 (char *) "self",(char *) "t", NULL
24570 };
24571
24572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24574 if (SWIG_arg_fail(1)) SWIG_fail;
24575 {
24576 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24577 if (SWIG_arg_fail(2)) SWIG_fail;
24578 if (arg2 == NULL) {
24579 SWIG_null_ref("wxTimeSpan");
24580 }
24581 if (SWIG_arg_fail(2)) SWIG_fail;
24582 }
24583 {
24584 PyThreadState* __tstate = wxPyBeginAllowThreads();
24585 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24586
24587 wxPyEndAllowThreads(__tstate);
24588 if (PyErr_Occurred()) SWIG_fail;
24589 }
24590 {
24591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24592 }
24593 return resultobj;
24594 fail:
24595 return NULL;
24596 }
24597
24598
24599 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24600 PyObject *resultobj;
24601 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24602 int result;
24603 PyObject * obj0 = 0 ;
24604 char *kwnames[] = {
24605 (char *) "self", NULL
24606 };
24607
24608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24610 if (SWIG_arg_fail(1)) SWIG_fail;
24611 {
24612 PyThreadState* __tstate = wxPyBeginAllowThreads();
24613 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24614
24615 wxPyEndAllowThreads(__tstate);
24616 if (PyErr_Occurred()) SWIG_fail;
24617 }
24618 {
24619 resultobj = SWIG_From_int((int)(result));
24620 }
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24628 PyObject *resultobj;
24629 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24630 int result;
24631 PyObject * obj0 = 0 ;
24632 char *kwnames[] = {
24633 (char *) "self", NULL
24634 };
24635
24636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24638 if (SWIG_arg_fail(1)) SWIG_fail;
24639 {
24640 PyThreadState* __tstate = wxPyBeginAllowThreads();
24641 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24642
24643 wxPyEndAllowThreads(__tstate);
24644 if (PyErr_Occurred()) SWIG_fail;
24645 }
24646 {
24647 resultobj = SWIG_From_int((int)(result));
24648 }
24649 return resultobj;
24650 fail:
24651 return NULL;
24652 }
24653
24654
24655 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24656 PyObject *resultobj;
24657 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24658 int result;
24659 PyObject * obj0 = 0 ;
24660 char *kwnames[] = {
24661 (char *) "self", NULL
24662 };
24663
24664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24666 if (SWIG_arg_fail(1)) SWIG_fail;
24667 {
24668 PyThreadState* __tstate = wxPyBeginAllowThreads();
24669 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24670
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 {
24675 resultobj = SWIG_From_int((int)(result));
24676 }
24677 return resultobj;
24678 fail:
24679 return NULL;
24680 }
24681
24682
24683 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj;
24685 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24686 int result;
24687 PyObject * obj0 = 0 ;
24688 char *kwnames[] = {
24689 (char *) "self", NULL
24690 };
24691
24692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24694 if (SWIG_arg_fail(1)) SWIG_fail;
24695 {
24696 PyThreadState* __tstate = wxPyBeginAllowThreads();
24697 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24698
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 {
24703 resultobj = SWIG_From_int((int)(result));
24704 }
24705 return resultobj;
24706 fail:
24707 return NULL;
24708 }
24709
24710
24711 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24712 PyObject *resultobj;
24713 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24714 wxLongLong result;
24715 PyObject * obj0 = 0 ;
24716 char *kwnames[] = {
24717 (char *) "self", NULL
24718 };
24719
24720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
24721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24722 if (SWIG_arg_fail(1)) SWIG_fail;
24723 {
24724 PyThreadState* __tstate = wxPyBeginAllowThreads();
24725 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24726
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 {
24731 PyObject *hi, *lo, *shifter, *shifted;
24732 hi = PyLong_FromLong( (&result)->GetHi() );
24733 lo = PyLong_FromLong( (&result)->GetLo() );
24734 shifter = PyLong_FromLong(32);
24735 shifted = PyNumber_Lshift(hi, shifter);
24736 resultobj = PyNumber_Or(shifted, lo);
24737 Py_DECREF(hi);
24738 Py_DECREF(lo);
24739 Py_DECREF(shifter);
24740 Py_DECREF(shifted);
24741 }
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24749 PyObject *resultobj;
24750 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24751 wxLongLong result;
24752 PyObject * obj0 = 0 ;
24753 char *kwnames[] = {
24754 (char *) "self", NULL
24755 };
24756
24757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) 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 {
24761 PyThreadState* __tstate = wxPyBeginAllowThreads();
24762 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
24763
24764 wxPyEndAllowThreads(__tstate);
24765 if (PyErr_Occurred()) SWIG_fail;
24766 }
24767 {
24768 PyObject *hi, *lo, *shifter, *shifted;
24769 hi = PyLong_FromLong( (&result)->GetHi() );
24770 lo = PyLong_FromLong( (&result)->GetLo() );
24771 shifter = PyLong_FromLong(32);
24772 shifted = PyNumber_Lshift(hi, shifter);
24773 resultobj = PyNumber_Or(shifted, lo);
24774 Py_DECREF(hi);
24775 Py_DECREF(lo);
24776 Py_DECREF(shifter);
24777 Py_DECREF(shifted);
24778 }
24779 return resultobj;
24780 fail:
24781 return NULL;
24782 }
24783
24784
24785 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24786 PyObject *resultobj;
24787 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24788 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
24789 wxString *arg2 = (wxString *) &arg2_defvalue ;
24790 wxString result;
24791 bool temp2 = false ;
24792 PyObject * obj0 = 0 ;
24793 PyObject * obj1 = 0 ;
24794 char *kwnames[] = {
24795 (char *) "self",(char *) "format", NULL
24796 };
24797
24798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
24799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24800 if (SWIG_arg_fail(1)) SWIG_fail;
24801 if (obj1) {
24802 {
24803 arg2 = wxString_in_helper(obj1);
24804 if (arg2 == NULL) SWIG_fail;
24805 temp2 = true;
24806 }
24807 }
24808 {
24809 PyThreadState* __tstate = wxPyBeginAllowThreads();
24810 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
24811
24812 wxPyEndAllowThreads(__tstate);
24813 if (PyErr_Occurred()) SWIG_fail;
24814 }
24815 {
24816 #if wxUSE_UNICODE
24817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24818 #else
24819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24820 #endif
24821 }
24822 {
24823 if (temp2)
24824 delete arg2;
24825 }
24826 return resultobj;
24827 fail:
24828 {
24829 if (temp2)
24830 delete arg2;
24831 }
24832 return NULL;
24833 }
24834
24835
24836 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
24837 PyObject *obj;
24838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24839 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
24840 Py_INCREF(obj);
24841 return Py_BuildValue((char *)"");
24842 }
24843 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24844 PyObject *resultobj;
24845 int arg1 = (int) 0 ;
24846 int arg2 = (int) 0 ;
24847 int arg3 = (int) 0 ;
24848 int arg4 = (int) 0 ;
24849 wxDateSpan *result;
24850 PyObject * obj0 = 0 ;
24851 PyObject * obj1 = 0 ;
24852 PyObject * obj2 = 0 ;
24853 PyObject * obj3 = 0 ;
24854 char *kwnames[] = {
24855 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
24856 };
24857
24858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24859 if (obj0) {
24860 {
24861 arg1 = (int)(SWIG_As_int(obj0));
24862 if (SWIG_arg_fail(1)) SWIG_fail;
24863 }
24864 }
24865 if (obj1) {
24866 {
24867 arg2 = (int)(SWIG_As_int(obj1));
24868 if (SWIG_arg_fail(2)) SWIG_fail;
24869 }
24870 }
24871 if (obj2) {
24872 {
24873 arg3 = (int)(SWIG_As_int(obj2));
24874 if (SWIG_arg_fail(3)) SWIG_fail;
24875 }
24876 }
24877 if (obj3) {
24878 {
24879 arg4 = (int)(SWIG_As_int(obj3));
24880 if (SWIG_arg_fail(4)) SWIG_fail;
24881 }
24882 }
24883 {
24884 PyThreadState* __tstate = wxPyBeginAllowThreads();
24885 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
24886
24887 wxPyEndAllowThreads(__tstate);
24888 if (PyErr_Occurred()) SWIG_fail;
24889 }
24890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
24891 return resultobj;
24892 fail:
24893 return NULL;
24894 }
24895
24896
24897 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24898 PyObject *resultobj;
24899 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
24900 PyObject * obj0 = 0 ;
24901 char *kwnames[] = {
24902 (char *) "self", NULL
24903 };
24904
24905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
24906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24907 if (SWIG_arg_fail(1)) SWIG_fail;
24908 {
24909 PyThreadState* __tstate = wxPyBeginAllowThreads();
24910 delete arg1;
24911
24912 wxPyEndAllowThreads(__tstate);
24913 if (PyErr_Occurred()) SWIG_fail;
24914 }
24915 Py_INCREF(Py_None); resultobj = Py_None;
24916 return resultobj;
24917 fail:
24918 return NULL;
24919 }
24920
24921
24922 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24923 PyObject *resultobj;
24924 int arg1 ;
24925 wxDateSpan result;
24926 PyObject * obj0 = 0 ;
24927 char *kwnames[] = {
24928 (char *) "days", NULL
24929 };
24930
24931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
24932 {
24933 arg1 = (int)(SWIG_As_int(obj0));
24934 if (SWIG_arg_fail(1)) SWIG_fail;
24935 }
24936 {
24937 PyThreadState* __tstate = wxPyBeginAllowThreads();
24938 result = wxDateSpan::Days(arg1);
24939
24940 wxPyEndAllowThreads(__tstate);
24941 if (PyErr_Occurred()) SWIG_fail;
24942 }
24943 {
24944 wxDateSpan * resultptr;
24945 resultptr = new wxDateSpan((wxDateSpan &)(result));
24946 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24947 }
24948 return resultobj;
24949 fail:
24950 return NULL;
24951 }
24952
24953
24954 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24955 PyObject *resultobj;
24956 wxDateSpan result;
24957 char *kwnames[] = {
24958 NULL
24959 };
24960
24961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
24962 {
24963 PyThreadState* __tstate = wxPyBeginAllowThreads();
24964 result = wxDateSpan::Day();
24965
24966 wxPyEndAllowThreads(__tstate);
24967 if (PyErr_Occurred()) SWIG_fail;
24968 }
24969 {
24970 wxDateSpan * resultptr;
24971 resultptr = new wxDateSpan((wxDateSpan &)(result));
24972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24973 }
24974 return resultobj;
24975 fail:
24976 return NULL;
24977 }
24978
24979
24980 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24981 PyObject *resultobj;
24982 int arg1 ;
24983 wxDateSpan result;
24984 PyObject * obj0 = 0 ;
24985 char *kwnames[] = {
24986 (char *) "weeks", NULL
24987 };
24988
24989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
24990 {
24991 arg1 = (int)(SWIG_As_int(obj0));
24992 if (SWIG_arg_fail(1)) SWIG_fail;
24993 }
24994 {
24995 PyThreadState* __tstate = wxPyBeginAllowThreads();
24996 result = wxDateSpan::Weeks(arg1);
24997
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 {
25002 wxDateSpan * resultptr;
25003 resultptr = new wxDateSpan((wxDateSpan &)(result));
25004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25005 }
25006 return resultobj;
25007 fail:
25008 return NULL;
25009 }
25010
25011
25012 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25013 PyObject *resultobj;
25014 wxDateSpan result;
25015 char *kwnames[] = {
25016 NULL
25017 };
25018
25019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25020 {
25021 PyThreadState* __tstate = wxPyBeginAllowThreads();
25022 result = wxDateSpan::Week();
25023
25024 wxPyEndAllowThreads(__tstate);
25025 if (PyErr_Occurred()) SWIG_fail;
25026 }
25027 {
25028 wxDateSpan * resultptr;
25029 resultptr = new wxDateSpan((wxDateSpan &)(result));
25030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25031 }
25032 return resultobj;
25033 fail:
25034 return NULL;
25035 }
25036
25037
25038 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25039 PyObject *resultobj;
25040 int arg1 ;
25041 wxDateSpan result;
25042 PyObject * obj0 = 0 ;
25043 char *kwnames[] = {
25044 (char *) "mon", NULL
25045 };
25046
25047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25048 {
25049 arg1 = (int)(SWIG_As_int(obj0));
25050 if (SWIG_arg_fail(1)) SWIG_fail;
25051 }
25052 {
25053 PyThreadState* __tstate = wxPyBeginAllowThreads();
25054 result = wxDateSpan::Months(arg1);
25055
25056 wxPyEndAllowThreads(__tstate);
25057 if (PyErr_Occurred()) SWIG_fail;
25058 }
25059 {
25060 wxDateSpan * resultptr;
25061 resultptr = new wxDateSpan((wxDateSpan &)(result));
25062 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25063 }
25064 return resultobj;
25065 fail:
25066 return NULL;
25067 }
25068
25069
25070 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25071 PyObject *resultobj;
25072 wxDateSpan result;
25073 char *kwnames[] = {
25074 NULL
25075 };
25076
25077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25078 {
25079 PyThreadState* __tstate = wxPyBeginAllowThreads();
25080 result = wxDateSpan::Month();
25081
25082 wxPyEndAllowThreads(__tstate);
25083 if (PyErr_Occurred()) SWIG_fail;
25084 }
25085 {
25086 wxDateSpan * resultptr;
25087 resultptr = new wxDateSpan((wxDateSpan &)(result));
25088 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25089 }
25090 return resultobj;
25091 fail:
25092 return NULL;
25093 }
25094
25095
25096 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25097 PyObject *resultobj;
25098 int arg1 ;
25099 wxDateSpan result;
25100 PyObject * obj0 = 0 ;
25101 char *kwnames[] = {
25102 (char *) "years", NULL
25103 };
25104
25105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25106 {
25107 arg1 = (int)(SWIG_As_int(obj0));
25108 if (SWIG_arg_fail(1)) SWIG_fail;
25109 }
25110 {
25111 PyThreadState* __tstate = wxPyBeginAllowThreads();
25112 result = wxDateSpan::Years(arg1);
25113
25114 wxPyEndAllowThreads(__tstate);
25115 if (PyErr_Occurred()) SWIG_fail;
25116 }
25117 {
25118 wxDateSpan * resultptr;
25119 resultptr = new wxDateSpan((wxDateSpan &)(result));
25120 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25121 }
25122 return resultobj;
25123 fail:
25124 return NULL;
25125 }
25126
25127
25128 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25129 PyObject *resultobj;
25130 wxDateSpan result;
25131 char *kwnames[] = {
25132 NULL
25133 };
25134
25135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 result = wxDateSpan::Year();
25139
25140 wxPyEndAllowThreads(__tstate);
25141 if (PyErr_Occurred()) SWIG_fail;
25142 }
25143 {
25144 wxDateSpan * resultptr;
25145 resultptr = new wxDateSpan((wxDateSpan &)(result));
25146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25147 }
25148 return resultobj;
25149 fail:
25150 return NULL;
25151 }
25152
25153
25154 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25155 PyObject *resultobj;
25156 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25157 int arg2 ;
25158 wxDateSpan *result;
25159 PyObject * obj0 = 0 ;
25160 PyObject * obj1 = 0 ;
25161 char *kwnames[] = {
25162 (char *) "self",(char *) "n", NULL
25163 };
25164
25165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25167 if (SWIG_arg_fail(1)) SWIG_fail;
25168 {
25169 arg2 = (int)(SWIG_As_int(obj1));
25170 if (SWIG_arg_fail(2)) SWIG_fail;
25171 }
25172 {
25173 PyThreadState* __tstate = wxPyBeginAllowThreads();
25174 {
25175 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25176 result = (wxDateSpan *) &_result_ref;
25177 }
25178
25179 wxPyEndAllowThreads(__tstate);
25180 if (PyErr_Occurred()) SWIG_fail;
25181 }
25182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25190 PyObject *resultobj;
25191 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25192 int arg2 ;
25193 wxDateSpan *result;
25194 PyObject * obj0 = 0 ;
25195 PyObject * obj1 = 0 ;
25196 char *kwnames[] = {
25197 (char *) "self",(char *) "n", NULL
25198 };
25199
25200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25202 if (SWIG_arg_fail(1)) SWIG_fail;
25203 {
25204 arg2 = (int)(SWIG_As_int(obj1));
25205 if (SWIG_arg_fail(2)) SWIG_fail;
25206 }
25207 {
25208 PyThreadState* __tstate = wxPyBeginAllowThreads();
25209 {
25210 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25211 result = (wxDateSpan *) &_result_ref;
25212 }
25213
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj;
25226 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25227 int arg2 ;
25228 wxDateSpan *result;
25229 PyObject * obj0 = 0 ;
25230 PyObject * obj1 = 0 ;
25231 char *kwnames[] = {
25232 (char *) "self",(char *) "n", NULL
25233 };
25234
25235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25237 if (SWIG_arg_fail(1)) SWIG_fail;
25238 {
25239 arg2 = (int)(SWIG_As_int(obj1));
25240 if (SWIG_arg_fail(2)) SWIG_fail;
25241 }
25242 {
25243 PyThreadState* __tstate = wxPyBeginAllowThreads();
25244 {
25245 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25246 result = (wxDateSpan *) &_result_ref;
25247 }
25248
25249 wxPyEndAllowThreads(__tstate);
25250 if (PyErr_Occurred()) SWIG_fail;
25251 }
25252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25253 return resultobj;
25254 fail:
25255 return NULL;
25256 }
25257
25258
25259 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25260 PyObject *resultobj;
25261 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25262 int arg2 ;
25263 wxDateSpan *result;
25264 PyObject * obj0 = 0 ;
25265 PyObject * obj1 = 0 ;
25266 char *kwnames[] = {
25267 (char *) "self",(char *) "n", NULL
25268 };
25269
25270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25272 if (SWIG_arg_fail(1)) SWIG_fail;
25273 {
25274 arg2 = (int)(SWIG_As_int(obj1));
25275 if (SWIG_arg_fail(2)) SWIG_fail;
25276 }
25277 {
25278 PyThreadState* __tstate = wxPyBeginAllowThreads();
25279 {
25280 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25281 result = (wxDateSpan *) &_result_ref;
25282 }
25283
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25295 PyObject *resultobj;
25296 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25297 int result;
25298 PyObject * obj0 = 0 ;
25299 char *kwnames[] = {
25300 (char *) "self", NULL
25301 };
25302
25303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25305 if (SWIG_arg_fail(1)) SWIG_fail;
25306 {
25307 PyThreadState* __tstate = wxPyBeginAllowThreads();
25308 result = (int)((wxDateSpan const *)arg1)->GetYears();
25309
25310 wxPyEndAllowThreads(__tstate);
25311 if (PyErr_Occurred()) SWIG_fail;
25312 }
25313 {
25314 resultobj = SWIG_From_int((int)(result));
25315 }
25316 return resultobj;
25317 fail:
25318 return NULL;
25319 }
25320
25321
25322 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25323 PyObject *resultobj;
25324 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25325 int result;
25326 PyObject * obj0 = 0 ;
25327 char *kwnames[] = {
25328 (char *) "self", NULL
25329 };
25330
25331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25333 if (SWIG_arg_fail(1)) SWIG_fail;
25334 {
25335 PyThreadState* __tstate = wxPyBeginAllowThreads();
25336 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25337
25338 wxPyEndAllowThreads(__tstate);
25339 if (PyErr_Occurred()) SWIG_fail;
25340 }
25341 {
25342 resultobj = SWIG_From_int((int)(result));
25343 }
25344 return resultobj;
25345 fail:
25346 return NULL;
25347 }
25348
25349
25350 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25351 PyObject *resultobj;
25352 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25353 int result;
25354 PyObject * obj0 = 0 ;
25355 char *kwnames[] = {
25356 (char *) "self", NULL
25357 };
25358
25359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25361 if (SWIG_arg_fail(1)) SWIG_fail;
25362 {
25363 PyThreadState* __tstate = wxPyBeginAllowThreads();
25364 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25365
25366 wxPyEndAllowThreads(__tstate);
25367 if (PyErr_Occurred()) SWIG_fail;
25368 }
25369 {
25370 resultobj = SWIG_From_int((int)(result));
25371 }
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25379 PyObject *resultobj;
25380 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25381 int result;
25382 PyObject * obj0 = 0 ;
25383 char *kwnames[] = {
25384 (char *) "self", NULL
25385 };
25386
25387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25389 if (SWIG_arg_fail(1)) SWIG_fail;
25390 {
25391 PyThreadState* __tstate = wxPyBeginAllowThreads();
25392 result = (int)((wxDateSpan const *)arg1)->GetDays();
25393
25394 wxPyEndAllowThreads(__tstate);
25395 if (PyErr_Occurred()) SWIG_fail;
25396 }
25397 {
25398 resultobj = SWIG_From_int((int)(result));
25399 }
25400 return resultobj;
25401 fail:
25402 return NULL;
25403 }
25404
25405
25406 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25407 PyObject *resultobj;
25408 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25409 int result;
25410 PyObject * obj0 = 0 ;
25411 char *kwnames[] = {
25412 (char *) "self", NULL
25413 };
25414
25415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25417 if (SWIG_arg_fail(1)) SWIG_fail;
25418 {
25419 PyThreadState* __tstate = wxPyBeginAllowThreads();
25420 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25421
25422 wxPyEndAllowThreads(__tstate);
25423 if (PyErr_Occurred()) SWIG_fail;
25424 }
25425 {
25426 resultobj = SWIG_From_int((int)(result));
25427 }
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25435 PyObject *resultobj;
25436 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25437 wxDateSpan *arg2 = 0 ;
25438 wxDateSpan *result;
25439 PyObject * obj0 = 0 ;
25440 PyObject * obj1 = 0 ;
25441 char *kwnames[] = {
25442 (char *) "self",(char *) "other", NULL
25443 };
25444
25445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25447 if (SWIG_arg_fail(1)) SWIG_fail;
25448 {
25449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25450 if (SWIG_arg_fail(2)) SWIG_fail;
25451 if (arg2 == NULL) {
25452 SWIG_null_ref("wxDateSpan");
25453 }
25454 if (SWIG_arg_fail(2)) SWIG_fail;
25455 }
25456 {
25457 PyThreadState* __tstate = wxPyBeginAllowThreads();
25458 {
25459 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25460 result = (wxDateSpan *) &_result_ref;
25461 }
25462
25463 wxPyEndAllowThreads(__tstate);
25464 if (PyErr_Occurred()) SWIG_fail;
25465 }
25466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25467 return resultobj;
25468 fail:
25469 return NULL;
25470 }
25471
25472
25473 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25474 PyObject *resultobj;
25475 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25476 wxDateSpan *arg2 = 0 ;
25477 wxDateSpan *result;
25478 PyObject * obj0 = 0 ;
25479 PyObject * obj1 = 0 ;
25480 char *kwnames[] = {
25481 (char *) "self",(char *) "other", NULL
25482 };
25483
25484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25486 if (SWIG_arg_fail(1)) SWIG_fail;
25487 {
25488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25489 if (SWIG_arg_fail(2)) SWIG_fail;
25490 if (arg2 == NULL) {
25491 SWIG_null_ref("wxDateSpan");
25492 }
25493 if (SWIG_arg_fail(2)) SWIG_fail;
25494 }
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 {
25498 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25499 result = (wxDateSpan *) &_result_ref;
25500 }
25501
25502 wxPyEndAllowThreads(__tstate);
25503 if (PyErr_Occurred()) SWIG_fail;
25504 }
25505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25506 return resultobj;
25507 fail:
25508 return NULL;
25509 }
25510
25511
25512 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25513 PyObject *resultobj;
25514 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25515 wxDateSpan *result;
25516 PyObject * obj0 = 0 ;
25517 char *kwnames[] = {
25518 (char *) "self", NULL
25519 };
25520
25521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25523 if (SWIG_arg_fail(1)) SWIG_fail;
25524 {
25525 PyThreadState* __tstate = wxPyBeginAllowThreads();
25526 {
25527 wxDateSpan &_result_ref = (arg1)->Neg();
25528 result = (wxDateSpan *) &_result_ref;
25529 }
25530
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25535 return resultobj;
25536 fail:
25537 return NULL;
25538 }
25539
25540
25541 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25542 PyObject *resultobj;
25543 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25544 int arg2 ;
25545 wxDateSpan *result;
25546 PyObject * obj0 = 0 ;
25547 PyObject * obj1 = 0 ;
25548 char *kwnames[] = {
25549 (char *) "self",(char *) "factor", NULL
25550 };
25551
25552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25554 if (SWIG_arg_fail(1)) SWIG_fail;
25555 {
25556 arg2 = (int)(SWIG_As_int(obj1));
25557 if (SWIG_arg_fail(2)) SWIG_fail;
25558 }
25559 {
25560 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 {
25562 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25563 result = (wxDateSpan *) &_result_ref;
25564 }
25565
25566 wxPyEndAllowThreads(__tstate);
25567 if (PyErr_Occurred()) SWIG_fail;
25568 }
25569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25570 return resultobj;
25571 fail:
25572 return NULL;
25573 }
25574
25575
25576 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25577 PyObject *resultobj;
25578 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25579 wxDateSpan *arg2 = 0 ;
25580 wxDateSpan *result;
25581 PyObject * obj0 = 0 ;
25582 PyObject * obj1 = 0 ;
25583 char *kwnames[] = {
25584 (char *) "self",(char *) "other", NULL
25585 };
25586
25587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25589 if (SWIG_arg_fail(1)) SWIG_fail;
25590 {
25591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25592 if (SWIG_arg_fail(2)) SWIG_fail;
25593 if (arg2 == NULL) {
25594 SWIG_null_ref("wxDateSpan");
25595 }
25596 if (SWIG_arg_fail(2)) SWIG_fail;
25597 }
25598 {
25599 PyThreadState* __tstate = wxPyBeginAllowThreads();
25600 {
25601 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25602 result = (wxDateSpan *) &_result_ref;
25603 }
25604
25605 wxPyEndAllowThreads(__tstate);
25606 if (PyErr_Occurred()) SWIG_fail;
25607 }
25608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25609 return resultobj;
25610 fail:
25611 return NULL;
25612 }
25613
25614
25615 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25616 PyObject *resultobj;
25617 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25618 wxDateSpan *arg2 = 0 ;
25619 wxDateSpan *result;
25620 PyObject * obj0 = 0 ;
25621 PyObject * obj1 = 0 ;
25622 char *kwnames[] = {
25623 (char *) "self",(char *) "other", NULL
25624 };
25625
25626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25628 if (SWIG_arg_fail(1)) SWIG_fail;
25629 {
25630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25631 if (SWIG_arg_fail(2)) SWIG_fail;
25632 if (arg2 == NULL) {
25633 SWIG_null_ref("wxDateSpan");
25634 }
25635 if (SWIG_arg_fail(2)) SWIG_fail;
25636 }
25637 {
25638 PyThreadState* __tstate = wxPyBeginAllowThreads();
25639 {
25640 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25641 result = (wxDateSpan *) &_result_ref;
25642 }
25643
25644 wxPyEndAllowThreads(__tstate);
25645 if (PyErr_Occurred()) SWIG_fail;
25646 }
25647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25648 return resultobj;
25649 fail:
25650 return NULL;
25651 }
25652
25653
25654 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25655 PyObject *resultobj;
25656 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25657 wxDateSpan *result;
25658 PyObject * obj0 = 0 ;
25659 char *kwnames[] = {
25660 (char *) "self", NULL
25661 };
25662
25663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25665 if (SWIG_arg_fail(1)) SWIG_fail;
25666 {
25667 PyThreadState* __tstate = wxPyBeginAllowThreads();
25668 {
25669 wxDateSpan &_result_ref = (arg1)->operator -();
25670 result = (wxDateSpan *) &_result_ref;
25671 }
25672
25673 wxPyEndAllowThreads(__tstate);
25674 if (PyErr_Occurred()) SWIG_fail;
25675 }
25676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25677 return resultobj;
25678 fail:
25679 return NULL;
25680 }
25681
25682
25683 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25684 PyObject *resultobj;
25685 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25686 int arg2 ;
25687 wxDateSpan *result;
25688 PyObject * obj0 = 0 ;
25689 PyObject * obj1 = 0 ;
25690 char *kwnames[] = {
25691 (char *) "self",(char *) "factor", NULL
25692 };
25693
25694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25696 if (SWIG_arg_fail(1)) SWIG_fail;
25697 {
25698 arg2 = (int)(SWIG_As_int(obj1));
25699 if (SWIG_arg_fail(2)) SWIG_fail;
25700 }
25701 {
25702 PyThreadState* __tstate = wxPyBeginAllowThreads();
25703 {
25704 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25705 result = (wxDateSpan *) &_result_ref;
25706 }
25707
25708 wxPyEndAllowThreads(__tstate);
25709 if (PyErr_Occurred()) SWIG_fail;
25710 }
25711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25712 return resultobj;
25713 fail:
25714 return NULL;
25715 }
25716
25717
25718 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25719 PyObject *resultobj;
25720 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25721 wxDateSpan *arg2 = 0 ;
25722 wxDateSpan result;
25723 PyObject * obj0 = 0 ;
25724 PyObject * obj1 = 0 ;
25725 char *kwnames[] = {
25726 (char *) "self",(char *) "other", NULL
25727 };
25728
25729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25731 if (SWIG_arg_fail(1)) SWIG_fail;
25732 {
25733 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25734 if (SWIG_arg_fail(2)) SWIG_fail;
25735 if (arg2 == NULL) {
25736 SWIG_null_ref("wxDateSpan");
25737 }
25738 if (SWIG_arg_fail(2)) SWIG_fail;
25739 }
25740 {
25741 PyThreadState* __tstate = wxPyBeginAllowThreads();
25742 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25743
25744 wxPyEndAllowThreads(__tstate);
25745 if (PyErr_Occurred()) SWIG_fail;
25746 }
25747 {
25748 wxDateSpan * resultptr;
25749 resultptr = new wxDateSpan((wxDateSpan &)(result));
25750 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25751 }
25752 return resultobj;
25753 fail:
25754 return NULL;
25755 }
25756
25757
25758 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25759 PyObject *resultobj;
25760 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25761 wxDateSpan *arg2 = 0 ;
25762 wxDateSpan result;
25763 PyObject * obj0 = 0 ;
25764 PyObject * obj1 = 0 ;
25765 char *kwnames[] = {
25766 (char *) "self",(char *) "other", NULL
25767 };
25768
25769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25771 if (SWIG_arg_fail(1)) SWIG_fail;
25772 {
25773 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25774 if (SWIG_arg_fail(2)) SWIG_fail;
25775 if (arg2 == NULL) {
25776 SWIG_null_ref("wxDateSpan");
25777 }
25778 if (SWIG_arg_fail(2)) SWIG_fail;
25779 }
25780 {
25781 PyThreadState* __tstate = wxPyBeginAllowThreads();
25782 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
25783
25784 wxPyEndAllowThreads(__tstate);
25785 if (PyErr_Occurred()) SWIG_fail;
25786 }
25787 {
25788 wxDateSpan * resultptr;
25789 resultptr = new wxDateSpan((wxDateSpan &)(result));
25790 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25791 }
25792 return resultobj;
25793 fail:
25794 return NULL;
25795 }
25796
25797
25798 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25799 PyObject *resultobj;
25800 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25801 int arg2 ;
25802 wxDateSpan result;
25803 PyObject * obj0 = 0 ;
25804 PyObject * obj1 = 0 ;
25805 char *kwnames[] = {
25806 (char *) "self",(char *) "n", NULL
25807 };
25808
25809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25811 if (SWIG_arg_fail(1)) SWIG_fail;
25812 {
25813 arg2 = (int)(SWIG_As_int(obj1));
25814 if (SWIG_arg_fail(2)) SWIG_fail;
25815 }
25816 {
25817 PyThreadState* __tstate = wxPyBeginAllowThreads();
25818 result = wxDateSpan___mul__(arg1,arg2);
25819
25820 wxPyEndAllowThreads(__tstate);
25821 if (PyErr_Occurred()) SWIG_fail;
25822 }
25823 {
25824 wxDateSpan * resultptr;
25825 resultptr = new wxDateSpan((wxDateSpan &)(result));
25826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25827 }
25828 return resultobj;
25829 fail:
25830 return NULL;
25831 }
25832
25833
25834 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25835 PyObject *resultobj;
25836 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25837 int arg2 ;
25838 wxDateSpan result;
25839 PyObject * obj0 = 0 ;
25840 PyObject * obj1 = 0 ;
25841 char *kwnames[] = {
25842 (char *) "self",(char *) "n", NULL
25843 };
25844
25845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25847 if (SWIG_arg_fail(1)) SWIG_fail;
25848 {
25849 arg2 = (int)(SWIG_As_int(obj1));
25850 if (SWIG_arg_fail(2)) SWIG_fail;
25851 }
25852 {
25853 PyThreadState* __tstate = wxPyBeginAllowThreads();
25854 result = wxDateSpan___rmul__(arg1,arg2);
25855
25856 wxPyEndAllowThreads(__tstate);
25857 if (PyErr_Occurred()) SWIG_fail;
25858 }
25859 {
25860 wxDateSpan * resultptr;
25861 resultptr = new wxDateSpan((wxDateSpan &)(result));
25862 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25863 }
25864 return resultobj;
25865 fail:
25866 return NULL;
25867 }
25868
25869
25870 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
25871 PyObject *resultobj;
25872 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25873 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25874 bool result;
25875 PyObject * obj0 = 0 ;
25876 PyObject * obj1 = 0 ;
25877 char *kwnames[] = {
25878 (char *) "self",(char *) "other", NULL
25879 };
25880
25881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
25882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25883 if (SWIG_arg_fail(1)) SWIG_fail;
25884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25885 if (SWIG_arg_fail(2)) SWIG_fail;
25886 {
25887 PyThreadState* __tstate = wxPyBeginAllowThreads();
25888 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
25889
25890 wxPyEndAllowThreads(__tstate);
25891 if (PyErr_Occurred()) SWIG_fail;
25892 }
25893 {
25894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25895 }
25896 return resultobj;
25897 fail:
25898 return NULL;
25899 }
25900
25901
25902 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
25903 PyObject *resultobj;
25904 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25905 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25906 bool result;
25907 PyObject * obj0 = 0 ;
25908 PyObject * obj1 = 0 ;
25909 char *kwnames[] = {
25910 (char *) "self",(char *) "other", NULL
25911 };
25912
25913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25915 if (SWIG_arg_fail(1)) SWIG_fail;
25916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25917 if (SWIG_arg_fail(2)) SWIG_fail;
25918 {
25919 PyThreadState* __tstate = wxPyBeginAllowThreads();
25920 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
25921
25922 wxPyEndAllowThreads(__tstate);
25923 if (PyErr_Occurred()) SWIG_fail;
25924 }
25925 {
25926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25927 }
25928 return resultobj;
25929 fail:
25930 return NULL;
25931 }
25932
25933
25934 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
25935 PyObject *obj;
25936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25937 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
25938 Py_INCREF(obj);
25939 return Py_BuildValue((char *)"");
25940 }
25941 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
25942 PyObject *resultobj;
25943 long result;
25944 char *kwnames[] = {
25945 NULL
25946 };
25947
25948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
25949 {
25950 PyThreadState* __tstate = wxPyBeginAllowThreads();
25951 result = (long)wxGetLocalTime();
25952
25953 wxPyEndAllowThreads(__tstate);
25954 if (PyErr_Occurred()) SWIG_fail;
25955 }
25956 {
25957 resultobj = SWIG_From_long((long)(result));
25958 }
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
25966 PyObject *resultobj;
25967 long result;
25968 char *kwnames[] = {
25969 NULL
25970 };
25971
25972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 result = (long)wxGetUTCTime();
25976
25977 wxPyEndAllowThreads(__tstate);
25978 if (PyErr_Occurred()) SWIG_fail;
25979 }
25980 {
25981 resultobj = SWIG_From_long((long)(result));
25982 }
25983 return resultobj;
25984 fail:
25985 return NULL;
25986 }
25987
25988
25989 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
25990 PyObject *resultobj;
25991 long result;
25992 char *kwnames[] = {
25993 NULL
25994 };
25995
25996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
25997 {
25998 PyThreadState* __tstate = wxPyBeginAllowThreads();
25999 result = (long)wxGetCurrentTime();
26000
26001 wxPyEndAllowThreads(__tstate);
26002 if (PyErr_Occurred()) SWIG_fail;
26003 }
26004 {
26005 resultobj = SWIG_From_long((long)(result));
26006 }
26007 return resultobj;
26008 fail:
26009 return NULL;
26010 }
26011
26012
26013 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26014 PyObject *resultobj;
26015 wxLongLong result;
26016 char *kwnames[] = {
26017 NULL
26018 };
26019
26020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26021 {
26022 PyThreadState* __tstate = wxPyBeginAllowThreads();
26023 result = wxGetLocalTimeMillis();
26024
26025 wxPyEndAllowThreads(__tstate);
26026 if (PyErr_Occurred()) SWIG_fail;
26027 }
26028 {
26029 PyObject *hi, *lo, *shifter, *shifted;
26030 hi = PyLong_FromLong( (&result)->GetHi() );
26031 lo = PyLong_FromLong( (&result)->GetLo() );
26032 shifter = PyLong_FromLong(32);
26033 shifted = PyNumber_Lshift(hi, shifter);
26034 resultobj = PyNumber_Or(shifted, lo);
26035 Py_DECREF(hi);
26036 Py_DECREF(lo);
26037 Py_DECREF(shifter);
26038 Py_DECREF(shifted);
26039 }
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 static int _wrap_DefaultDateTime_set(PyObject *) {
26047 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26048 return 1;
26049 }
26050
26051
26052 static PyObject *_wrap_DefaultDateTime_get(void) {
26053 PyObject *pyobj;
26054
26055 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26056 return pyobj;
26057 }
26058
26059
26060 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26061 PyObject *resultobj;
26062 wxDataFormatId arg1 ;
26063 wxDataFormat *result;
26064 PyObject * obj0 = 0 ;
26065 char *kwnames[] = {
26066 (char *) "type", NULL
26067 };
26068
26069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26070 {
26071 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26072 if (SWIG_arg_fail(1)) SWIG_fail;
26073 }
26074 {
26075 PyThreadState* __tstate = wxPyBeginAllowThreads();
26076 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26077
26078 wxPyEndAllowThreads(__tstate);
26079 if (PyErr_Occurred()) SWIG_fail;
26080 }
26081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26082 return resultobj;
26083 fail:
26084 return NULL;
26085 }
26086
26087
26088 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26089 PyObject *resultobj;
26090 wxString *arg1 = 0 ;
26091 wxDataFormat *result;
26092 bool temp1 = false ;
26093 PyObject * obj0 = 0 ;
26094 char *kwnames[] = {
26095 (char *) "format", NULL
26096 };
26097
26098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26099 {
26100 arg1 = wxString_in_helper(obj0);
26101 if (arg1 == NULL) SWIG_fail;
26102 temp1 = true;
26103 }
26104 {
26105 PyThreadState* __tstate = wxPyBeginAllowThreads();
26106 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26107
26108 wxPyEndAllowThreads(__tstate);
26109 if (PyErr_Occurred()) SWIG_fail;
26110 }
26111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26112 {
26113 if (temp1)
26114 delete arg1;
26115 }
26116 return resultobj;
26117 fail:
26118 {
26119 if (temp1)
26120 delete arg1;
26121 }
26122 return NULL;
26123 }
26124
26125
26126 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26127 PyObject *resultobj;
26128 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26129 PyObject * obj0 = 0 ;
26130 char *kwnames[] = {
26131 (char *) "self", NULL
26132 };
26133
26134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26136 if (SWIG_arg_fail(1)) SWIG_fail;
26137 {
26138 PyThreadState* __tstate = wxPyBeginAllowThreads();
26139 delete arg1;
26140
26141 wxPyEndAllowThreads(__tstate);
26142 if (PyErr_Occurred()) SWIG_fail;
26143 }
26144 Py_INCREF(Py_None); resultobj = Py_None;
26145 return resultobj;
26146 fail:
26147 return NULL;
26148 }
26149
26150
26151 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26152 PyObject *resultobj;
26153 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26154 wxDataFormatId arg2 ;
26155 bool result;
26156 PyObject * obj0 = 0 ;
26157 PyObject * obj1 = 0 ;
26158
26159 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26161 if (SWIG_arg_fail(1)) SWIG_fail;
26162 {
26163 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26164 if (SWIG_arg_fail(2)) SWIG_fail;
26165 }
26166 {
26167 PyThreadState* __tstate = wxPyBeginAllowThreads();
26168 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26169
26170 wxPyEndAllowThreads(__tstate);
26171 if (PyErr_Occurred()) SWIG_fail;
26172 }
26173 {
26174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26175 }
26176 return resultobj;
26177 fail:
26178 return NULL;
26179 }
26180
26181
26182 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26183 PyObject *resultobj;
26184 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26185 wxDataFormatId arg2 ;
26186 bool result;
26187 PyObject * obj0 = 0 ;
26188 PyObject * obj1 = 0 ;
26189
26190 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26192 if (SWIG_arg_fail(1)) SWIG_fail;
26193 {
26194 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26195 if (SWIG_arg_fail(2)) SWIG_fail;
26196 }
26197 {
26198 PyThreadState* __tstate = wxPyBeginAllowThreads();
26199 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26200
26201 wxPyEndAllowThreads(__tstate);
26202 if (PyErr_Occurred()) SWIG_fail;
26203 }
26204 {
26205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26206 }
26207 return resultobj;
26208 fail:
26209 return NULL;
26210 }
26211
26212
26213 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26214 PyObject *resultobj;
26215 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26216 wxDataFormat *arg2 = 0 ;
26217 bool result;
26218 PyObject * obj0 = 0 ;
26219 PyObject * obj1 = 0 ;
26220
26221 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26223 if (SWIG_arg_fail(1)) SWIG_fail;
26224 {
26225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26226 if (SWIG_arg_fail(2)) SWIG_fail;
26227 if (arg2 == NULL) {
26228 SWIG_null_ref("wxDataFormat");
26229 }
26230 if (SWIG_arg_fail(2)) SWIG_fail;
26231 }
26232 {
26233 PyThreadState* __tstate = wxPyBeginAllowThreads();
26234 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26235
26236 wxPyEndAllowThreads(__tstate);
26237 if (PyErr_Occurred()) SWIG_fail;
26238 }
26239 {
26240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26241 }
26242 return resultobj;
26243 fail:
26244 return NULL;
26245 }
26246
26247
26248 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26249 int argc;
26250 PyObject *argv[3];
26251 int ii;
26252
26253 argc = PyObject_Length(args);
26254 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26255 argv[ii] = PyTuple_GetItem(args,ii);
26256 }
26257 if (argc == 2) {
26258 int _v;
26259 {
26260 void *ptr;
26261 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26262 _v = 0;
26263 PyErr_Clear();
26264 } else {
26265 _v = 1;
26266 }
26267 }
26268 if (_v) {
26269 {
26270 void *ptr = 0;
26271 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26272 _v = 0;
26273 PyErr_Clear();
26274 } else {
26275 _v = (ptr != 0);
26276 }
26277 }
26278 if (_v) {
26279 return _wrap_DataFormat___eq____SWIG_1(self,args);
26280 }
26281 }
26282 }
26283 if (argc == 2) {
26284 int _v;
26285 {
26286 void *ptr;
26287 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26288 _v = 0;
26289 PyErr_Clear();
26290 } else {
26291 _v = 1;
26292 }
26293 }
26294 if (_v) {
26295 _v = SWIG_Check_int(argv[1]);
26296 if (_v) {
26297 return _wrap_DataFormat___eq____SWIG_0(self,args);
26298 }
26299 }
26300 }
26301
26302 Py_INCREF(Py_NotImplemented);
26303 return Py_NotImplemented;
26304 }
26305
26306
26307 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26308 PyObject *resultobj;
26309 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26310 wxDataFormat *arg2 = 0 ;
26311 bool result;
26312 PyObject * obj0 = 0 ;
26313 PyObject * obj1 = 0 ;
26314
26315 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26317 if (SWIG_arg_fail(1)) SWIG_fail;
26318 {
26319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26320 if (SWIG_arg_fail(2)) SWIG_fail;
26321 if (arg2 == NULL) {
26322 SWIG_null_ref("wxDataFormat");
26323 }
26324 if (SWIG_arg_fail(2)) SWIG_fail;
26325 }
26326 {
26327 PyThreadState* __tstate = wxPyBeginAllowThreads();
26328 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26329
26330 wxPyEndAllowThreads(__tstate);
26331 if (PyErr_Occurred()) SWIG_fail;
26332 }
26333 {
26334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26335 }
26336 return resultobj;
26337 fail:
26338 return NULL;
26339 }
26340
26341
26342 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26343 int argc;
26344 PyObject *argv[3];
26345 int ii;
26346
26347 argc = PyObject_Length(args);
26348 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26349 argv[ii] = PyTuple_GetItem(args,ii);
26350 }
26351 if (argc == 2) {
26352 int _v;
26353 {
26354 void *ptr;
26355 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26356 _v = 0;
26357 PyErr_Clear();
26358 } else {
26359 _v = 1;
26360 }
26361 }
26362 if (_v) {
26363 {
26364 void *ptr = 0;
26365 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26366 _v = 0;
26367 PyErr_Clear();
26368 } else {
26369 _v = (ptr != 0);
26370 }
26371 }
26372 if (_v) {
26373 return _wrap_DataFormat___ne____SWIG_1(self,args);
26374 }
26375 }
26376 }
26377 if (argc == 2) {
26378 int _v;
26379 {
26380 void *ptr;
26381 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26382 _v = 0;
26383 PyErr_Clear();
26384 } else {
26385 _v = 1;
26386 }
26387 }
26388 if (_v) {
26389 _v = SWIG_Check_int(argv[1]);
26390 if (_v) {
26391 return _wrap_DataFormat___ne____SWIG_0(self,args);
26392 }
26393 }
26394 }
26395
26396 Py_INCREF(Py_NotImplemented);
26397 return Py_NotImplemented;
26398 }
26399
26400
26401 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26402 PyObject *resultobj;
26403 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26404 wxDataFormatId arg2 ;
26405 PyObject * obj0 = 0 ;
26406 PyObject * obj1 = 0 ;
26407 char *kwnames[] = {
26408 (char *) "self",(char *) "format", NULL
26409 };
26410
26411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26413 if (SWIG_arg_fail(1)) SWIG_fail;
26414 {
26415 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26416 if (SWIG_arg_fail(2)) SWIG_fail;
26417 }
26418 {
26419 PyThreadState* __tstate = wxPyBeginAllowThreads();
26420 (arg1)->SetType((wxDataFormatId )arg2);
26421
26422 wxPyEndAllowThreads(__tstate);
26423 if (PyErr_Occurred()) SWIG_fail;
26424 }
26425 Py_INCREF(Py_None); resultobj = Py_None;
26426 return resultobj;
26427 fail:
26428 return NULL;
26429 }
26430
26431
26432 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26433 PyObject *resultobj;
26434 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26435 wxDataFormatId result;
26436 PyObject * obj0 = 0 ;
26437 char *kwnames[] = {
26438 (char *) "self", NULL
26439 };
26440
26441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26443 if (SWIG_arg_fail(1)) SWIG_fail;
26444 {
26445 PyThreadState* __tstate = wxPyBeginAllowThreads();
26446 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26447
26448 wxPyEndAllowThreads(__tstate);
26449 if (PyErr_Occurred()) SWIG_fail;
26450 }
26451 resultobj = SWIG_From_int((result));
26452 return resultobj;
26453 fail:
26454 return NULL;
26455 }
26456
26457
26458 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26459 PyObject *resultobj;
26460 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26461 wxString result;
26462 PyObject * obj0 = 0 ;
26463 char *kwnames[] = {
26464 (char *) "self", NULL
26465 };
26466
26467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26469 if (SWIG_arg_fail(1)) SWIG_fail;
26470 {
26471 PyThreadState* __tstate = wxPyBeginAllowThreads();
26472 result = ((wxDataFormat const *)arg1)->GetId();
26473
26474 wxPyEndAllowThreads(__tstate);
26475 if (PyErr_Occurred()) SWIG_fail;
26476 }
26477 {
26478 #if wxUSE_UNICODE
26479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26480 #else
26481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26482 #endif
26483 }
26484 return resultobj;
26485 fail:
26486 return NULL;
26487 }
26488
26489
26490 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26491 PyObject *resultobj;
26492 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26493 wxString *arg2 = 0 ;
26494 bool temp2 = false ;
26495 PyObject * obj0 = 0 ;
26496 PyObject * obj1 = 0 ;
26497 char *kwnames[] = {
26498 (char *) "self",(char *) "format", NULL
26499 };
26500
26501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26503 if (SWIG_arg_fail(1)) SWIG_fail;
26504 {
26505 arg2 = wxString_in_helper(obj1);
26506 if (arg2 == NULL) SWIG_fail;
26507 temp2 = true;
26508 }
26509 {
26510 PyThreadState* __tstate = wxPyBeginAllowThreads();
26511 (arg1)->SetId((wxString const &)*arg2);
26512
26513 wxPyEndAllowThreads(__tstate);
26514 if (PyErr_Occurred()) SWIG_fail;
26515 }
26516 Py_INCREF(Py_None); resultobj = Py_None;
26517 {
26518 if (temp2)
26519 delete arg2;
26520 }
26521 return resultobj;
26522 fail:
26523 {
26524 if (temp2)
26525 delete arg2;
26526 }
26527 return NULL;
26528 }
26529
26530
26531 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26532 PyObject *obj;
26533 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26534 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26535 Py_INCREF(obj);
26536 return Py_BuildValue((char *)"");
26537 }
26538 static int _wrap_FormatInvalid_set(PyObject *) {
26539 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26540 return 1;
26541 }
26542
26543
26544 static PyObject *_wrap_FormatInvalid_get(void) {
26545 PyObject *pyobj;
26546
26547 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26548 return pyobj;
26549 }
26550
26551
26552 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26553 PyObject *resultobj;
26554 wxDataObject *arg1 = (wxDataObject *) 0 ;
26555 PyObject * obj0 = 0 ;
26556 char *kwnames[] = {
26557 (char *) "self", NULL
26558 };
26559
26560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26562 if (SWIG_arg_fail(1)) SWIG_fail;
26563 {
26564 PyThreadState* __tstate = wxPyBeginAllowThreads();
26565 delete arg1;
26566
26567 wxPyEndAllowThreads(__tstate);
26568 if (PyErr_Occurred()) SWIG_fail;
26569 }
26570 Py_INCREF(Py_None); resultobj = Py_None;
26571 return resultobj;
26572 fail:
26573 return NULL;
26574 }
26575
26576
26577 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26578 PyObject *resultobj;
26579 wxDataObject *arg1 = (wxDataObject *) 0 ;
26580 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26581 SwigValueWrapper<wxDataFormat > result;
26582 PyObject * obj0 = 0 ;
26583 PyObject * obj1 = 0 ;
26584 char *kwnames[] = {
26585 (char *) "self",(char *) "dir", NULL
26586 };
26587
26588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26590 if (SWIG_arg_fail(1)) SWIG_fail;
26591 if (obj1) {
26592 {
26593 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26594 if (SWIG_arg_fail(2)) SWIG_fail;
26595 }
26596 }
26597 {
26598 PyThreadState* __tstate = wxPyBeginAllowThreads();
26599 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26600
26601 wxPyEndAllowThreads(__tstate);
26602 if (PyErr_Occurred()) SWIG_fail;
26603 }
26604 {
26605 wxDataFormat * resultptr;
26606 resultptr = new wxDataFormat((wxDataFormat &)(result));
26607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26608 }
26609 return resultobj;
26610 fail:
26611 return NULL;
26612 }
26613
26614
26615 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26616 PyObject *resultobj;
26617 wxDataObject *arg1 = (wxDataObject *) 0 ;
26618 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26619 size_t result;
26620 PyObject * obj0 = 0 ;
26621 PyObject * obj1 = 0 ;
26622 char *kwnames[] = {
26623 (char *) "self",(char *) "dir", NULL
26624 };
26625
26626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26628 if (SWIG_arg_fail(1)) SWIG_fail;
26629 if (obj1) {
26630 {
26631 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26632 if (SWIG_arg_fail(2)) SWIG_fail;
26633 }
26634 }
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26638
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 {
26643 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26644 }
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26652 PyObject *resultobj;
26653 wxDataObject *arg1 = (wxDataObject *) 0 ;
26654 wxDataFormat *arg2 = 0 ;
26655 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26656 bool result;
26657 PyObject * obj0 = 0 ;
26658 PyObject * obj1 = 0 ;
26659 PyObject * obj2 = 0 ;
26660 char *kwnames[] = {
26661 (char *) "self",(char *) "format",(char *) "dir", NULL
26662 };
26663
26664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26666 if (SWIG_arg_fail(1)) SWIG_fail;
26667 {
26668 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26669 if (SWIG_arg_fail(2)) SWIG_fail;
26670 if (arg2 == NULL) {
26671 SWIG_null_ref("wxDataFormat");
26672 }
26673 if (SWIG_arg_fail(2)) SWIG_fail;
26674 }
26675 if (obj2) {
26676 {
26677 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26678 if (SWIG_arg_fail(3)) SWIG_fail;
26679 }
26680 }
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26684
26685 wxPyEndAllowThreads(__tstate);
26686 if (PyErr_Occurred()) SWIG_fail;
26687 }
26688 {
26689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26690 }
26691 return resultobj;
26692 fail:
26693 return NULL;
26694 }
26695
26696
26697 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26698 PyObject *resultobj;
26699 wxDataObject *arg1 = (wxDataObject *) 0 ;
26700 wxDataFormat *arg2 = 0 ;
26701 size_t result;
26702 PyObject * obj0 = 0 ;
26703 PyObject * obj1 = 0 ;
26704 char *kwnames[] = {
26705 (char *) "self",(char *) "format", NULL
26706 };
26707
26708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26710 if (SWIG_arg_fail(1)) SWIG_fail;
26711 {
26712 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26713 if (SWIG_arg_fail(2)) SWIG_fail;
26714 if (arg2 == NULL) {
26715 SWIG_null_ref("wxDataFormat");
26716 }
26717 if (SWIG_arg_fail(2)) SWIG_fail;
26718 }
26719 {
26720 PyThreadState* __tstate = wxPyBeginAllowThreads();
26721 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26722
26723 wxPyEndAllowThreads(__tstate);
26724 if (PyErr_Occurred()) SWIG_fail;
26725 }
26726 {
26727 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26728 }
26729 return resultobj;
26730 fail:
26731 return NULL;
26732 }
26733
26734
26735 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26736 PyObject *resultobj;
26737 wxDataObject *arg1 = (wxDataObject *) 0 ;
26738 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26739 PyObject *result;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 char *kwnames[] = {
26743 (char *) "self",(char *) "dir", NULL
26744 };
26745
26746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26748 if (SWIG_arg_fail(1)) SWIG_fail;
26749 if (obj1) {
26750 {
26751 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26752 if (SWIG_arg_fail(2)) SWIG_fail;
26753 }
26754 }
26755 {
26756 PyThreadState* __tstate = wxPyBeginAllowThreads();
26757 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26758
26759 wxPyEndAllowThreads(__tstate);
26760 if (PyErr_Occurred()) SWIG_fail;
26761 }
26762 resultobj = result;
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26770 PyObject *resultobj;
26771 wxDataObject *arg1 = (wxDataObject *) 0 ;
26772 wxDataFormat *arg2 = 0 ;
26773 PyObject *result;
26774 PyObject * obj0 = 0 ;
26775 PyObject * obj1 = 0 ;
26776 char *kwnames[] = {
26777 (char *) "self",(char *) "format", NULL
26778 };
26779
26780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
26781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26782 if (SWIG_arg_fail(1)) SWIG_fail;
26783 {
26784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26785 if (SWIG_arg_fail(2)) SWIG_fail;
26786 if (arg2 == NULL) {
26787 SWIG_null_ref("wxDataFormat");
26788 }
26789 if (SWIG_arg_fail(2)) SWIG_fail;
26790 }
26791 {
26792 PyThreadState* __tstate = wxPyBeginAllowThreads();
26793 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
26794
26795 wxPyEndAllowThreads(__tstate);
26796 if (PyErr_Occurred()) SWIG_fail;
26797 }
26798 resultobj = result;
26799 return resultobj;
26800 fail:
26801 return NULL;
26802 }
26803
26804
26805 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
26806 PyObject *resultobj;
26807 wxDataObject *arg1 = (wxDataObject *) 0 ;
26808 wxDataFormat *arg2 = 0 ;
26809 PyObject *arg3 = (PyObject *) 0 ;
26810 bool result;
26811 PyObject * obj0 = 0 ;
26812 PyObject * obj1 = 0 ;
26813 PyObject * obj2 = 0 ;
26814 char *kwnames[] = {
26815 (char *) "self",(char *) "format",(char *) "data", NULL
26816 };
26817
26818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
26819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26820 if (SWIG_arg_fail(1)) SWIG_fail;
26821 {
26822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26823 if (SWIG_arg_fail(2)) SWIG_fail;
26824 if (arg2 == NULL) {
26825 SWIG_null_ref("wxDataFormat");
26826 }
26827 if (SWIG_arg_fail(2)) SWIG_fail;
26828 }
26829 arg3 = obj2;
26830 {
26831 PyThreadState* __tstate = wxPyBeginAllowThreads();
26832 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
26833
26834 wxPyEndAllowThreads(__tstate);
26835 if (PyErr_Occurred()) SWIG_fail;
26836 }
26837 {
26838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26839 }
26840 return resultobj;
26841 fail:
26842 return NULL;
26843 }
26844
26845
26846 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
26847 PyObject *obj;
26848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26849 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
26850 Py_INCREF(obj);
26851 return Py_BuildValue((char *)"");
26852 }
26853 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj;
26855 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
26856 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
26857 wxDataObjectSimple *result;
26858 PyObject * obj0 = 0 ;
26859 char *kwnames[] = {
26860 (char *) "format", NULL
26861 };
26862
26863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
26864 if (obj0) {
26865 {
26866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26867 if (SWIG_arg_fail(1)) SWIG_fail;
26868 if (arg1 == NULL) {
26869 SWIG_null_ref("wxDataFormat");
26870 }
26871 if (SWIG_arg_fail(1)) SWIG_fail;
26872 }
26873 }
26874 {
26875 PyThreadState* __tstate = wxPyBeginAllowThreads();
26876 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
26877
26878 wxPyEndAllowThreads(__tstate);
26879 if (PyErr_Occurred()) SWIG_fail;
26880 }
26881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
26882 return resultobj;
26883 fail:
26884 return NULL;
26885 }
26886
26887
26888 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26889 PyObject *resultobj;
26890 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26891 wxDataFormat *result;
26892 PyObject * obj0 = 0 ;
26893 char *kwnames[] = {
26894 (char *) "self", NULL
26895 };
26896
26897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
26898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26899 if (SWIG_arg_fail(1)) SWIG_fail;
26900 {
26901 PyThreadState* __tstate = wxPyBeginAllowThreads();
26902 {
26903 wxDataFormat const &_result_ref = (arg1)->GetFormat();
26904 result = (wxDataFormat *) &_result_ref;
26905 }
26906
26907 wxPyEndAllowThreads(__tstate);
26908 if (PyErr_Occurred()) SWIG_fail;
26909 }
26910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
26911 return resultobj;
26912 fail:
26913 return NULL;
26914 }
26915
26916
26917 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26918 PyObject *resultobj;
26919 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26920 wxDataFormat *arg2 = 0 ;
26921 PyObject * obj0 = 0 ;
26922 PyObject * obj1 = 0 ;
26923 char *kwnames[] = {
26924 (char *) "self",(char *) "format", NULL
26925 };
26926
26927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
26928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26929 if (SWIG_arg_fail(1)) SWIG_fail;
26930 {
26931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26932 if (SWIG_arg_fail(2)) SWIG_fail;
26933 if (arg2 == NULL) {
26934 SWIG_null_ref("wxDataFormat");
26935 }
26936 if (SWIG_arg_fail(2)) SWIG_fail;
26937 }
26938 {
26939 PyThreadState* __tstate = wxPyBeginAllowThreads();
26940 (arg1)->SetFormat((wxDataFormat const &)*arg2);
26941
26942 wxPyEndAllowThreads(__tstate);
26943 if (PyErr_Occurred()) SWIG_fail;
26944 }
26945 Py_INCREF(Py_None); resultobj = Py_None;
26946 return resultobj;
26947 fail:
26948 return NULL;
26949 }
26950
26951
26952 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26953 PyObject *resultobj;
26954 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26955 size_t result;
26956 PyObject * obj0 = 0 ;
26957 char *kwnames[] = {
26958 (char *) "self", NULL
26959 };
26960
26961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
26962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26963 if (SWIG_arg_fail(1)) SWIG_fail;
26964 {
26965 PyThreadState* __tstate = wxPyBeginAllowThreads();
26966 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
26967
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 {
26972 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26973 }
26974 return resultobj;
26975 fail:
26976 return NULL;
26977 }
26978
26979
26980 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26981 PyObject *resultobj;
26982 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26983 PyObject *result;
26984 PyObject * obj0 = 0 ;
26985 char *kwnames[] = {
26986 (char *) "self", NULL
26987 };
26988
26989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
26990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26991 if (SWIG_arg_fail(1)) SWIG_fail;
26992 {
26993 PyThreadState* __tstate = wxPyBeginAllowThreads();
26994 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
26995
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 resultobj = result;
27000 return resultobj;
27001 fail:
27002 return NULL;
27003 }
27004
27005
27006 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27007 PyObject *resultobj;
27008 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27009 PyObject *arg2 = (PyObject *) 0 ;
27010 bool result;
27011 PyObject * obj0 = 0 ;
27012 PyObject * obj1 = 0 ;
27013 char *kwnames[] = {
27014 (char *) "self",(char *) "data", NULL
27015 };
27016
27017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27019 if (SWIG_arg_fail(1)) SWIG_fail;
27020 arg2 = obj1;
27021 {
27022 PyThreadState* __tstate = wxPyBeginAllowThreads();
27023 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27024
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 {
27029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27030 }
27031 return resultobj;
27032 fail:
27033 return NULL;
27034 }
27035
27036
27037 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27038 PyObject *obj;
27039 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27040 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27041 Py_INCREF(obj);
27042 return Py_BuildValue((char *)"");
27043 }
27044 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27045 PyObject *resultobj;
27046 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27047 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27048 wxPyDataObjectSimple *result;
27049 PyObject * obj0 = 0 ;
27050 char *kwnames[] = {
27051 (char *) "format", NULL
27052 };
27053
27054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27055 if (obj0) {
27056 {
27057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27058 if (SWIG_arg_fail(1)) SWIG_fail;
27059 if (arg1 == NULL) {
27060 SWIG_null_ref("wxDataFormat");
27061 }
27062 if (SWIG_arg_fail(1)) SWIG_fail;
27063 }
27064 }
27065 {
27066 PyThreadState* __tstate = wxPyBeginAllowThreads();
27067 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27068
27069 wxPyEndAllowThreads(__tstate);
27070 if (PyErr_Occurred()) SWIG_fail;
27071 }
27072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27073 return resultobj;
27074 fail:
27075 return NULL;
27076 }
27077
27078
27079 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27080 PyObject *resultobj;
27081 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27082 PyObject *arg2 = (PyObject *) 0 ;
27083 PyObject *arg3 = (PyObject *) 0 ;
27084 PyObject * obj0 = 0 ;
27085 PyObject * obj1 = 0 ;
27086 PyObject * obj2 = 0 ;
27087 char *kwnames[] = {
27088 (char *) "self",(char *) "self",(char *) "_class", NULL
27089 };
27090
27091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27093 if (SWIG_arg_fail(1)) SWIG_fail;
27094 arg2 = obj1;
27095 arg3 = obj2;
27096 {
27097 PyThreadState* __tstate = wxPyBeginAllowThreads();
27098 (arg1)->_setCallbackInfo(arg2,arg3);
27099
27100 wxPyEndAllowThreads(__tstate);
27101 if (PyErr_Occurred()) SWIG_fail;
27102 }
27103 Py_INCREF(Py_None); resultobj = Py_None;
27104 return resultobj;
27105 fail:
27106 return NULL;
27107 }
27108
27109
27110 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27111 PyObject *obj;
27112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27113 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27114 Py_INCREF(obj);
27115 return Py_BuildValue((char *)"");
27116 }
27117 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27118 PyObject *resultobj;
27119 wxDataObjectComposite *result;
27120 char *kwnames[] = {
27121 NULL
27122 };
27123
27124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27125 {
27126 PyThreadState* __tstate = wxPyBeginAllowThreads();
27127 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27128
27129 wxPyEndAllowThreads(__tstate);
27130 if (PyErr_Occurred()) SWIG_fail;
27131 }
27132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27133 return resultobj;
27134 fail:
27135 return NULL;
27136 }
27137
27138
27139 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27140 PyObject *resultobj;
27141 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27142 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27143 bool arg3 = (bool) false ;
27144 PyObject * obj0 = 0 ;
27145 PyObject * obj1 = 0 ;
27146 PyObject * obj2 = 0 ;
27147 char *kwnames[] = {
27148 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27149 };
27150
27151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27153 if (SWIG_arg_fail(1)) SWIG_fail;
27154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27155 if (SWIG_arg_fail(2)) SWIG_fail;
27156 if (obj2) {
27157 {
27158 arg3 = (bool)(SWIG_As_bool(obj2));
27159 if (SWIG_arg_fail(3)) SWIG_fail;
27160 }
27161 }
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 (arg1)->Add(arg2,arg3);
27165
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 Py_INCREF(Py_None); resultobj = Py_None;
27170 return resultobj;
27171 fail:
27172 return NULL;
27173 }
27174
27175
27176 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27177 PyObject *obj;
27178 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27179 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27180 Py_INCREF(obj);
27181 return Py_BuildValue((char *)"");
27182 }
27183 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27184 PyObject *resultobj;
27185 wxString const &arg1_defvalue = wxPyEmptyString ;
27186 wxString *arg1 = (wxString *) &arg1_defvalue ;
27187 wxTextDataObject *result;
27188 bool temp1 = false ;
27189 PyObject * obj0 = 0 ;
27190 char *kwnames[] = {
27191 (char *) "text", NULL
27192 };
27193
27194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27195 if (obj0) {
27196 {
27197 arg1 = wxString_in_helper(obj0);
27198 if (arg1 == NULL) SWIG_fail;
27199 temp1 = true;
27200 }
27201 }
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27205
27206 wxPyEndAllowThreads(__tstate);
27207 if (PyErr_Occurred()) SWIG_fail;
27208 }
27209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27210 {
27211 if (temp1)
27212 delete arg1;
27213 }
27214 return resultobj;
27215 fail:
27216 {
27217 if (temp1)
27218 delete arg1;
27219 }
27220 return NULL;
27221 }
27222
27223
27224 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27225 PyObject *resultobj;
27226 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27227 size_t result;
27228 PyObject * obj0 = 0 ;
27229 char *kwnames[] = {
27230 (char *) "self", NULL
27231 };
27232
27233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27235 if (SWIG_arg_fail(1)) SWIG_fail;
27236 {
27237 PyThreadState* __tstate = wxPyBeginAllowThreads();
27238 result = (size_t)(arg1)->GetTextLength();
27239
27240 wxPyEndAllowThreads(__tstate);
27241 if (PyErr_Occurred()) SWIG_fail;
27242 }
27243 {
27244 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27245 }
27246 return resultobj;
27247 fail:
27248 return NULL;
27249 }
27250
27251
27252 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27253 PyObject *resultobj;
27254 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27255 wxString result;
27256 PyObject * obj0 = 0 ;
27257 char *kwnames[] = {
27258 (char *) "self", NULL
27259 };
27260
27261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27263 if (SWIG_arg_fail(1)) SWIG_fail;
27264 {
27265 PyThreadState* __tstate = wxPyBeginAllowThreads();
27266 result = (arg1)->GetText();
27267
27268 wxPyEndAllowThreads(__tstate);
27269 if (PyErr_Occurred()) SWIG_fail;
27270 }
27271 {
27272 #if wxUSE_UNICODE
27273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27274 #else
27275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27276 #endif
27277 }
27278 return resultobj;
27279 fail:
27280 return NULL;
27281 }
27282
27283
27284 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27285 PyObject *resultobj;
27286 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27287 wxString *arg2 = 0 ;
27288 bool temp2 = false ;
27289 PyObject * obj0 = 0 ;
27290 PyObject * obj1 = 0 ;
27291 char *kwnames[] = {
27292 (char *) "self",(char *) "text", NULL
27293 };
27294
27295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27297 if (SWIG_arg_fail(1)) SWIG_fail;
27298 {
27299 arg2 = wxString_in_helper(obj1);
27300 if (arg2 == NULL) SWIG_fail;
27301 temp2 = true;
27302 }
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 (arg1)->SetText((wxString const &)*arg2);
27306
27307 wxPyEndAllowThreads(__tstate);
27308 if (PyErr_Occurred()) SWIG_fail;
27309 }
27310 Py_INCREF(Py_None); resultobj = Py_None;
27311 {
27312 if (temp2)
27313 delete arg2;
27314 }
27315 return resultobj;
27316 fail:
27317 {
27318 if (temp2)
27319 delete arg2;
27320 }
27321 return NULL;
27322 }
27323
27324
27325 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27326 PyObject *obj;
27327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27328 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27329 Py_INCREF(obj);
27330 return Py_BuildValue((char *)"");
27331 }
27332 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27333 PyObject *resultobj;
27334 wxString const &arg1_defvalue = wxPyEmptyString ;
27335 wxString *arg1 = (wxString *) &arg1_defvalue ;
27336 wxPyTextDataObject *result;
27337 bool temp1 = false ;
27338 PyObject * obj0 = 0 ;
27339 char *kwnames[] = {
27340 (char *) "text", NULL
27341 };
27342
27343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27344 if (obj0) {
27345 {
27346 arg1 = wxString_in_helper(obj0);
27347 if (arg1 == NULL) SWIG_fail;
27348 temp1 = true;
27349 }
27350 }
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27354
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27359 {
27360 if (temp1)
27361 delete arg1;
27362 }
27363 return resultobj;
27364 fail:
27365 {
27366 if (temp1)
27367 delete arg1;
27368 }
27369 return NULL;
27370 }
27371
27372
27373 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27374 PyObject *resultobj;
27375 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27376 PyObject *arg2 = (PyObject *) 0 ;
27377 PyObject *arg3 = (PyObject *) 0 ;
27378 PyObject * obj0 = 0 ;
27379 PyObject * obj1 = 0 ;
27380 PyObject * obj2 = 0 ;
27381 char *kwnames[] = {
27382 (char *) "self",(char *) "self",(char *) "_class", NULL
27383 };
27384
27385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27387 if (SWIG_arg_fail(1)) SWIG_fail;
27388 arg2 = obj1;
27389 arg3 = obj2;
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 (arg1)->_setCallbackInfo(arg2,arg3);
27393
27394 wxPyEndAllowThreads(__tstate);
27395 if (PyErr_Occurred()) SWIG_fail;
27396 }
27397 Py_INCREF(Py_None); resultobj = Py_None;
27398 return resultobj;
27399 fail:
27400 return NULL;
27401 }
27402
27403
27404 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27405 PyObject *obj;
27406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27407 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27408 Py_INCREF(obj);
27409 return Py_BuildValue((char *)"");
27410 }
27411 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27412 PyObject *resultobj;
27413 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27414 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27415 wxBitmapDataObject *result;
27416 PyObject * obj0 = 0 ;
27417 char *kwnames[] = {
27418 (char *) "bitmap", NULL
27419 };
27420
27421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27422 if (obj0) {
27423 {
27424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27425 if (SWIG_arg_fail(1)) SWIG_fail;
27426 if (arg1 == NULL) {
27427 SWIG_null_ref("wxBitmap");
27428 }
27429 if (SWIG_arg_fail(1)) SWIG_fail;
27430 }
27431 }
27432 {
27433 PyThreadState* __tstate = wxPyBeginAllowThreads();
27434 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27435
27436 wxPyEndAllowThreads(__tstate);
27437 if (PyErr_Occurred()) SWIG_fail;
27438 }
27439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27440 return resultobj;
27441 fail:
27442 return NULL;
27443 }
27444
27445
27446 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27447 PyObject *resultobj;
27448 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27449 wxBitmap result;
27450 PyObject * obj0 = 0 ;
27451 char *kwnames[] = {
27452 (char *) "self", NULL
27453 };
27454
27455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27457 if (SWIG_arg_fail(1)) SWIG_fail;
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27461
27462 wxPyEndAllowThreads(__tstate);
27463 if (PyErr_Occurred()) SWIG_fail;
27464 }
27465 {
27466 wxBitmap * resultptr;
27467 resultptr = new wxBitmap((wxBitmap &)(result));
27468 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27469 }
27470 return resultobj;
27471 fail:
27472 return NULL;
27473 }
27474
27475
27476 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27477 PyObject *resultobj;
27478 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27479 wxBitmap *arg2 = 0 ;
27480 PyObject * obj0 = 0 ;
27481 PyObject * obj1 = 0 ;
27482 char *kwnames[] = {
27483 (char *) "self",(char *) "bitmap", NULL
27484 };
27485
27486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27488 if (SWIG_arg_fail(1)) SWIG_fail;
27489 {
27490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27491 if (SWIG_arg_fail(2)) SWIG_fail;
27492 if (arg2 == NULL) {
27493 SWIG_null_ref("wxBitmap");
27494 }
27495 if (SWIG_arg_fail(2)) SWIG_fail;
27496 }
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27500
27501 wxPyEndAllowThreads(__tstate);
27502 if (PyErr_Occurred()) SWIG_fail;
27503 }
27504 Py_INCREF(Py_None); resultobj = Py_None;
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27512 PyObject *obj;
27513 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27514 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27515 Py_INCREF(obj);
27516 return Py_BuildValue((char *)"");
27517 }
27518 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27519 PyObject *resultobj;
27520 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27521 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27522 wxPyBitmapDataObject *result;
27523 PyObject * obj0 = 0 ;
27524 char *kwnames[] = {
27525 (char *) "bitmap", NULL
27526 };
27527
27528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27529 if (obj0) {
27530 {
27531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27532 if (SWIG_arg_fail(1)) SWIG_fail;
27533 if (arg1 == NULL) {
27534 SWIG_null_ref("wxBitmap");
27535 }
27536 if (SWIG_arg_fail(1)) SWIG_fail;
27537 }
27538 }
27539 {
27540 PyThreadState* __tstate = wxPyBeginAllowThreads();
27541 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27542
27543 wxPyEndAllowThreads(__tstate);
27544 if (PyErr_Occurred()) SWIG_fail;
27545 }
27546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27547 return resultobj;
27548 fail:
27549 return NULL;
27550 }
27551
27552
27553 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27554 PyObject *resultobj;
27555 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27556 PyObject *arg2 = (PyObject *) 0 ;
27557 PyObject *arg3 = (PyObject *) 0 ;
27558 PyObject * obj0 = 0 ;
27559 PyObject * obj1 = 0 ;
27560 PyObject * obj2 = 0 ;
27561 char *kwnames[] = {
27562 (char *) "self",(char *) "self",(char *) "_class", NULL
27563 };
27564
27565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27567 if (SWIG_arg_fail(1)) SWIG_fail;
27568 arg2 = obj1;
27569 arg3 = obj2;
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 (arg1)->_setCallbackInfo(arg2,arg3);
27573
27574 wxPyEndAllowThreads(__tstate);
27575 if (PyErr_Occurred()) SWIG_fail;
27576 }
27577 Py_INCREF(Py_None); resultobj = Py_None;
27578 return resultobj;
27579 fail:
27580 return NULL;
27581 }
27582
27583
27584 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27585 PyObject *obj;
27586 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27587 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27588 Py_INCREF(obj);
27589 return Py_BuildValue((char *)"");
27590 }
27591 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27592 PyObject *resultobj;
27593 wxFileDataObject *result;
27594 char *kwnames[] = {
27595 NULL
27596 };
27597
27598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27599 {
27600 PyThreadState* __tstate = wxPyBeginAllowThreads();
27601 result = (wxFileDataObject *)new wxFileDataObject();
27602
27603 wxPyEndAllowThreads(__tstate);
27604 if (PyErr_Occurred()) SWIG_fail;
27605 }
27606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27614 PyObject *resultobj;
27615 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27616 wxArrayString *result;
27617 PyObject * obj0 = 0 ;
27618 char *kwnames[] = {
27619 (char *) "self", NULL
27620 };
27621
27622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27624 if (SWIG_arg_fail(1)) SWIG_fail;
27625 {
27626 PyThreadState* __tstate = wxPyBeginAllowThreads();
27627 {
27628 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27629 result = (wxArrayString *) &_result_ref;
27630 }
27631
27632 wxPyEndAllowThreads(__tstate);
27633 if (PyErr_Occurred()) SWIG_fail;
27634 }
27635 {
27636 resultobj = wxArrayString2PyList_helper(*result);
27637 }
27638 return resultobj;
27639 fail:
27640 return NULL;
27641 }
27642
27643
27644 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27645 PyObject *resultobj;
27646 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27647 wxString *arg2 = 0 ;
27648 bool temp2 = false ;
27649 PyObject * obj0 = 0 ;
27650 PyObject * obj1 = 0 ;
27651 char *kwnames[] = {
27652 (char *) "self",(char *) "filename", NULL
27653 };
27654
27655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27657 if (SWIG_arg_fail(1)) SWIG_fail;
27658 {
27659 arg2 = wxString_in_helper(obj1);
27660 if (arg2 == NULL) SWIG_fail;
27661 temp2 = true;
27662 }
27663 {
27664 PyThreadState* __tstate = wxPyBeginAllowThreads();
27665 (arg1)->AddFile((wxString const &)*arg2);
27666
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 Py_INCREF(Py_None); resultobj = Py_None;
27671 {
27672 if (temp2)
27673 delete arg2;
27674 }
27675 return resultobj;
27676 fail:
27677 {
27678 if (temp2)
27679 delete arg2;
27680 }
27681 return NULL;
27682 }
27683
27684
27685 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27686 PyObject *obj;
27687 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27688 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27689 Py_INCREF(obj);
27690 return Py_BuildValue((char *)"");
27691 }
27692 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
27693 PyObject *resultobj;
27694 wxDataFormat *arg1 = 0 ;
27695 wxCustomDataObject *result;
27696 PyObject * obj0 = 0 ;
27697
27698 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27699 {
27700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27701 if (SWIG_arg_fail(1)) SWIG_fail;
27702 if (arg1 == NULL) {
27703 SWIG_null_ref("wxDataFormat");
27704 }
27705 if (SWIG_arg_fail(1)) SWIG_fail;
27706 }
27707 {
27708 PyThreadState* __tstate = wxPyBeginAllowThreads();
27709 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27710
27711 wxPyEndAllowThreads(__tstate);
27712 if (PyErr_Occurred()) SWIG_fail;
27713 }
27714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27715 return resultobj;
27716 fail:
27717 return NULL;
27718 }
27719
27720
27721 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
27722 PyObject *resultobj;
27723 wxString *arg1 = 0 ;
27724 wxCustomDataObject *result;
27725 bool temp1 = false ;
27726 PyObject * obj0 = 0 ;
27727
27728 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27729 {
27730 arg1 = wxString_in_helper(obj0);
27731 if (arg1 == NULL) SWIG_fail;
27732 temp1 = true;
27733 }
27734 {
27735 PyThreadState* __tstate = wxPyBeginAllowThreads();
27736 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
27737
27738 wxPyEndAllowThreads(__tstate);
27739 if (PyErr_Occurred()) SWIG_fail;
27740 }
27741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27742 {
27743 if (temp1)
27744 delete arg1;
27745 }
27746 return resultobj;
27747 fail:
27748 {
27749 if (temp1)
27750 delete arg1;
27751 }
27752 return NULL;
27753 }
27754
27755
27756 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
27757 PyObject *resultobj;
27758 wxCustomDataObject *result;
27759
27760 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
27761 {
27762 PyThreadState* __tstate = wxPyBeginAllowThreads();
27763 result = (wxCustomDataObject *)new wxCustomDataObject();
27764
27765 wxPyEndAllowThreads(__tstate);
27766 if (PyErr_Occurred()) SWIG_fail;
27767 }
27768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
27776 int argc;
27777 PyObject *argv[2];
27778 int ii;
27779
27780 argc = PyObject_Length(args);
27781 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
27782 argv[ii] = PyTuple_GetItem(args,ii);
27783 }
27784 if (argc == 0) {
27785 return _wrap_new_CustomDataObject__SWIG_2(self,args);
27786 }
27787 if (argc == 1) {
27788 int _v;
27789 {
27790 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
27791 }
27792 if (_v) {
27793 return _wrap_new_CustomDataObject__SWIG_1(self,args);
27794 }
27795 }
27796 if (argc == 1) {
27797 int _v;
27798 {
27799 void *ptr = 0;
27800 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27801 _v = 0;
27802 PyErr_Clear();
27803 } else {
27804 _v = (ptr != 0);
27805 }
27806 }
27807 if (_v) {
27808 return _wrap_new_CustomDataObject__SWIG_0(self,args);
27809 }
27810 }
27811
27812 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
27813 return NULL;
27814 }
27815
27816
27817 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27818 PyObject *resultobj;
27819 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27820 PyObject *arg2 = (PyObject *) 0 ;
27821 bool result;
27822 PyObject * obj0 = 0 ;
27823 PyObject * obj1 = 0 ;
27824 char *kwnames[] = {
27825 (char *) "self",(char *) "data", NULL
27826 };
27827
27828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
27829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27830 if (SWIG_arg_fail(1)) SWIG_fail;
27831 arg2 = obj1;
27832 {
27833 PyThreadState* __tstate = wxPyBeginAllowThreads();
27834 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
27835
27836 wxPyEndAllowThreads(__tstate);
27837 if (PyErr_Occurred()) SWIG_fail;
27838 }
27839 {
27840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27841 }
27842 return resultobj;
27843 fail:
27844 return NULL;
27845 }
27846
27847
27848 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27849 PyObject *resultobj;
27850 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27851 size_t result;
27852 PyObject * obj0 = 0 ;
27853 char *kwnames[] = {
27854 (char *) "self", NULL
27855 };
27856
27857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
27858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27859 if (SWIG_arg_fail(1)) SWIG_fail;
27860 {
27861 PyThreadState* __tstate = wxPyBeginAllowThreads();
27862 result = (size_t)(arg1)->GetSize();
27863
27864 wxPyEndAllowThreads(__tstate);
27865 if (PyErr_Occurred()) SWIG_fail;
27866 }
27867 {
27868 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27869 }
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27877 PyObject *resultobj;
27878 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27879 PyObject *result;
27880 PyObject * obj0 = 0 ;
27881 char *kwnames[] = {
27882 (char *) "self", NULL
27883 };
27884
27885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
27886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27887 if (SWIG_arg_fail(1)) SWIG_fail;
27888 {
27889 PyThreadState* __tstate = wxPyBeginAllowThreads();
27890 result = (PyObject *)wxCustomDataObject_GetData(arg1);
27891
27892 wxPyEndAllowThreads(__tstate);
27893 if (PyErr_Occurred()) SWIG_fail;
27894 }
27895 resultobj = result;
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
27903 PyObject *obj;
27904 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27905 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
27906 Py_INCREF(obj);
27907 return Py_BuildValue((char *)"");
27908 }
27909 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27910 PyObject *resultobj;
27911 wxURLDataObject *result;
27912 char *kwnames[] = {
27913 NULL
27914 };
27915
27916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
27917 {
27918 PyThreadState* __tstate = wxPyBeginAllowThreads();
27919 result = (wxURLDataObject *)new wxURLDataObject();
27920
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27932 PyObject *resultobj;
27933 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27934 wxString result;
27935 PyObject * obj0 = 0 ;
27936 char *kwnames[] = {
27937 (char *) "self", NULL
27938 };
27939
27940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
27941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27942 if (SWIG_arg_fail(1)) SWIG_fail;
27943 {
27944 PyThreadState* __tstate = wxPyBeginAllowThreads();
27945 result = (arg1)->GetURL();
27946
27947 wxPyEndAllowThreads(__tstate);
27948 if (PyErr_Occurred()) SWIG_fail;
27949 }
27950 {
27951 #if wxUSE_UNICODE
27952 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27953 #else
27954 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27955 #endif
27956 }
27957 return resultobj;
27958 fail:
27959 return NULL;
27960 }
27961
27962
27963 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27964 PyObject *resultobj;
27965 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27966 wxString *arg2 = 0 ;
27967 bool temp2 = false ;
27968 PyObject * obj0 = 0 ;
27969 PyObject * obj1 = 0 ;
27970 char *kwnames[] = {
27971 (char *) "self",(char *) "url", NULL
27972 };
27973
27974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
27975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27976 if (SWIG_arg_fail(1)) SWIG_fail;
27977 {
27978 arg2 = wxString_in_helper(obj1);
27979 if (arg2 == NULL) SWIG_fail;
27980 temp2 = true;
27981 }
27982 {
27983 PyThreadState* __tstate = wxPyBeginAllowThreads();
27984 (arg1)->SetURL((wxString const &)*arg2);
27985
27986 wxPyEndAllowThreads(__tstate);
27987 if (PyErr_Occurred()) SWIG_fail;
27988 }
27989 Py_INCREF(Py_None); resultobj = Py_None;
27990 {
27991 if (temp2)
27992 delete arg2;
27993 }
27994 return resultobj;
27995 fail:
27996 {
27997 if (temp2)
27998 delete arg2;
27999 }
28000 return NULL;
28001 }
28002
28003
28004 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28005 PyObject *obj;
28006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28007 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28008 Py_INCREF(obj);
28009 return Py_BuildValue((char *)"");
28010 }
28011 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28012 PyObject *resultobj;
28013 wxMetafileDataObject *result;
28014 char *kwnames[] = {
28015 NULL
28016 };
28017
28018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28019 {
28020 PyThreadState* __tstate = wxPyBeginAllowThreads();
28021 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28022
28023 wxPyEndAllowThreads(__tstate);
28024 if (PyErr_Occurred()) SWIG_fail;
28025 }
28026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28027 return resultobj;
28028 fail:
28029 return NULL;
28030 }
28031
28032
28033 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28034 PyObject *resultobj;
28035 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28036 wxMetafile *arg2 = 0 ;
28037 PyObject * obj0 = 0 ;
28038 PyObject * obj1 = 0 ;
28039 char *kwnames[] = {
28040 (char *) "self",(char *) "metafile", NULL
28041 };
28042
28043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28045 if (SWIG_arg_fail(1)) SWIG_fail;
28046 {
28047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28048 if (SWIG_arg_fail(2)) SWIG_fail;
28049 if (arg2 == NULL) {
28050 SWIG_null_ref("wxMetafile");
28051 }
28052 if (SWIG_arg_fail(2)) SWIG_fail;
28053 }
28054 {
28055 PyThreadState* __tstate = wxPyBeginAllowThreads();
28056 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28057
28058 wxPyEndAllowThreads(__tstate);
28059 if (PyErr_Occurred()) SWIG_fail;
28060 }
28061 Py_INCREF(Py_None); resultobj = Py_None;
28062 return resultobj;
28063 fail:
28064 return NULL;
28065 }
28066
28067
28068 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28069 PyObject *resultobj;
28070 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28071 wxMetafile result;
28072 PyObject * obj0 = 0 ;
28073 char *kwnames[] = {
28074 (char *) "self", NULL
28075 };
28076
28077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28079 if (SWIG_arg_fail(1)) SWIG_fail;
28080 {
28081 PyThreadState* __tstate = wxPyBeginAllowThreads();
28082 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28083
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 {
28088 wxMetafile * resultptr;
28089 resultptr = new wxMetafile((wxMetafile &)(result));
28090 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28091 }
28092 return resultobj;
28093 fail:
28094 return NULL;
28095 }
28096
28097
28098 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28099 PyObject *obj;
28100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28101 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28102 Py_INCREF(obj);
28103 return Py_BuildValue((char *)"");
28104 }
28105 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28106 PyObject *resultobj;
28107 wxDragResult arg1 ;
28108 bool result;
28109 PyObject * obj0 = 0 ;
28110 char *kwnames[] = {
28111 (char *) "res", NULL
28112 };
28113
28114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28115 {
28116 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28117 if (SWIG_arg_fail(1)) SWIG_fail;
28118 }
28119 {
28120 PyThreadState* __tstate = wxPyBeginAllowThreads();
28121 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28122
28123 wxPyEndAllowThreads(__tstate);
28124 if (PyErr_Occurred()) SWIG_fail;
28125 }
28126 {
28127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28128 }
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28136 PyObject *resultobj;
28137 wxWindow *arg1 = (wxWindow *) 0 ;
28138 wxCursor const &arg2_defvalue = wxNullCursor ;
28139 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28140 wxCursor const &arg3_defvalue = wxNullCursor ;
28141 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28142 wxCursor const &arg4_defvalue = wxNullCursor ;
28143 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28144 wxPyDropSource *result;
28145 PyObject * obj0 = 0 ;
28146 PyObject * obj1 = 0 ;
28147 PyObject * obj2 = 0 ;
28148 PyObject * obj3 = 0 ;
28149 char *kwnames[] = {
28150 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28151 };
28152
28153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28155 if (SWIG_arg_fail(1)) SWIG_fail;
28156 if (obj1) {
28157 {
28158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28159 if (SWIG_arg_fail(2)) SWIG_fail;
28160 if (arg2 == NULL) {
28161 SWIG_null_ref("wxCursor");
28162 }
28163 if (SWIG_arg_fail(2)) SWIG_fail;
28164 }
28165 }
28166 if (obj2) {
28167 {
28168 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28169 if (SWIG_arg_fail(3)) SWIG_fail;
28170 if (arg3 == NULL) {
28171 SWIG_null_ref("wxCursor");
28172 }
28173 if (SWIG_arg_fail(3)) SWIG_fail;
28174 }
28175 }
28176 if (obj3) {
28177 {
28178 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28179 if (SWIG_arg_fail(4)) SWIG_fail;
28180 if (arg4 == NULL) {
28181 SWIG_null_ref("wxCursor");
28182 }
28183 if (SWIG_arg_fail(4)) SWIG_fail;
28184 }
28185 }
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28189
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28194 return resultobj;
28195 fail:
28196 return NULL;
28197 }
28198
28199
28200 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28201 PyObject *resultobj;
28202 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28203 PyObject *arg2 = (PyObject *) 0 ;
28204 PyObject *arg3 = (PyObject *) 0 ;
28205 int arg4 ;
28206 PyObject * obj0 = 0 ;
28207 PyObject * obj1 = 0 ;
28208 PyObject * obj2 = 0 ;
28209 PyObject * obj3 = 0 ;
28210 char *kwnames[] = {
28211 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28212 };
28213
28214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28216 if (SWIG_arg_fail(1)) SWIG_fail;
28217 arg2 = obj1;
28218 arg3 = obj2;
28219 {
28220 arg4 = (int)(SWIG_As_int(obj3));
28221 if (SWIG_arg_fail(4)) SWIG_fail;
28222 }
28223 {
28224 PyThreadState* __tstate = wxPyBeginAllowThreads();
28225 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28226
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 Py_INCREF(Py_None); resultobj = Py_None;
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28238 PyObject *resultobj;
28239 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28240 PyObject * obj0 = 0 ;
28241 char *kwnames[] = {
28242 (char *) "self", NULL
28243 };
28244
28245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28247 if (SWIG_arg_fail(1)) SWIG_fail;
28248 {
28249 PyThreadState* __tstate = wxPyBeginAllowThreads();
28250 delete arg1;
28251
28252 wxPyEndAllowThreads(__tstate);
28253 if (PyErr_Occurred()) SWIG_fail;
28254 }
28255 Py_INCREF(Py_None); resultobj = Py_None;
28256 return resultobj;
28257 fail:
28258 return NULL;
28259 }
28260
28261
28262 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28263 PyObject *resultobj;
28264 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28265 wxDataObject *arg2 = 0 ;
28266 PyObject * obj0 = 0 ;
28267 PyObject * obj1 = 0 ;
28268 char *kwnames[] = {
28269 (char *) "self",(char *) "data", NULL
28270 };
28271
28272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28274 if (SWIG_arg_fail(1)) SWIG_fail;
28275 {
28276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28277 if (SWIG_arg_fail(2)) SWIG_fail;
28278 if (arg2 == NULL) {
28279 SWIG_null_ref("wxDataObject");
28280 }
28281 if (SWIG_arg_fail(2)) SWIG_fail;
28282 }
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 (arg1)->SetData(*arg2);
28286
28287 wxPyEndAllowThreads(__tstate);
28288 if (PyErr_Occurred()) SWIG_fail;
28289 }
28290 Py_INCREF(Py_None); resultobj = Py_None;
28291 return resultobj;
28292 fail:
28293 return NULL;
28294 }
28295
28296
28297 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28298 PyObject *resultobj;
28299 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28300 wxDataObject *result;
28301 PyObject * obj0 = 0 ;
28302 char *kwnames[] = {
28303 (char *) "self", NULL
28304 };
28305
28306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28308 if (SWIG_arg_fail(1)) SWIG_fail;
28309 {
28310 PyThreadState* __tstate = wxPyBeginAllowThreads();
28311 result = (wxDataObject *)(arg1)->GetDataObject();
28312
28313 wxPyEndAllowThreads(__tstate);
28314 if (PyErr_Occurred()) SWIG_fail;
28315 }
28316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28317 return resultobj;
28318 fail:
28319 return NULL;
28320 }
28321
28322
28323 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28324 PyObject *resultobj;
28325 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28326 wxDragResult arg2 ;
28327 wxCursor *arg3 = 0 ;
28328 PyObject * obj0 = 0 ;
28329 PyObject * obj1 = 0 ;
28330 PyObject * obj2 = 0 ;
28331 char *kwnames[] = {
28332 (char *) "self",(char *) "res",(char *) "cursor", NULL
28333 };
28334
28335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28337 if (SWIG_arg_fail(1)) SWIG_fail;
28338 {
28339 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28340 if (SWIG_arg_fail(2)) SWIG_fail;
28341 }
28342 {
28343 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28344 if (SWIG_arg_fail(3)) SWIG_fail;
28345 if (arg3 == NULL) {
28346 SWIG_null_ref("wxCursor");
28347 }
28348 if (SWIG_arg_fail(3)) SWIG_fail;
28349 }
28350 {
28351 PyThreadState* __tstate = wxPyBeginAllowThreads();
28352 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28353
28354 wxPyEndAllowThreads(__tstate);
28355 if (PyErr_Occurred()) SWIG_fail;
28356 }
28357 Py_INCREF(Py_None); resultobj = Py_None;
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28365 PyObject *resultobj;
28366 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28367 int arg2 = (int) wxDrag_CopyOnly ;
28368 wxDragResult result;
28369 PyObject * obj0 = 0 ;
28370 PyObject * obj1 = 0 ;
28371 char *kwnames[] = {
28372 (char *) "self",(char *) "flags", NULL
28373 };
28374
28375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28377 if (SWIG_arg_fail(1)) SWIG_fail;
28378 if (obj1) {
28379 {
28380 arg2 = (int)(SWIG_As_int(obj1));
28381 if (SWIG_arg_fail(2)) SWIG_fail;
28382 }
28383 }
28384 {
28385 PyThreadState* __tstate = wxPyBeginAllowThreads();
28386 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28387
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 resultobj = SWIG_From_int((result));
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj;
28400 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28401 wxDragResult arg2 ;
28402 bool result;
28403 PyObject * obj0 = 0 ;
28404 PyObject * obj1 = 0 ;
28405 char *kwnames[] = {
28406 (char *) "self",(char *) "effect", NULL
28407 };
28408
28409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28411 if (SWIG_arg_fail(1)) SWIG_fail;
28412 {
28413 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28414 if (SWIG_arg_fail(2)) SWIG_fail;
28415 }
28416 {
28417 PyThreadState* __tstate = wxPyBeginAllowThreads();
28418 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28419
28420 wxPyEndAllowThreads(__tstate);
28421 if (PyErr_Occurred()) SWIG_fail;
28422 }
28423 {
28424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28425 }
28426 return resultobj;
28427 fail:
28428 return NULL;
28429 }
28430
28431
28432 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28433 PyObject *obj;
28434 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28435 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28436 Py_INCREF(obj);
28437 return Py_BuildValue((char *)"");
28438 }
28439 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28440 PyObject *resultobj;
28441 wxDataObject *arg1 = (wxDataObject *) NULL ;
28442 wxPyDropTarget *result;
28443 PyObject * obj0 = 0 ;
28444 char *kwnames[] = {
28445 (char *) "dataObject", NULL
28446 };
28447
28448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28449 if (obj0) {
28450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28451 if (SWIG_arg_fail(1)) SWIG_fail;
28452 }
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28456
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28461 return resultobj;
28462 fail:
28463 return NULL;
28464 }
28465
28466
28467 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28468 PyObject *resultobj;
28469 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28470 PyObject *arg2 = (PyObject *) 0 ;
28471 PyObject *arg3 = (PyObject *) 0 ;
28472 PyObject * obj0 = 0 ;
28473 PyObject * obj1 = 0 ;
28474 PyObject * obj2 = 0 ;
28475 char *kwnames[] = {
28476 (char *) "self",(char *) "self",(char *) "_class", NULL
28477 };
28478
28479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28481 if (SWIG_arg_fail(1)) SWIG_fail;
28482 arg2 = obj1;
28483 arg3 = obj2;
28484 {
28485 PyThreadState* __tstate = wxPyBeginAllowThreads();
28486 (arg1)->_setCallbackInfo(arg2,arg3);
28487
28488 wxPyEndAllowThreads(__tstate);
28489 if (PyErr_Occurred()) SWIG_fail;
28490 }
28491 Py_INCREF(Py_None); resultobj = Py_None;
28492 return resultobj;
28493 fail:
28494 return NULL;
28495 }
28496
28497
28498 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28499 PyObject *resultobj;
28500 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28501 PyObject * obj0 = 0 ;
28502 char *kwnames[] = {
28503 (char *) "self", NULL
28504 };
28505
28506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28508 if (SWIG_arg_fail(1)) SWIG_fail;
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 delete arg1;
28512
28513 wxPyEndAllowThreads(__tstate);
28514 if (PyErr_Occurred()) SWIG_fail;
28515 }
28516 Py_INCREF(Py_None); resultobj = Py_None;
28517 return resultobj;
28518 fail:
28519 return NULL;
28520 }
28521
28522
28523 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28524 PyObject *resultobj;
28525 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28526 wxDataObject *result;
28527 PyObject * obj0 = 0 ;
28528 char *kwnames[] = {
28529 (char *) "self", NULL
28530 };
28531
28532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28534 if (SWIG_arg_fail(1)) SWIG_fail;
28535 {
28536 PyThreadState* __tstate = wxPyBeginAllowThreads();
28537 result = (wxDataObject *)(arg1)->GetDataObject();
28538
28539 wxPyEndAllowThreads(__tstate);
28540 if (PyErr_Occurred()) SWIG_fail;
28541 }
28542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28543 return resultobj;
28544 fail:
28545 return NULL;
28546 }
28547
28548
28549 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28550 PyObject *resultobj;
28551 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28552 wxDataObject *arg2 = (wxDataObject *) 0 ;
28553 PyObject * obj0 = 0 ;
28554 PyObject * obj1 = 0 ;
28555 char *kwnames[] = {
28556 (char *) "self",(char *) "dataObject", NULL
28557 };
28558
28559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28561 if (SWIG_arg_fail(1)) SWIG_fail;
28562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28563 if (SWIG_arg_fail(2)) SWIG_fail;
28564 {
28565 PyThreadState* __tstate = wxPyBeginAllowThreads();
28566 (arg1)->SetDataObject(arg2);
28567
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 Py_INCREF(Py_None); resultobj = Py_None;
28572 return resultobj;
28573 fail:
28574 return NULL;
28575 }
28576
28577
28578 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28579 PyObject *resultobj;
28580 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28581 int arg2 ;
28582 int arg3 ;
28583 wxDragResult arg4 ;
28584 wxDragResult result;
28585 PyObject * obj0 = 0 ;
28586 PyObject * obj1 = 0 ;
28587 PyObject * obj2 = 0 ;
28588 PyObject * obj3 = 0 ;
28589 char *kwnames[] = {
28590 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28591 };
28592
28593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28595 if (SWIG_arg_fail(1)) SWIG_fail;
28596 {
28597 arg2 = (int)(SWIG_As_int(obj1));
28598 if (SWIG_arg_fail(2)) SWIG_fail;
28599 }
28600 {
28601 arg3 = (int)(SWIG_As_int(obj2));
28602 if (SWIG_arg_fail(3)) SWIG_fail;
28603 }
28604 {
28605 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28606 if (SWIG_arg_fail(4)) SWIG_fail;
28607 }
28608 {
28609 PyThreadState* __tstate = wxPyBeginAllowThreads();
28610 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28611
28612 wxPyEndAllowThreads(__tstate);
28613 if (PyErr_Occurred()) SWIG_fail;
28614 }
28615 resultobj = SWIG_From_int((result));
28616 return resultobj;
28617 fail:
28618 return NULL;
28619 }
28620
28621
28622 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28623 PyObject *resultobj;
28624 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28625 int arg2 ;
28626 int arg3 ;
28627 wxDragResult arg4 ;
28628 wxDragResult result;
28629 PyObject * obj0 = 0 ;
28630 PyObject * obj1 = 0 ;
28631 PyObject * obj2 = 0 ;
28632 PyObject * obj3 = 0 ;
28633 char *kwnames[] = {
28634 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28635 };
28636
28637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28639 if (SWIG_arg_fail(1)) SWIG_fail;
28640 {
28641 arg2 = (int)(SWIG_As_int(obj1));
28642 if (SWIG_arg_fail(2)) SWIG_fail;
28643 }
28644 {
28645 arg3 = (int)(SWIG_As_int(obj2));
28646 if (SWIG_arg_fail(3)) SWIG_fail;
28647 }
28648 {
28649 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28650 if (SWIG_arg_fail(4)) SWIG_fail;
28651 }
28652 {
28653 PyThreadState* __tstate = wxPyBeginAllowThreads();
28654 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28655
28656 wxPyEndAllowThreads(__tstate);
28657 if (PyErr_Occurred()) SWIG_fail;
28658 }
28659 resultobj = SWIG_From_int((result));
28660 return resultobj;
28661 fail:
28662 return NULL;
28663 }
28664
28665
28666 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28667 PyObject *resultobj;
28668 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28669 PyObject * obj0 = 0 ;
28670 char *kwnames[] = {
28671 (char *) "self", NULL
28672 };
28673
28674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28676 if (SWIG_arg_fail(1)) SWIG_fail;
28677 {
28678 PyThreadState* __tstate = wxPyBeginAllowThreads();
28679 (arg1)->base_OnLeave();
28680
28681 wxPyEndAllowThreads(__tstate);
28682 if (PyErr_Occurred()) SWIG_fail;
28683 }
28684 Py_INCREF(Py_None); resultobj = Py_None;
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28692 PyObject *resultobj;
28693 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28694 int arg2 ;
28695 int arg3 ;
28696 bool result;
28697 PyObject * obj0 = 0 ;
28698 PyObject * obj1 = 0 ;
28699 PyObject * obj2 = 0 ;
28700 char *kwnames[] = {
28701 (char *) "self",(char *) "x",(char *) "y", NULL
28702 };
28703
28704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28706 if (SWIG_arg_fail(1)) SWIG_fail;
28707 {
28708 arg2 = (int)(SWIG_As_int(obj1));
28709 if (SWIG_arg_fail(2)) SWIG_fail;
28710 }
28711 {
28712 arg3 = (int)(SWIG_As_int(obj2));
28713 if (SWIG_arg_fail(3)) SWIG_fail;
28714 }
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28718
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 {
28723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28724 }
28725 return resultobj;
28726 fail:
28727 return NULL;
28728 }
28729
28730
28731 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28732 PyObject *resultobj;
28733 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28734 bool result;
28735 PyObject * obj0 = 0 ;
28736 char *kwnames[] = {
28737 (char *) "self", NULL
28738 };
28739
28740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28742 if (SWIG_arg_fail(1)) SWIG_fail;
28743 {
28744 PyThreadState* __tstate = wxPyBeginAllowThreads();
28745 result = (bool)(arg1)->GetData();
28746
28747 wxPyEndAllowThreads(__tstate);
28748 if (PyErr_Occurred()) SWIG_fail;
28749 }
28750 {
28751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28752 }
28753 return resultobj;
28754 fail:
28755 return NULL;
28756 }
28757
28758
28759 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28760 PyObject *obj;
28761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28762 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28763 Py_INCREF(obj);
28764 return Py_BuildValue((char *)"");
28765 }
28766 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj;
28768 wxPyTextDropTarget *result;
28769 char *kwnames[] = {
28770 NULL
28771 };
28772
28773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28774 {
28775 PyThreadState* __tstate = wxPyBeginAllowThreads();
28776 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28777
28778 wxPyEndAllowThreads(__tstate);
28779 if (PyErr_Occurred()) SWIG_fail;
28780 }
28781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28782 return resultobj;
28783 fail:
28784 return NULL;
28785 }
28786
28787
28788 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28789 PyObject *resultobj;
28790 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28791 PyObject *arg2 = (PyObject *) 0 ;
28792 PyObject *arg3 = (PyObject *) 0 ;
28793 PyObject * obj0 = 0 ;
28794 PyObject * obj1 = 0 ;
28795 PyObject * obj2 = 0 ;
28796 char *kwnames[] = {
28797 (char *) "self",(char *) "self",(char *) "_class", NULL
28798 };
28799
28800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28802 if (SWIG_arg_fail(1)) SWIG_fail;
28803 arg2 = obj1;
28804 arg3 = obj2;
28805 {
28806 PyThreadState* __tstate = wxPyBeginAllowThreads();
28807 (arg1)->_setCallbackInfo(arg2,arg3);
28808
28809 wxPyEndAllowThreads(__tstate);
28810 if (PyErr_Occurred()) SWIG_fail;
28811 }
28812 Py_INCREF(Py_None); resultobj = Py_None;
28813 return resultobj;
28814 fail:
28815 return NULL;
28816 }
28817
28818
28819 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28820 PyObject *resultobj;
28821 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28822 int arg2 ;
28823 int arg3 ;
28824 wxDragResult arg4 ;
28825 wxDragResult result;
28826 PyObject * obj0 = 0 ;
28827 PyObject * obj1 = 0 ;
28828 PyObject * obj2 = 0 ;
28829 PyObject * obj3 = 0 ;
28830 char *kwnames[] = {
28831 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28832 };
28833
28834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28836 if (SWIG_arg_fail(1)) SWIG_fail;
28837 {
28838 arg2 = (int)(SWIG_As_int(obj1));
28839 if (SWIG_arg_fail(2)) SWIG_fail;
28840 }
28841 {
28842 arg3 = (int)(SWIG_As_int(obj2));
28843 if (SWIG_arg_fail(3)) SWIG_fail;
28844 }
28845 {
28846 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28847 if (SWIG_arg_fail(4)) SWIG_fail;
28848 }
28849 {
28850 PyThreadState* __tstate = wxPyBeginAllowThreads();
28851 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28852
28853 wxPyEndAllowThreads(__tstate);
28854 if (PyErr_Occurred()) SWIG_fail;
28855 }
28856 resultobj = SWIG_From_int((result));
28857 return resultobj;
28858 fail:
28859 return NULL;
28860 }
28861
28862
28863 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28864 PyObject *resultobj;
28865 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28866 int arg2 ;
28867 int arg3 ;
28868 wxDragResult arg4 ;
28869 wxDragResult result;
28870 PyObject * obj0 = 0 ;
28871 PyObject * obj1 = 0 ;
28872 PyObject * obj2 = 0 ;
28873 PyObject * obj3 = 0 ;
28874 char *kwnames[] = {
28875 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28876 };
28877
28878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28880 if (SWIG_arg_fail(1)) SWIG_fail;
28881 {
28882 arg2 = (int)(SWIG_As_int(obj1));
28883 if (SWIG_arg_fail(2)) SWIG_fail;
28884 }
28885 {
28886 arg3 = (int)(SWIG_As_int(obj2));
28887 if (SWIG_arg_fail(3)) SWIG_fail;
28888 }
28889 {
28890 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28891 if (SWIG_arg_fail(4)) SWIG_fail;
28892 }
28893 {
28894 PyThreadState* __tstate = wxPyBeginAllowThreads();
28895 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28896
28897 wxPyEndAllowThreads(__tstate);
28898 if (PyErr_Occurred()) SWIG_fail;
28899 }
28900 resultobj = SWIG_From_int((result));
28901 return resultobj;
28902 fail:
28903 return NULL;
28904 }
28905
28906
28907 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28908 PyObject *resultobj;
28909 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28910 PyObject * obj0 = 0 ;
28911 char *kwnames[] = {
28912 (char *) "self", NULL
28913 };
28914
28915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28917 if (SWIG_arg_fail(1)) SWIG_fail;
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 (arg1)->base_OnLeave();
28921
28922 wxPyEndAllowThreads(__tstate);
28923 if (PyErr_Occurred()) SWIG_fail;
28924 }
28925 Py_INCREF(Py_None); resultobj = Py_None;
28926 return resultobj;
28927 fail:
28928 return NULL;
28929 }
28930
28931
28932 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28933 PyObject *resultobj;
28934 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28935 int arg2 ;
28936 int arg3 ;
28937 bool result;
28938 PyObject * obj0 = 0 ;
28939 PyObject * obj1 = 0 ;
28940 PyObject * obj2 = 0 ;
28941 char *kwnames[] = {
28942 (char *) "self",(char *) "x",(char *) "y", NULL
28943 };
28944
28945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28947 if (SWIG_arg_fail(1)) SWIG_fail;
28948 {
28949 arg2 = (int)(SWIG_As_int(obj1));
28950 if (SWIG_arg_fail(2)) SWIG_fail;
28951 }
28952 {
28953 arg3 = (int)(SWIG_As_int(obj2));
28954 if (SWIG_arg_fail(3)) SWIG_fail;
28955 }
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28959
28960 wxPyEndAllowThreads(__tstate);
28961 if (PyErr_Occurred()) SWIG_fail;
28962 }
28963 {
28964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28965 }
28966 return resultobj;
28967 fail:
28968 return NULL;
28969 }
28970
28971
28972 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
28973 PyObject *resultobj;
28974 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28975 int arg2 ;
28976 int arg3 ;
28977 wxDragResult arg4 ;
28978 wxDragResult result;
28979 PyObject * obj0 = 0 ;
28980 PyObject * obj1 = 0 ;
28981 PyObject * obj2 = 0 ;
28982 PyObject * obj3 = 0 ;
28983 char *kwnames[] = {
28984 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28985 };
28986
28987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28989 if (SWIG_arg_fail(1)) SWIG_fail;
28990 {
28991 arg2 = (int)(SWIG_As_int(obj1));
28992 if (SWIG_arg_fail(2)) SWIG_fail;
28993 }
28994 {
28995 arg3 = (int)(SWIG_As_int(obj2));
28996 if (SWIG_arg_fail(3)) SWIG_fail;
28997 }
28998 {
28999 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29000 if (SWIG_arg_fail(4)) SWIG_fail;
29001 }
29002 {
29003 PyThreadState* __tstate = wxPyBeginAllowThreads();
29004 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29005
29006 wxPyEndAllowThreads(__tstate);
29007 if (PyErr_Occurred()) SWIG_fail;
29008 }
29009 resultobj = SWIG_From_int((result));
29010 return resultobj;
29011 fail:
29012 return NULL;
29013 }
29014
29015
29016 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29017 PyObject *obj;
29018 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29019 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29020 Py_INCREF(obj);
29021 return Py_BuildValue((char *)"");
29022 }
29023 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29024 PyObject *resultobj;
29025 wxPyFileDropTarget *result;
29026 char *kwnames[] = {
29027 NULL
29028 };
29029
29030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29031 {
29032 PyThreadState* __tstate = wxPyBeginAllowThreads();
29033 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29034
29035 wxPyEndAllowThreads(__tstate);
29036 if (PyErr_Occurred()) SWIG_fail;
29037 }
29038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29039 return resultobj;
29040 fail:
29041 return NULL;
29042 }
29043
29044
29045 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29046 PyObject *resultobj;
29047 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29048 PyObject *arg2 = (PyObject *) 0 ;
29049 PyObject *arg3 = (PyObject *) 0 ;
29050 PyObject * obj0 = 0 ;
29051 PyObject * obj1 = 0 ;
29052 PyObject * obj2 = 0 ;
29053 char *kwnames[] = {
29054 (char *) "self",(char *) "self",(char *) "_class", NULL
29055 };
29056
29057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29059 if (SWIG_arg_fail(1)) SWIG_fail;
29060 arg2 = obj1;
29061 arg3 = obj2;
29062 {
29063 PyThreadState* __tstate = wxPyBeginAllowThreads();
29064 (arg1)->_setCallbackInfo(arg2,arg3);
29065
29066 wxPyEndAllowThreads(__tstate);
29067 if (PyErr_Occurred()) SWIG_fail;
29068 }
29069 Py_INCREF(Py_None); resultobj = Py_None;
29070 return resultobj;
29071 fail:
29072 return NULL;
29073 }
29074
29075
29076 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29077 PyObject *resultobj;
29078 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29079 int arg2 ;
29080 int arg3 ;
29081 wxDragResult arg4 ;
29082 wxDragResult result;
29083 PyObject * obj0 = 0 ;
29084 PyObject * obj1 = 0 ;
29085 PyObject * obj2 = 0 ;
29086 PyObject * obj3 = 0 ;
29087 char *kwnames[] = {
29088 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29089 };
29090
29091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29093 if (SWIG_arg_fail(1)) SWIG_fail;
29094 {
29095 arg2 = (int)(SWIG_As_int(obj1));
29096 if (SWIG_arg_fail(2)) SWIG_fail;
29097 }
29098 {
29099 arg3 = (int)(SWIG_As_int(obj2));
29100 if (SWIG_arg_fail(3)) SWIG_fail;
29101 }
29102 {
29103 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29104 if (SWIG_arg_fail(4)) SWIG_fail;
29105 }
29106 {
29107 PyThreadState* __tstate = wxPyBeginAllowThreads();
29108 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29109
29110 wxPyEndAllowThreads(__tstate);
29111 if (PyErr_Occurred()) SWIG_fail;
29112 }
29113 resultobj = SWIG_From_int((result));
29114 return resultobj;
29115 fail:
29116 return NULL;
29117 }
29118
29119
29120 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29121 PyObject *resultobj;
29122 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29123 int arg2 ;
29124 int arg3 ;
29125 wxDragResult arg4 ;
29126 wxDragResult result;
29127 PyObject * obj0 = 0 ;
29128 PyObject * obj1 = 0 ;
29129 PyObject * obj2 = 0 ;
29130 PyObject * obj3 = 0 ;
29131 char *kwnames[] = {
29132 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29133 };
29134
29135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29137 if (SWIG_arg_fail(1)) SWIG_fail;
29138 {
29139 arg2 = (int)(SWIG_As_int(obj1));
29140 if (SWIG_arg_fail(2)) SWIG_fail;
29141 }
29142 {
29143 arg3 = (int)(SWIG_As_int(obj2));
29144 if (SWIG_arg_fail(3)) SWIG_fail;
29145 }
29146 {
29147 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29148 if (SWIG_arg_fail(4)) SWIG_fail;
29149 }
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29153
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 resultobj = SWIG_From_int((result));
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29165 PyObject *resultobj;
29166 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29167 PyObject * obj0 = 0 ;
29168 char *kwnames[] = {
29169 (char *) "self", NULL
29170 };
29171
29172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29174 if (SWIG_arg_fail(1)) SWIG_fail;
29175 {
29176 PyThreadState* __tstate = wxPyBeginAllowThreads();
29177 (arg1)->base_OnLeave();
29178
29179 wxPyEndAllowThreads(__tstate);
29180 if (PyErr_Occurred()) SWIG_fail;
29181 }
29182 Py_INCREF(Py_None); resultobj = Py_None;
29183 return resultobj;
29184 fail:
29185 return NULL;
29186 }
29187
29188
29189 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29190 PyObject *resultobj;
29191 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29192 int arg2 ;
29193 int arg3 ;
29194 bool result;
29195 PyObject * obj0 = 0 ;
29196 PyObject * obj1 = 0 ;
29197 PyObject * obj2 = 0 ;
29198 char *kwnames[] = {
29199 (char *) "self",(char *) "x",(char *) "y", NULL
29200 };
29201
29202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29204 if (SWIG_arg_fail(1)) SWIG_fail;
29205 {
29206 arg2 = (int)(SWIG_As_int(obj1));
29207 if (SWIG_arg_fail(2)) SWIG_fail;
29208 }
29209 {
29210 arg3 = (int)(SWIG_As_int(obj2));
29211 if (SWIG_arg_fail(3)) SWIG_fail;
29212 }
29213 {
29214 PyThreadState* __tstate = wxPyBeginAllowThreads();
29215 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29216
29217 wxPyEndAllowThreads(__tstate);
29218 if (PyErr_Occurred()) SWIG_fail;
29219 }
29220 {
29221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29222 }
29223 return resultobj;
29224 fail:
29225 return NULL;
29226 }
29227
29228
29229 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29230 PyObject *resultobj;
29231 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29232 int arg2 ;
29233 int arg3 ;
29234 wxDragResult arg4 ;
29235 wxDragResult result;
29236 PyObject * obj0 = 0 ;
29237 PyObject * obj1 = 0 ;
29238 PyObject * obj2 = 0 ;
29239 PyObject * obj3 = 0 ;
29240 char *kwnames[] = {
29241 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29242 };
29243
29244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29246 if (SWIG_arg_fail(1)) SWIG_fail;
29247 {
29248 arg2 = (int)(SWIG_As_int(obj1));
29249 if (SWIG_arg_fail(2)) SWIG_fail;
29250 }
29251 {
29252 arg3 = (int)(SWIG_As_int(obj2));
29253 if (SWIG_arg_fail(3)) SWIG_fail;
29254 }
29255 {
29256 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29257 if (SWIG_arg_fail(4)) SWIG_fail;
29258 }
29259 {
29260 PyThreadState* __tstate = wxPyBeginAllowThreads();
29261 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29262
29263 wxPyEndAllowThreads(__tstate);
29264 if (PyErr_Occurred()) SWIG_fail;
29265 }
29266 resultobj = SWIG_From_int((result));
29267 return resultobj;
29268 fail:
29269 return NULL;
29270 }
29271
29272
29273 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29274 PyObject *obj;
29275 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29276 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29277 Py_INCREF(obj);
29278 return Py_BuildValue((char *)"");
29279 }
29280 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29281 PyObject *resultobj;
29282 wxClipboard *result;
29283 char *kwnames[] = {
29284 NULL
29285 };
29286
29287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29288 {
29289 PyThreadState* __tstate = wxPyBeginAllowThreads();
29290 result = (wxClipboard *)new wxClipboard();
29291
29292 wxPyEndAllowThreads(__tstate);
29293 if (PyErr_Occurred()) SWIG_fail;
29294 }
29295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29303 PyObject *resultobj;
29304 wxClipboard *arg1 = (wxClipboard *) 0 ;
29305 PyObject * obj0 = 0 ;
29306 char *kwnames[] = {
29307 (char *) "self", NULL
29308 };
29309
29310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29312 if (SWIG_arg_fail(1)) SWIG_fail;
29313 {
29314 PyThreadState* __tstate = wxPyBeginAllowThreads();
29315 delete arg1;
29316
29317 wxPyEndAllowThreads(__tstate);
29318 if (PyErr_Occurred()) SWIG_fail;
29319 }
29320 Py_INCREF(Py_None); resultobj = Py_None;
29321 return resultobj;
29322 fail:
29323 return NULL;
29324 }
29325
29326
29327 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29328 PyObject *resultobj;
29329 wxClipboard *arg1 = (wxClipboard *) 0 ;
29330 bool result;
29331 PyObject * obj0 = 0 ;
29332 char *kwnames[] = {
29333 (char *) "self", NULL
29334 };
29335
29336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29338 if (SWIG_arg_fail(1)) SWIG_fail;
29339 {
29340 PyThreadState* __tstate = wxPyBeginAllowThreads();
29341 result = (bool)(arg1)->Open();
29342
29343 wxPyEndAllowThreads(__tstate);
29344 if (PyErr_Occurred()) SWIG_fail;
29345 }
29346 {
29347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29348 }
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29356 PyObject *resultobj;
29357 wxClipboard *arg1 = (wxClipboard *) 0 ;
29358 PyObject * obj0 = 0 ;
29359 char *kwnames[] = {
29360 (char *) "self", NULL
29361 };
29362
29363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29365 if (SWIG_arg_fail(1)) SWIG_fail;
29366 {
29367 PyThreadState* __tstate = wxPyBeginAllowThreads();
29368 (arg1)->Close();
29369
29370 wxPyEndAllowThreads(__tstate);
29371 if (PyErr_Occurred()) SWIG_fail;
29372 }
29373 Py_INCREF(Py_None); resultobj = Py_None;
29374 return resultobj;
29375 fail:
29376 return NULL;
29377 }
29378
29379
29380 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29381 PyObject *resultobj;
29382 wxClipboard *arg1 = (wxClipboard *) 0 ;
29383 bool result;
29384 PyObject * obj0 = 0 ;
29385 char *kwnames[] = {
29386 (char *) "self", NULL
29387 };
29388
29389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29391 if (SWIG_arg_fail(1)) SWIG_fail;
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29395
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 {
29400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29401 }
29402 return resultobj;
29403 fail:
29404 return NULL;
29405 }
29406
29407
29408 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29409 PyObject *resultobj;
29410 wxClipboard *arg1 = (wxClipboard *) 0 ;
29411 wxDataObject *arg2 = (wxDataObject *) 0 ;
29412 bool result;
29413 PyObject * obj0 = 0 ;
29414 PyObject * obj1 = 0 ;
29415 char *kwnames[] = {
29416 (char *) "self",(char *) "data", NULL
29417 };
29418
29419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29421 if (SWIG_arg_fail(1)) SWIG_fail;
29422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29423 if (SWIG_arg_fail(2)) SWIG_fail;
29424 {
29425 PyThreadState* __tstate = wxPyBeginAllowThreads();
29426 result = (bool)(arg1)->AddData(arg2);
29427
29428 wxPyEndAllowThreads(__tstate);
29429 if (PyErr_Occurred()) SWIG_fail;
29430 }
29431 {
29432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29433 }
29434 return resultobj;
29435 fail:
29436 return NULL;
29437 }
29438
29439
29440 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29441 PyObject *resultobj;
29442 wxClipboard *arg1 = (wxClipboard *) 0 ;
29443 wxDataObject *arg2 = (wxDataObject *) 0 ;
29444 bool result;
29445 PyObject * obj0 = 0 ;
29446 PyObject * obj1 = 0 ;
29447 char *kwnames[] = {
29448 (char *) "self",(char *) "data", NULL
29449 };
29450
29451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29453 if (SWIG_arg_fail(1)) SWIG_fail;
29454 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29455 if (SWIG_arg_fail(2)) SWIG_fail;
29456 {
29457 PyThreadState* __tstate = wxPyBeginAllowThreads();
29458 result = (bool)(arg1)->SetData(arg2);
29459
29460 wxPyEndAllowThreads(__tstate);
29461 if (PyErr_Occurred()) SWIG_fail;
29462 }
29463 {
29464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29465 }
29466 return resultobj;
29467 fail:
29468 return NULL;
29469 }
29470
29471
29472 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29473 PyObject *resultobj;
29474 wxClipboard *arg1 = (wxClipboard *) 0 ;
29475 wxDataFormat *arg2 = 0 ;
29476 bool result;
29477 PyObject * obj0 = 0 ;
29478 PyObject * obj1 = 0 ;
29479 char *kwnames[] = {
29480 (char *) "self",(char *) "format", NULL
29481 };
29482
29483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29485 if (SWIG_arg_fail(1)) SWIG_fail;
29486 {
29487 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29488 if (SWIG_arg_fail(2)) SWIG_fail;
29489 if (arg2 == NULL) {
29490 SWIG_null_ref("wxDataFormat");
29491 }
29492 if (SWIG_arg_fail(2)) SWIG_fail;
29493 }
29494 {
29495 PyThreadState* __tstate = wxPyBeginAllowThreads();
29496 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29497
29498 wxPyEndAllowThreads(__tstate);
29499 if (PyErr_Occurred()) SWIG_fail;
29500 }
29501 {
29502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29503 }
29504 return resultobj;
29505 fail:
29506 return NULL;
29507 }
29508
29509
29510 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29511 PyObject *resultobj;
29512 wxClipboard *arg1 = (wxClipboard *) 0 ;
29513 wxDataObject *arg2 = 0 ;
29514 bool result;
29515 PyObject * obj0 = 0 ;
29516 PyObject * obj1 = 0 ;
29517 char *kwnames[] = {
29518 (char *) "self",(char *) "data", NULL
29519 };
29520
29521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29523 if (SWIG_arg_fail(1)) SWIG_fail;
29524 {
29525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29526 if (SWIG_arg_fail(2)) SWIG_fail;
29527 if (arg2 == NULL) {
29528 SWIG_null_ref("wxDataObject");
29529 }
29530 if (SWIG_arg_fail(2)) SWIG_fail;
29531 }
29532 {
29533 PyThreadState* __tstate = wxPyBeginAllowThreads();
29534 result = (bool)(arg1)->GetData(*arg2);
29535
29536 wxPyEndAllowThreads(__tstate);
29537 if (PyErr_Occurred()) SWIG_fail;
29538 }
29539 {
29540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29541 }
29542 return resultobj;
29543 fail:
29544 return NULL;
29545 }
29546
29547
29548 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29549 PyObject *resultobj;
29550 wxClipboard *arg1 = (wxClipboard *) 0 ;
29551 PyObject * obj0 = 0 ;
29552 char *kwnames[] = {
29553 (char *) "self", NULL
29554 };
29555
29556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29558 if (SWIG_arg_fail(1)) SWIG_fail;
29559 {
29560 PyThreadState* __tstate = wxPyBeginAllowThreads();
29561 (arg1)->Clear();
29562
29563 wxPyEndAllowThreads(__tstate);
29564 if (PyErr_Occurred()) SWIG_fail;
29565 }
29566 Py_INCREF(Py_None); resultobj = Py_None;
29567 return resultobj;
29568 fail:
29569 return NULL;
29570 }
29571
29572
29573 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29574 PyObject *resultobj;
29575 wxClipboard *arg1 = (wxClipboard *) 0 ;
29576 bool result;
29577 PyObject * obj0 = 0 ;
29578 char *kwnames[] = {
29579 (char *) "self", NULL
29580 };
29581
29582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29584 if (SWIG_arg_fail(1)) SWIG_fail;
29585 {
29586 PyThreadState* __tstate = wxPyBeginAllowThreads();
29587 result = (bool)(arg1)->Flush();
29588
29589 wxPyEndAllowThreads(__tstate);
29590 if (PyErr_Occurred()) SWIG_fail;
29591 }
29592 {
29593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29594 }
29595 return resultobj;
29596 fail:
29597 return NULL;
29598 }
29599
29600
29601 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29602 PyObject *resultobj;
29603 wxClipboard *arg1 = (wxClipboard *) 0 ;
29604 bool arg2 = (bool) true ;
29605 PyObject * obj0 = 0 ;
29606 PyObject * obj1 = 0 ;
29607 char *kwnames[] = {
29608 (char *) "self",(char *) "primary", NULL
29609 };
29610
29611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29613 if (SWIG_arg_fail(1)) SWIG_fail;
29614 if (obj1) {
29615 {
29616 arg2 = (bool)(SWIG_As_bool(obj1));
29617 if (SWIG_arg_fail(2)) SWIG_fail;
29618 }
29619 }
29620 {
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 (arg1)->UsePrimarySelection(arg2);
29623
29624 wxPyEndAllowThreads(__tstate);
29625 if (PyErr_Occurred()) SWIG_fail;
29626 }
29627 Py_INCREF(Py_None); resultobj = Py_None;
29628 return resultobj;
29629 fail:
29630 return NULL;
29631 }
29632
29633
29634 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29635 PyObject *resultobj;
29636 wxClipboard *result;
29637 char *kwnames[] = {
29638 NULL
29639 };
29640
29641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 result = (wxClipboard *)wxClipboard::Get();
29645
29646 wxPyEndAllowThreads(__tstate);
29647 if (PyErr_Occurred()) SWIG_fail;
29648 }
29649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29650 return resultobj;
29651 fail:
29652 return NULL;
29653 }
29654
29655
29656 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29657 PyObject *obj;
29658 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29659 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29660 Py_INCREF(obj);
29661 return Py_BuildValue((char *)"");
29662 }
29663 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29664 PyObject *resultobj;
29665 wxClipboard *arg1 = (wxClipboard *) NULL ;
29666 wxClipboardLocker *result;
29667 PyObject * obj0 = 0 ;
29668 char *kwnames[] = {
29669 (char *) "clipboard", NULL
29670 };
29671
29672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29673 if (obj0) {
29674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29675 if (SWIG_arg_fail(1)) SWIG_fail;
29676 }
29677 {
29678 PyThreadState* __tstate = wxPyBeginAllowThreads();
29679 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29680
29681 wxPyEndAllowThreads(__tstate);
29682 if (PyErr_Occurred()) SWIG_fail;
29683 }
29684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29685 return resultobj;
29686 fail:
29687 return NULL;
29688 }
29689
29690
29691 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29692 PyObject *resultobj;
29693 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29694 PyObject * obj0 = 0 ;
29695 char *kwnames[] = {
29696 (char *) "self", NULL
29697 };
29698
29699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29701 if (SWIG_arg_fail(1)) SWIG_fail;
29702 {
29703 PyThreadState* __tstate = wxPyBeginAllowThreads();
29704 delete arg1;
29705
29706 wxPyEndAllowThreads(__tstate);
29707 if (PyErr_Occurred()) SWIG_fail;
29708 }
29709 Py_INCREF(Py_None); resultobj = Py_None;
29710 return resultobj;
29711 fail:
29712 return NULL;
29713 }
29714
29715
29716 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29717 PyObject *resultobj;
29718 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29719 bool result;
29720 PyObject * obj0 = 0 ;
29721 char *kwnames[] = {
29722 (char *) "self", NULL
29723 };
29724
29725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29727 if (SWIG_arg_fail(1)) SWIG_fail;
29728 {
29729 PyThreadState* __tstate = wxPyBeginAllowThreads();
29730 result = (bool)wxClipboardLocker___nonzero__(arg1);
29731
29732 wxPyEndAllowThreads(__tstate);
29733 if (PyErr_Occurred()) SWIG_fail;
29734 }
29735 {
29736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29737 }
29738 return resultobj;
29739 fail:
29740 return NULL;
29741 }
29742
29743
29744 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29745 PyObject *obj;
29746 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29747 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29748 Py_INCREF(obj);
29749 return Py_BuildValue((char *)"");
29750 }
29751 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29752 PyObject *resultobj;
29753 int arg1 = (int) 0 ;
29754 int arg2 = (int) 0 ;
29755 int arg3 = (int) 0 ;
29756 int arg4 = (int) 0 ;
29757 wxVideoMode *result;
29758 PyObject * obj0 = 0 ;
29759 PyObject * obj1 = 0 ;
29760 PyObject * obj2 = 0 ;
29761 PyObject * obj3 = 0 ;
29762 char *kwnames[] = {
29763 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29764 };
29765
29766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29767 if (obj0) {
29768 {
29769 arg1 = (int)(SWIG_As_int(obj0));
29770 if (SWIG_arg_fail(1)) SWIG_fail;
29771 }
29772 }
29773 if (obj1) {
29774 {
29775 arg2 = (int)(SWIG_As_int(obj1));
29776 if (SWIG_arg_fail(2)) SWIG_fail;
29777 }
29778 }
29779 if (obj2) {
29780 {
29781 arg3 = (int)(SWIG_As_int(obj2));
29782 if (SWIG_arg_fail(3)) SWIG_fail;
29783 }
29784 }
29785 if (obj3) {
29786 {
29787 arg4 = (int)(SWIG_As_int(obj3));
29788 if (SWIG_arg_fail(4)) SWIG_fail;
29789 }
29790 }
29791 {
29792 PyThreadState* __tstate = wxPyBeginAllowThreads();
29793 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29794
29795 wxPyEndAllowThreads(__tstate);
29796 if (PyErr_Occurred()) SWIG_fail;
29797 }
29798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29799 return resultobj;
29800 fail:
29801 return NULL;
29802 }
29803
29804
29805 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29806 PyObject *resultobj;
29807 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29808 PyObject * obj0 = 0 ;
29809 char *kwnames[] = {
29810 (char *) "self", NULL
29811 };
29812
29813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29815 if (SWIG_arg_fail(1)) SWIG_fail;
29816 {
29817 PyThreadState* __tstate = wxPyBeginAllowThreads();
29818 delete arg1;
29819
29820 wxPyEndAllowThreads(__tstate);
29821 if (PyErr_Occurred()) SWIG_fail;
29822 }
29823 Py_INCREF(Py_None); resultobj = Py_None;
29824 return resultobj;
29825 fail:
29826 return NULL;
29827 }
29828
29829
29830 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
29831 PyObject *resultobj;
29832 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29833 wxVideoMode *arg2 = 0 ;
29834 bool result;
29835 PyObject * obj0 = 0 ;
29836 PyObject * obj1 = 0 ;
29837 char *kwnames[] = {
29838 (char *) "self",(char *) "other", NULL
29839 };
29840
29841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
29842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29843 if (SWIG_arg_fail(1)) SWIG_fail;
29844 {
29845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29846 if (SWIG_arg_fail(2)) SWIG_fail;
29847 if (arg2 == NULL) {
29848 SWIG_null_ref("wxVideoMode");
29849 }
29850 if (SWIG_arg_fail(2)) SWIG_fail;
29851 }
29852 {
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
29855
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 {
29860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29861 }
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29869 PyObject *resultobj;
29870 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29871 int result;
29872 PyObject * obj0 = 0 ;
29873 char *kwnames[] = {
29874 (char *) "self", NULL
29875 };
29876
29877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
29878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29879 if (SWIG_arg_fail(1)) SWIG_fail;
29880 {
29881 PyThreadState* __tstate = wxPyBeginAllowThreads();
29882 result = (int)((wxVideoMode const *)arg1)->GetWidth();
29883
29884 wxPyEndAllowThreads(__tstate);
29885 if (PyErr_Occurred()) SWIG_fail;
29886 }
29887 {
29888 resultobj = SWIG_From_int((int)(result));
29889 }
29890 return resultobj;
29891 fail:
29892 return NULL;
29893 }
29894
29895
29896 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29897 PyObject *resultobj;
29898 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29899 int result;
29900 PyObject * obj0 = 0 ;
29901 char *kwnames[] = {
29902 (char *) "self", NULL
29903 };
29904
29905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
29906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29907 if (SWIG_arg_fail(1)) SWIG_fail;
29908 {
29909 PyThreadState* __tstate = wxPyBeginAllowThreads();
29910 result = (int)((wxVideoMode const *)arg1)->GetHeight();
29911
29912 wxPyEndAllowThreads(__tstate);
29913 if (PyErr_Occurred()) SWIG_fail;
29914 }
29915 {
29916 resultobj = SWIG_From_int((int)(result));
29917 }
29918 return resultobj;
29919 fail:
29920 return NULL;
29921 }
29922
29923
29924 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
29925 PyObject *resultobj;
29926 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29927 int result;
29928 PyObject * obj0 = 0 ;
29929 char *kwnames[] = {
29930 (char *) "self", NULL
29931 };
29932
29933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
29934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29935 if (SWIG_arg_fail(1)) SWIG_fail;
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 result = (int)((wxVideoMode const *)arg1)->GetDepth();
29939
29940 wxPyEndAllowThreads(__tstate);
29941 if (PyErr_Occurred()) SWIG_fail;
29942 }
29943 {
29944 resultobj = SWIG_From_int((int)(result));
29945 }
29946 return resultobj;
29947 fail:
29948 return NULL;
29949 }
29950
29951
29952 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
29953 PyObject *resultobj;
29954 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29955 bool result;
29956 PyObject * obj0 = 0 ;
29957 char *kwnames[] = {
29958 (char *) "self", NULL
29959 };
29960
29961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
29962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29963 if (SWIG_arg_fail(1)) SWIG_fail;
29964 {
29965 PyThreadState* __tstate = wxPyBeginAllowThreads();
29966 result = (bool)((wxVideoMode const *)arg1)->IsOk();
29967
29968 wxPyEndAllowThreads(__tstate);
29969 if (PyErr_Occurred()) SWIG_fail;
29970 }
29971 {
29972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29973 }
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
29981 PyObject *resultobj;
29982 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29983 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
29984 bool result;
29985 PyObject * obj0 = 0 ;
29986 PyObject * obj1 = 0 ;
29987 char *kwnames[] = {
29988 (char *) "self",(char *) "other", NULL
29989 };
29990
29991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
29992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29993 if (SWIG_arg_fail(1)) SWIG_fail;
29994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29995 if (SWIG_arg_fail(2)) SWIG_fail;
29996 {
29997 PyThreadState* __tstate = wxPyBeginAllowThreads();
29998 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
29999
30000 wxPyEndAllowThreads(__tstate);
30001 if (PyErr_Occurred()) SWIG_fail;
30002 }
30003 {
30004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30005 }
30006 return resultobj;
30007 fail:
30008 return NULL;
30009 }
30010
30011
30012 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30013 PyObject *resultobj;
30014 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30015 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30016 bool result;
30017 PyObject * obj0 = 0 ;
30018 PyObject * obj1 = 0 ;
30019 char *kwnames[] = {
30020 (char *) "self",(char *) "other", NULL
30021 };
30022
30023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30025 if (SWIG_arg_fail(1)) SWIG_fail;
30026 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30027 if (SWIG_arg_fail(2)) SWIG_fail;
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30031
30032 wxPyEndAllowThreads(__tstate);
30033 if (PyErr_Occurred()) SWIG_fail;
30034 }
30035 {
30036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30037 }
30038 return resultobj;
30039 fail:
30040 return NULL;
30041 }
30042
30043
30044 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30045 PyObject *resultobj;
30046 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30047 int arg2 ;
30048 PyObject * obj0 = 0 ;
30049 PyObject * obj1 = 0 ;
30050 char *kwnames[] = {
30051 (char *) "self",(char *) "w", NULL
30052 };
30053
30054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30056 if (SWIG_arg_fail(1)) SWIG_fail;
30057 {
30058 arg2 = (int)(SWIG_As_int(obj1));
30059 if (SWIG_arg_fail(2)) SWIG_fail;
30060 }
30061 if (arg1) (arg1)->w = arg2;
30062
30063 Py_INCREF(Py_None); resultobj = Py_None;
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30071 PyObject *resultobj;
30072 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30073 int result;
30074 PyObject * obj0 = 0 ;
30075 char *kwnames[] = {
30076 (char *) "self", NULL
30077 };
30078
30079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30081 if (SWIG_arg_fail(1)) SWIG_fail;
30082 result = (int) ((arg1)->w);
30083
30084 {
30085 resultobj = SWIG_From_int((int)(result));
30086 }
30087 return resultobj;
30088 fail:
30089 return NULL;
30090 }
30091
30092
30093 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30094 PyObject *resultobj;
30095 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30096 int arg2 ;
30097 PyObject * obj0 = 0 ;
30098 PyObject * obj1 = 0 ;
30099 char *kwnames[] = {
30100 (char *) "self",(char *) "h", NULL
30101 };
30102
30103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30105 if (SWIG_arg_fail(1)) SWIG_fail;
30106 {
30107 arg2 = (int)(SWIG_As_int(obj1));
30108 if (SWIG_arg_fail(2)) SWIG_fail;
30109 }
30110 if (arg1) (arg1)->h = arg2;
30111
30112 Py_INCREF(Py_None); resultobj = Py_None;
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30120 PyObject *resultobj;
30121 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30122 int result;
30123 PyObject * obj0 = 0 ;
30124 char *kwnames[] = {
30125 (char *) "self", NULL
30126 };
30127
30128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30130 if (SWIG_arg_fail(1)) SWIG_fail;
30131 result = (int) ((arg1)->h);
30132
30133 {
30134 resultobj = SWIG_From_int((int)(result));
30135 }
30136 return resultobj;
30137 fail:
30138 return NULL;
30139 }
30140
30141
30142 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30143 PyObject *resultobj;
30144 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30145 int arg2 ;
30146 PyObject * obj0 = 0 ;
30147 PyObject * obj1 = 0 ;
30148 char *kwnames[] = {
30149 (char *) "self",(char *) "bpp", NULL
30150 };
30151
30152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30154 if (SWIG_arg_fail(1)) SWIG_fail;
30155 {
30156 arg2 = (int)(SWIG_As_int(obj1));
30157 if (SWIG_arg_fail(2)) SWIG_fail;
30158 }
30159 if (arg1) (arg1)->bpp = arg2;
30160
30161 Py_INCREF(Py_None); resultobj = Py_None;
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30169 PyObject *resultobj;
30170 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30171 int result;
30172 PyObject * obj0 = 0 ;
30173 char *kwnames[] = {
30174 (char *) "self", NULL
30175 };
30176
30177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30179 if (SWIG_arg_fail(1)) SWIG_fail;
30180 result = (int) ((arg1)->bpp);
30181
30182 {
30183 resultobj = SWIG_From_int((int)(result));
30184 }
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj;
30193 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30194 int arg2 ;
30195 PyObject * obj0 = 0 ;
30196 PyObject * obj1 = 0 ;
30197 char *kwnames[] = {
30198 (char *) "self",(char *) "refresh", NULL
30199 };
30200
30201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30203 if (SWIG_arg_fail(1)) SWIG_fail;
30204 {
30205 arg2 = (int)(SWIG_As_int(obj1));
30206 if (SWIG_arg_fail(2)) SWIG_fail;
30207 }
30208 if (arg1) (arg1)->refresh = arg2;
30209
30210 Py_INCREF(Py_None); resultobj = Py_None;
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30218 PyObject *resultobj;
30219 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30220 int result;
30221 PyObject * obj0 = 0 ;
30222 char *kwnames[] = {
30223 (char *) "self", NULL
30224 };
30225
30226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30228 if (SWIG_arg_fail(1)) SWIG_fail;
30229 result = (int) ((arg1)->refresh);
30230
30231 {
30232 resultobj = SWIG_From_int((int)(result));
30233 }
30234 return resultobj;
30235 fail:
30236 return NULL;
30237 }
30238
30239
30240 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30241 PyObject *obj;
30242 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30243 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30244 Py_INCREF(obj);
30245 return Py_BuildValue((char *)"");
30246 }
30247 static int _wrap_DefaultVideoMode_set(PyObject *) {
30248 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30249 return 1;
30250 }
30251
30252
30253 static PyObject *_wrap_DefaultVideoMode_get(void) {
30254 PyObject *pyobj;
30255
30256 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30257 return pyobj;
30258 }
30259
30260
30261 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30262 PyObject *resultobj;
30263 size_t arg1 = (size_t) 0 ;
30264 wxDisplay *result;
30265 PyObject * obj0 = 0 ;
30266 char *kwnames[] = {
30267 (char *) "index", NULL
30268 };
30269
30270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30271 if (obj0) {
30272 {
30273 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30274 if (SWIG_arg_fail(1)) SWIG_fail;
30275 }
30276 }
30277 {
30278 PyThreadState* __tstate = wxPyBeginAllowThreads();
30279 result = (wxDisplay *)new wxDisplay(arg1);
30280
30281 wxPyEndAllowThreads(__tstate);
30282 if (PyErr_Occurred()) SWIG_fail;
30283 }
30284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30285 return resultobj;
30286 fail:
30287 return NULL;
30288 }
30289
30290
30291 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30292 PyObject *resultobj;
30293 wxDisplay *arg1 = (wxDisplay *) 0 ;
30294 PyObject * obj0 = 0 ;
30295 char *kwnames[] = {
30296 (char *) "self", NULL
30297 };
30298
30299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30301 if (SWIG_arg_fail(1)) SWIG_fail;
30302 {
30303 PyThreadState* __tstate = wxPyBeginAllowThreads();
30304 delete arg1;
30305
30306 wxPyEndAllowThreads(__tstate);
30307 if (PyErr_Occurred()) SWIG_fail;
30308 }
30309 Py_INCREF(Py_None); resultobj = Py_None;
30310 return resultobj;
30311 fail:
30312 return NULL;
30313 }
30314
30315
30316 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30317 PyObject *resultobj;
30318 size_t result;
30319 char *kwnames[] = {
30320 NULL
30321 };
30322
30323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30324 {
30325 PyThreadState* __tstate = wxPyBeginAllowThreads();
30326 result = (size_t)wxDisplay::GetCount();
30327
30328 wxPyEndAllowThreads(__tstate);
30329 if (PyErr_Occurred()) SWIG_fail;
30330 }
30331 {
30332 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30333 }
30334 return resultobj;
30335 fail:
30336 return NULL;
30337 }
30338
30339
30340 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30341 PyObject *resultobj;
30342 wxPoint *arg1 = 0 ;
30343 int result;
30344 wxPoint temp1 ;
30345 PyObject * obj0 = 0 ;
30346 char *kwnames[] = {
30347 (char *) "pt", NULL
30348 };
30349
30350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30351 {
30352 arg1 = &temp1;
30353 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30354 }
30355 {
30356 PyThreadState* __tstate = wxPyBeginAllowThreads();
30357 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30358
30359 wxPyEndAllowThreads(__tstate);
30360 if (PyErr_Occurred()) SWIG_fail;
30361 }
30362 {
30363 resultobj = SWIG_From_int((int)(result));
30364 }
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30372 PyObject *resultobj;
30373 wxWindow *arg1 = (wxWindow *) 0 ;
30374 int result;
30375 PyObject * obj0 = 0 ;
30376 char *kwnames[] = {
30377 (char *) "window", NULL
30378 };
30379
30380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30382 if (SWIG_arg_fail(1)) SWIG_fail;
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 result = (int)wxDisplay::GetFromWindow(arg1);
30386
30387 wxPyEndAllowThreads(__tstate);
30388 if (PyErr_Occurred()) SWIG_fail;
30389 }
30390 {
30391 resultobj = SWIG_From_int((int)(result));
30392 }
30393 return resultobj;
30394 fail:
30395 return NULL;
30396 }
30397
30398
30399 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30400 PyObject *resultobj;
30401 wxDisplay *arg1 = (wxDisplay *) 0 ;
30402 bool result;
30403 PyObject * obj0 = 0 ;
30404 char *kwnames[] = {
30405 (char *) "self", NULL
30406 };
30407
30408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30410 if (SWIG_arg_fail(1)) SWIG_fail;
30411 {
30412 PyThreadState* __tstate = wxPyBeginAllowThreads();
30413 result = (bool)((wxDisplay const *)arg1)->IsOk();
30414
30415 wxPyEndAllowThreads(__tstate);
30416 if (PyErr_Occurred()) SWIG_fail;
30417 }
30418 {
30419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30420 }
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30428 PyObject *resultobj;
30429 wxDisplay *arg1 = (wxDisplay *) 0 ;
30430 wxRect result;
30431 PyObject * obj0 = 0 ;
30432 char *kwnames[] = {
30433 (char *) "self", NULL
30434 };
30435
30436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30438 if (SWIG_arg_fail(1)) SWIG_fail;
30439 {
30440 PyThreadState* __tstate = wxPyBeginAllowThreads();
30441 result = ((wxDisplay const *)arg1)->GetGeometry();
30442
30443 wxPyEndAllowThreads(__tstate);
30444 if (PyErr_Occurred()) SWIG_fail;
30445 }
30446 {
30447 wxRect * resultptr;
30448 resultptr = new wxRect((wxRect &)(result));
30449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30450 }
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30458 PyObject *resultobj;
30459 wxDisplay *arg1 = (wxDisplay *) 0 ;
30460 wxString result;
30461 PyObject * obj0 = 0 ;
30462 char *kwnames[] = {
30463 (char *) "self", NULL
30464 };
30465
30466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30468 if (SWIG_arg_fail(1)) SWIG_fail;
30469 {
30470 PyThreadState* __tstate = wxPyBeginAllowThreads();
30471 result = ((wxDisplay const *)arg1)->GetName();
30472
30473 wxPyEndAllowThreads(__tstate);
30474 if (PyErr_Occurred()) SWIG_fail;
30475 }
30476 {
30477 #if wxUSE_UNICODE
30478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30479 #else
30480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30481 #endif
30482 }
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30490 PyObject *resultobj;
30491 wxDisplay *arg1 = (wxDisplay *) 0 ;
30492 bool result;
30493 PyObject * obj0 = 0 ;
30494 char *kwnames[] = {
30495 (char *) "self", NULL
30496 };
30497
30498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30500 if (SWIG_arg_fail(1)) SWIG_fail;
30501 {
30502 PyThreadState* __tstate = wxPyBeginAllowThreads();
30503 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30504
30505 wxPyEndAllowThreads(__tstate);
30506 if (PyErr_Occurred()) SWIG_fail;
30507 }
30508 {
30509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30510 }
30511 return resultobj;
30512 fail:
30513 return NULL;
30514 }
30515
30516
30517 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30518 PyObject *resultobj;
30519 wxDisplay *arg1 = (wxDisplay *) 0 ;
30520 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30521 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30522 PyObject *result;
30523 PyObject * obj0 = 0 ;
30524 PyObject * obj1 = 0 ;
30525 char *kwnames[] = {
30526 (char *) "self",(char *) "mode", NULL
30527 };
30528
30529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30531 if (SWIG_arg_fail(1)) SWIG_fail;
30532 if (obj1) {
30533 {
30534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30535 if (SWIG_arg_fail(2)) SWIG_fail;
30536 if (arg2 == NULL) {
30537 SWIG_null_ref("wxVideoMode");
30538 }
30539 if (SWIG_arg_fail(2)) SWIG_fail;
30540 }
30541 }
30542 {
30543 PyThreadState* __tstate = wxPyBeginAllowThreads();
30544 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30545
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = result;
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30557 PyObject *resultobj;
30558 wxDisplay *arg1 = (wxDisplay *) 0 ;
30559 wxVideoMode result;
30560 PyObject * obj0 = 0 ;
30561 char *kwnames[] = {
30562 (char *) "self", NULL
30563 };
30564
30565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30567 if (SWIG_arg_fail(1)) SWIG_fail;
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30571
30572 wxPyEndAllowThreads(__tstate);
30573 if (PyErr_Occurred()) SWIG_fail;
30574 }
30575 {
30576 wxVideoMode * resultptr;
30577 resultptr = new wxVideoMode((wxVideoMode &)(result));
30578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30579 }
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30587 PyObject *resultobj;
30588 wxDisplay *arg1 = (wxDisplay *) 0 ;
30589 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30590 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30591 bool result;
30592 PyObject * obj0 = 0 ;
30593 PyObject * obj1 = 0 ;
30594 char *kwnames[] = {
30595 (char *) "self",(char *) "mode", NULL
30596 };
30597
30598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30600 if (SWIG_arg_fail(1)) SWIG_fail;
30601 if (obj1) {
30602 {
30603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30604 if (SWIG_arg_fail(2)) SWIG_fail;
30605 if (arg2 == NULL) {
30606 SWIG_null_ref("wxVideoMode");
30607 }
30608 if (SWIG_arg_fail(2)) SWIG_fail;
30609 }
30610 }
30611 {
30612 PyThreadState* __tstate = wxPyBeginAllowThreads();
30613 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30614
30615 wxPyEndAllowThreads(__tstate);
30616 if (PyErr_Occurred()) SWIG_fail;
30617 }
30618 {
30619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30620 }
30621 return resultobj;
30622 fail:
30623 return NULL;
30624 }
30625
30626
30627 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30628 PyObject *resultobj;
30629 wxDisplay *arg1 = (wxDisplay *) 0 ;
30630 PyObject * obj0 = 0 ;
30631 char *kwnames[] = {
30632 (char *) "self", NULL
30633 };
30634
30635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30637 if (SWIG_arg_fail(1)) SWIG_fail;
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 (arg1)->ResetMode();
30641
30642 wxPyEndAllowThreads(__tstate);
30643 if (PyErr_Occurred()) SWIG_fail;
30644 }
30645 Py_INCREF(Py_None); resultobj = Py_None;
30646 return resultobj;
30647 fail:
30648 return NULL;
30649 }
30650
30651
30652 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30653 PyObject *obj;
30654 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30655 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30656 Py_INCREF(obj);
30657 return Py_BuildValue((char *)"");
30658 }
30659 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30660 PyObject *resultobj;
30661 wxStandardPaths *result;
30662 char *kwnames[] = {
30663 NULL
30664 };
30665
30666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30667 {
30668 PyThreadState* __tstate = wxPyBeginAllowThreads();
30669 result = (wxStandardPaths *)StandardPaths_Get();
30670
30671 wxPyEndAllowThreads(__tstate);
30672 if (PyErr_Occurred()) SWIG_fail;
30673 }
30674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30675 return resultobj;
30676 fail:
30677 return NULL;
30678 }
30679
30680
30681 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30682 PyObject *resultobj;
30683 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30684 wxString result;
30685 PyObject * obj0 = 0 ;
30686 char *kwnames[] = {
30687 (char *) "self", NULL
30688 };
30689
30690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30692 if (SWIG_arg_fail(1)) SWIG_fail;
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30696
30697 wxPyEndAllowThreads(__tstate);
30698 if (PyErr_Occurred()) SWIG_fail;
30699 }
30700 {
30701 #if wxUSE_UNICODE
30702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30703 #else
30704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30705 #endif
30706 }
30707 return resultobj;
30708 fail:
30709 return NULL;
30710 }
30711
30712
30713 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30714 PyObject *resultobj;
30715 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30716 wxString result;
30717 PyObject * obj0 = 0 ;
30718 char *kwnames[] = {
30719 (char *) "self", NULL
30720 };
30721
30722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30724 if (SWIG_arg_fail(1)) SWIG_fail;
30725 {
30726 PyThreadState* __tstate = wxPyBeginAllowThreads();
30727 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30728
30729 wxPyEndAllowThreads(__tstate);
30730 if (PyErr_Occurred()) SWIG_fail;
30731 }
30732 {
30733 #if wxUSE_UNICODE
30734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30735 #else
30736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30737 #endif
30738 }
30739 return resultobj;
30740 fail:
30741 return NULL;
30742 }
30743
30744
30745 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30746 PyObject *resultobj;
30747 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30748 wxString result;
30749 PyObject * obj0 = 0 ;
30750 char *kwnames[] = {
30751 (char *) "self", NULL
30752 };
30753
30754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30756 if (SWIG_arg_fail(1)) SWIG_fail;
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30760
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 {
30765 #if wxUSE_UNICODE
30766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30767 #else
30768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30769 #endif
30770 }
30771 return resultobj;
30772 fail:
30773 return NULL;
30774 }
30775
30776
30777 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30778 PyObject *resultobj;
30779 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30780 wxString result;
30781 PyObject * obj0 = 0 ;
30782 char *kwnames[] = {
30783 (char *) "self", NULL
30784 };
30785
30786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30788 if (SWIG_arg_fail(1)) SWIG_fail;
30789 {
30790 PyThreadState* __tstate = wxPyBeginAllowThreads();
30791 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30792
30793 wxPyEndAllowThreads(__tstate);
30794 if (PyErr_Occurred()) SWIG_fail;
30795 }
30796 {
30797 #if wxUSE_UNICODE
30798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30799 #else
30800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30801 #endif
30802 }
30803 return resultobj;
30804 fail:
30805 return NULL;
30806 }
30807
30808
30809 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30810 PyObject *resultobj;
30811 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30812 wxString result;
30813 PyObject * obj0 = 0 ;
30814 char *kwnames[] = {
30815 (char *) "self", NULL
30816 };
30817
30818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30820 if (SWIG_arg_fail(1)) SWIG_fail;
30821 {
30822 PyThreadState* __tstate = wxPyBeginAllowThreads();
30823 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30824
30825 wxPyEndAllowThreads(__tstate);
30826 if (PyErr_Occurred()) SWIG_fail;
30827 }
30828 {
30829 #if wxUSE_UNICODE
30830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30831 #else
30832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30833 #endif
30834 }
30835 return resultobj;
30836 fail:
30837 return NULL;
30838 }
30839
30840
30841 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30842 PyObject *resultobj;
30843 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30844 wxString result;
30845 PyObject * obj0 = 0 ;
30846 char *kwnames[] = {
30847 (char *) "self", NULL
30848 };
30849
30850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
30851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30852 if (SWIG_arg_fail(1)) SWIG_fail;
30853 {
30854 PyThreadState* __tstate = wxPyBeginAllowThreads();
30855 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
30856
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 {
30861 #if wxUSE_UNICODE
30862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30863 #else
30864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30865 #endif
30866 }
30867 return resultobj;
30868 fail:
30869 return NULL;
30870 }
30871
30872
30873 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
30874 PyObject *resultobj;
30875 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30876 wxString result;
30877 PyObject * obj0 = 0 ;
30878 char *kwnames[] = {
30879 (char *) "self", NULL
30880 };
30881
30882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
30883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30884 if (SWIG_arg_fail(1)) SWIG_fail;
30885 {
30886 PyThreadState* __tstate = wxPyBeginAllowThreads();
30887 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
30888
30889 wxPyEndAllowThreads(__tstate);
30890 if (PyErr_Occurred()) SWIG_fail;
30891 }
30892 {
30893 #if wxUSE_UNICODE
30894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30895 #else
30896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30897 #endif
30898 }
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30906 PyObject *resultobj;
30907 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30908 wxString *arg2 = 0 ;
30909 bool temp2 = false ;
30910 PyObject * obj0 = 0 ;
30911 PyObject * obj1 = 0 ;
30912 char *kwnames[] = {
30913 (char *) "self",(char *) "prefix", NULL
30914 };
30915
30916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
30917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30918 if (SWIG_arg_fail(1)) SWIG_fail;
30919 {
30920 arg2 = wxString_in_helper(obj1);
30921 if (arg2 == NULL) SWIG_fail;
30922 temp2 = true;
30923 }
30924 {
30925 PyThreadState* __tstate = wxPyBeginAllowThreads();
30926 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
30927
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 Py_INCREF(Py_None); resultobj = Py_None;
30932 {
30933 if (temp2)
30934 delete arg2;
30935 }
30936 return resultobj;
30937 fail:
30938 {
30939 if (temp2)
30940 delete arg2;
30941 }
30942 return NULL;
30943 }
30944
30945
30946 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30947 PyObject *resultobj;
30948 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30949 wxString result;
30950 PyObject * obj0 = 0 ;
30951 char *kwnames[] = {
30952 (char *) "self", NULL
30953 };
30954
30955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
30956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30957 if (SWIG_arg_fail(1)) SWIG_fail;
30958 {
30959 PyThreadState* __tstate = wxPyBeginAllowThreads();
30960 result = wxStandardPaths_GetInstallPrefix(arg1);
30961
30962 wxPyEndAllowThreads(__tstate);
30963 if (PyErr_Occurred()) SWIG_fail;
30964 }
30965 {
30966 #if wxUSE_UNICODE
30967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30968 #else
30969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30970 #endif
30971 }
30972 return resultobj;
30973 fail:
30974 return NULL;
30975 }
30976
30977
30978 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
30979 PyObject *obj;
30980 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30981 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
30982 Py_INCREF(obj);
30983 return Py_BuildValue((char *)"");
30984 }
30985 static PyMethodDef SwigMethods[] = {
30986 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30987 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
30988 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
30989 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
30990 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30991 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30992 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
30993 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
30994 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
30995 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
30996 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
30997 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
30998 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
30999 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31000 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31001 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31002 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31003 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31004 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31005 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31006 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31007 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31008 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31009 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31010 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31011 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31012 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31013 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31014 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31015 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31016 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31017 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31018 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31019 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31020 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31021 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31022 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31023 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31024 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31025 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31026 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31027 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31028 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31029 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31030 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31031 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31032 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31033 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31034 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31035 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31036 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31037 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31038 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31039 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31040 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31041 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31042 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31043 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31044 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31045 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31046 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31047 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31048 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31049 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31050 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31051 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31052 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31053 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31054 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31055 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31056 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31057 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31058 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31059 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31060 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31061 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31062 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31063 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31064 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31065 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31066 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31067 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31068 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31069 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31070 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31071 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31072 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31073 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31074 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31075 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31076 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31077 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31078 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31079 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31080 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31081 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31082 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31083 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31084 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31085 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31086 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31087 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31088 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31089 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31090 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31091 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31092 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31093 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31094 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31095 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31096 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31097 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31098 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31099 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31100 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31101 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31102 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31103 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31104 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31105 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31106 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31111 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31112 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31113 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31114 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31115 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31119 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31120 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31121 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31125 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31126 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31127 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31128 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31129 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31130 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31131 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31132 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31133 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31135 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31136 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31137 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31138 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31139 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31140 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31144 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31147 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31150 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31151 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31152 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31154 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31155 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31156 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31157 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31158 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31159 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31160 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31161 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31162 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31168 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31181 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31182 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31183 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31185 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31187 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31188 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31193 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31194 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31200 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31207 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31214 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31218 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31221 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31238 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31246 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31293 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31311 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31321 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31337 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31353 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31367 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31376 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31419 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31422 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31425 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31429 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31522 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31523 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31524 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31525 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31542 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31587 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31621 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31629 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31630 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31635 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31644 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31651 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31654 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31657 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31662 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31665 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31669 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31672 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31676 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
31677 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31681 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31685 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31689 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31699 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31710 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31718 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31726 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31740 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31744 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31762 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31776 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31787 { NULL, NULL, 0, NULL }
31788 };
31789
31790
31791 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31792
31793 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31794 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31795 }
31796 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31797 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31798 }
31799 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31800 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31801 }
31802 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31803 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31804 }
31805 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31806 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31807 }
31808 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31809 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31810 }
31811 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31812 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31813 }
31814 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31815 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31816 }
31817 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31818 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31819 }
31820 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31821 return (void *)((wxEvent *) ((wxPyEvent *) x));
31822 }
31823 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31824 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31825 }
31826 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
31827 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
31828 }
31829 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
31830 return (void *)((wxEvent *) ((wxIdleEvent *) x));
31831 }
31832 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
31833 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
31834 }
31835 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
31836 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
31837 }
31838 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
31839 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
31840 }
31841 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
31842 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
31843 }
31844 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
31845 return (void *)((wxEvent *) ((wxActivateEvent *) x));
31846 }
31847 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
31848 return (void *)((wxEvent *) ((wxSizeEvent *) x));
31849 }
31850 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
31851 return (void *)((wxEvent *) ((wxMoveEvent *) x));
31852 }
31853 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
31854 return (void *)((wxEvent *) ((wxPaintEvent *) x));
31855 }
31856 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
31857 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
31858 }
31859 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
31860 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
31861 }
31862 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
31863 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
31864 }
31865 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
31866 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
31867 }
31868 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
31869 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31870 }
31871 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
31872 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
31873 }
31874 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
31875 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
31876 }
31877 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
31878 return (void *)((wxEvent *) ((wxFocusEvent *) x));
31879 }
31880 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
31881 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
31882 }
31883 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
31884 return (void *)((wxEvent *) ((wxProcessEvent *) x));
31885 }
31886 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
31887 return (void *)((wxEvent *) ((wxShowEvent *) x));
31888 }
31889 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
31890 return (void *)((wxEvent *) ((wxCommandEvent *) x));
31891 }
31892 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
31893 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
31894 }
31895 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
31896 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
31897 }
31898 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
31899 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
31900 }
31901 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
31902 return (void *)((wxEvent *) ((wxKeyEvent *) x));
31903 }
31904 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
31905 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
31906 }
31907 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
31908 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
31909 }
31910 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
31911 return (void *)((wxConfigBase *) ((wxConfig *) x));
31912 }
31913 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
31914 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31915 }
31916 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
31917 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
31918 }
31919 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
31920 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
31921 }
31922 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
31923 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31924 }
31925 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
31926 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
31927 }
31928 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
31929 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
31930 }
31931 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
31932 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
31933 }
31934 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
31935 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31936 }
31937 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
31938 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31939 }
31940 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
31941 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
31942 }
31943 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
31944 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
31945 }
31946 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
31947 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
31948 }
31949 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
31950 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31951 }
31952 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
31953 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
31954 }
31955 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
31956 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31957 }
31958 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31959 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
31960 }
31961 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31962 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
31963 }
31964 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31965 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31966 }
31967 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31968 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31969 }
31970 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
31971 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
31972 }
31973 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
31974 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
31975 }
31976 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
31977 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31978 }
31979 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
31980 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
31981 }
31982 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
31983 return (void *)((wxEvtHandler *) ((wxWindow *) x));
31984 }
31985 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
31986 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
31987 }
31988 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
31989 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
31990 }
31991 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
31992 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
31993 }
31994 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
31995 return (void *)((wxEvtHandler *) ((wxValidator *) x));
31996 }
31997 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
31998 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
31999 }
32000 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32001 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32002 }
32003 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32004 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32005 }
32006 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32007 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32008 }
32009 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32010 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32011 }
32012 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32013 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32014 }
32015 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32016 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32017 }
32018 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32019 return (void *)((wxObject *) ((wxSizerItem *) x));
32020 }
32021 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32022 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32023 }
32024 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32025 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32026 }
32027 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32028 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32029 }
32030 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32031 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32032 }
32033 static void *_p_wxSizerTo_p_wxObject(void *x) {
32034 return (void *)((wxObject *) ((wxSizer *) x));
32035 }
32036 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32037 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32038 }
32039 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32040 return (void *)((wxObject *) ((wxFileHistory *) x));
32041 }
32042 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32043 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32044 }
32045 static void *_p_wxEventTo_p_wxObject(void *x) {
32046 return (void *)((wxObject *) ((wxEvent *) x));
32047 }
32048 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32049 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32050 }
32051 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32052 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32053 }
32054 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32055 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32056 }
32057 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32058 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32059 }
32060 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32061 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32062 }
32063 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32064 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32065 }
32066 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32067 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32068 }
32069 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32070 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32071 }
32072 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32073 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32074 }
32075 static void *_p_wxControlTo_p_wxObject(void *x) {
32076 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32077 }
32078 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32079 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32080 }
32081 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32082 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32083 }
32084 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32085 return (void *)((wxObject *) ((wxFSFile *) x));
32086 }
32087 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32088 return (void *)((wxObject *) ((wxClipboard *) x));
32089 }
32090 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32091 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32092 }
32093 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32094 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32095 }
32096 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32097 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32098 }
32099 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32100 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32101 }
32102 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32103 return (void *)((wxObject *) ((wxToolTip *) x));
32104 }
32105 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32106 return (void *)((wxObject *) ((wxMenuItem *) x));
32107 }
32108 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32109 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32110 }
32111 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32112 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32113 }
32114 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32115 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32116 }
32117 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32118 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32119 }
32120 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32121 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32122 }
32123 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32124 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32125 }
32126 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32127 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32128 }
32129 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32130 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32131 }
32132 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32133 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32134 }
32135 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32136 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32137 }
32138 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32139 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32140 }
32141 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32142 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32143 }
32144 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32145 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32146 }
32147 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32148 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32149 }
32150 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32151 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32152 }
32153 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32154 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32155 }
32156 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32157 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32158 }
32159 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32160 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32161 }
32162 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32163 return (void *)((wxObject *) ((wxImageHandler *) x));
32164 }
32165 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32166 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32167 }
32168 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32169 return (void *)((wxObject *) ((wxEvtHandler *) x));
32170 }
32171 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32172 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32173 }
32174 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32175 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32176 }
32177 static void *_p_wxImageTo_p_wxObject(void *x) {
32178 return (void *)((wxObject *) ((wxImage *) x));
32179 }
32180 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32181 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32182 }
32183 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32184 return (void *)((wxObject *) ((wxSystemOptions *) x));
32185 }
32186 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32187 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32188 }
32189 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32190 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32191 }
32192 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32193 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32194 }
32195 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32196 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32197 }
32198 static void *_p_wxWindowTo_p_wxObject(void *x) {
32199 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32200 }
32201 static void *_p_wxMenuTo_p_wxObject(void *x) {
32202 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32203 }
32204 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32205 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32206 }
32207 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32208 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32209 }
32210 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32211 return (void *)((wxObject *) ((wxFileSystem *) x));
32212 }
32213 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32214 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32215 }
32216 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32217 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32218 }
32219 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32220 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32221 }
32222 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32223 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32224 }
32225 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32226 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32227 }
32228 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32229 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32230 }
32231 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32232 return (void *)((wxObject *) ((wxBusyInfo *) x));
32233 }
32234 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32235 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32236 }
32237 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32238 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32239 }
32240 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32241 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32242 }
32243 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32244 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32245 }
32246 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32247 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32248 }
32249 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32250 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32251 }
32252 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32253 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32254 }
32255 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32256 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32257 }
32258 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32259 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32260 }
32261 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32262 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32263 }
32264 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32265 return (void *)((wxLog *) ((wxLogStderr *) x));
32266 }
32267 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32268 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32269 }
32270 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32271 return (void *)((wxLog *) ((wxLogWindow *) x));
32272 }
32273 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32274 return (void *)((wxLog *) ((wxLogChain *) x));
32275 }
32276 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32277 return (void *)((wxLog *) ((wxLogGui *) x));
32278 }
32279 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32280 return (void *)((wxLog *) ((wxPyLog *) x));
32281 }
32282 static void *_p_wxControlTo_p_wxWindow(void *x) {
32283 return (void *)((wxWindow *) ((wxControl *) x));
32284 }
32285 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32286 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32287 }
32288 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32289 return (void *)((wxWindow *) ((wxMenuBar *) x));
32290 }
32291 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32292 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32293 }
32294 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32295 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32296 }
32297 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}};
32298 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}};
32299 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}};
32300 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}};
32301 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}};
32302 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}};
32303 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32304 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}};
32305 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}};
32306 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}};
32307 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}};
32308 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}};
32309 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}};
32310 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}};
32311 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}};
32312 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}};
32313 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}};
32314 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}};
32315 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}};
32316 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}};
32317 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}};
32318 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}};
32319 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}};
32320 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}};
32321 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}};
32322 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}};
32323 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}};
32324 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}};
32325 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}};
32326 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}};
32327 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}};
32328 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}};
32329 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}};
32330 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}};
32331 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}};
32332 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}};
32333 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}};
32334 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}};
32335 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}};
32336 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}};
32337 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}};
32338 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}};
32339 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}};
32340 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}};
32341 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}};
32342 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}};
32343 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}};
32344 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}};
32345 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}};
32346 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}};
32347 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}};
32348 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}};
32349 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}};
32350 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}};
32351 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}};
32352 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}};
32353 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}};
32354 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}};
32355 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}};
32356 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}};
32357 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}};
32358 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}};
32359 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}};
32360 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}};
32361 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}};
32362 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}};
32363 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}};
32364 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}};
32365 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}};
32366 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}};
32367 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32368 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}};
32369 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}};
32370 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}};
32371 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}};
32372 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}};
32373 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}};
32374 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}};
32375 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}};
32376 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}};
32377 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}};
32378 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}};
32379 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}};
32380 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}};
32381 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}};
32382 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}};
32383 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}};
32384 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}};
32385 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}};
32386 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}};
32387 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}};
32388 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}};
32389 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}};
32390 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}};
32391 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}};
32392 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}};
32393
32394 static swig_type_info *swig_types_initial[] = {
32395 _swigt__p_wxLogChain,
32396 _swigt__p_wxMutexGuiLocker,
32397 _swigt__p_wxMetafile,
32398 _swigt__p_wxFileHistory,
32399 _swigt__p_wxLog,
32400 _swigt__p_wxMenu,
32401 _swigt__p_wxEvent,
32402 _swigt__p_wxDateTime__TimeZone,
32403 _swigt__p_wxConfigBase,
32404 _swigt__p_wxDisplay,
32405 _swigt__p_wxFileType,
32406 _swigt__p_wxLogGui,
32407 _swigt__p_wxFont,
32408 _swigt__p_wxDataFormat,
32409 _swigt__p_wxTimerEvent,
32410 _swigt__p_wxCaret,
32411 _swigt__ptrdiff_t,
32412 _swigt__std__ptrdiff_t,
32413 _swigt__p_int,
32414 _swigt__p_wxSize,
32415 _swigt__p_wxClipboard,
32416 _swigt__p_wxStopWatch,
32417 _swigt__p_wxClipboardLocker,
32418 _swigt__p_wxIcon,
32419 _swigt__p_wxLogStderr,
32420 _swigt__p_wxLogTextCtrl,
32421 _swigt__p_wxTextCtrl,
32422 _swigt__p_wxBusyCursor,
32423 _swigt__p_wxBitmapDataObject,
32424 _swigt__p_wxTextDataObject,
32425 _swigt__p_wxDataObject,
32426 _swigt__p_wxPyTextDataObject,
32427 _swigt__p_wxPyBitmapDataObject,
32428 _swigt__p_wxFileDataObject,
32429 _swigt__p_wxCustomDataObject,
32430 _swigt__p_wxURLDataObject,
32431 _swigt__p_wxMetafileDataObject,
32432 _swigt__p_wxSound,
32433 _swigt__p_wxTimerRunner,
32434 _swigt__p_wxLogWindow,
32435 _swigt__p_wxTimeSpan,
32436 _swigt__p_wxArrayString,
32437 _swigt__p_wxWindowDisabler,
32438 _swigt__p_form_ops_t,
32439 _swigt__p_wxToolTip,
32440 _swigt__p_wxDataObjectComposite,
32441 _swigt__p_wxFileConfig,
32442 _swigt__p_wxSystemSettings,
32443 _swigt__p_wxVideoMode,
32444 _swigt__p_wxDataObjectSimple,
32445 _swigt__p_wxPyDataObjectSimple,
32446 _swigt__p_wxDuplexMode,
32447 _swigt__p_wxEvtHandler,
32448 _swigt__p_wxRect,
32449 _swigt__p_char,
32450 _swigt__p_wxSingleInstanceChecker,
32451 _swigt__p_wxStandardPaths,
32452 _swigt__p_wxFileTypeInfo,
32453 _swigt__p_wxFrame,
32454 _swigt__p_wxTimer,
32455 _swigt__p_wxPaperSize,
32456 _swigt__p_wxMimeTypesManager,
32457 _swigt__p_wxPyArtProvider,
32458 _swigt__p_wxPyTipProvider,
32459 _swigt__p_wxTipProvider,
32460 _swigt__p_wxJoystick,
32461 _swigt__p_wxSystemOptions,
32462 _swigt__p_wxPoint,
32463 _swigt__p_wxJoystickEvent,
32464 _swigt__p_wxCursor,
32465 _swigt__p_wxObject,
32466 _swigt__p_wxOutputStream,
32467 _swigt__p_wxDateTime,
32468 _swigt__p_wxPyDropSource,
32469 _swigt__p_unsigned_long,
32470 _swigt__p_wxKillError,
32471 _swigt__p_wxWindow,
32472 _swigt__p_wxString,
32473 _swigt__p_wxPyProcess,
32474 _swigt__p_wxBitmap,
32475 _swigt__p_wxConfig,
32476 _swigt__unsigned_int,
32477 _swigt__p_unsigned_int,
32478 _swigt__p_unsigned_char,
32479 _swigt__p_wxChar,
32480 _swigt__p_wxBusyInfo,
32481 _swigt__p_wxPyDropTarget,
32482 _swigt__p_wxPyTextDropTarget,
32483 _swigt__p_wxPyFileDropTarget,
32484 _swigt__p_wxProcessEvent,
32485 _swigt__p_wxPyLog,
32486 _swigt__p_wxLogNull,
32487 _swigt__p_wxColour,
32488 _swigt__p_wxPyTimer,
32489 _swigt__p_wxConfigPathChanger,
32490 _swigt__p_wxDateSpan,
32491 0
32492 };
32493
32494
32495 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32496
32497 static swig_const_info swig_const_table[] = {
32498 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32499 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32500 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32501 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32502 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32503 {0, 0, 0, 0.0, 0, 0}};
32504
32505 #ifdef __cplusplus
32506 }
32507 #endif
32508
32509
32510 #ifdef __cplusplus
32511 extern "C" {
32512 #endif
32513
32514 /* Python-specific SWIG API */
32515 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32516 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32517 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32518
32519 /* -----------------------------------------------------------------------------
32520 * global variable support code.
32521 * ----------------------------------------------------------------------------- */
32522
32523 typedef struct swig_globalvar {
32524 char *name; /* Name of global variable */
32525 PyObject *(*get_attr)(); /* Return the current value */
32526 int (*set_attr)(PyObject *); /* Set the value */
32527 struct swig_globalvar *next;
32528 } swig_globalvar;
32529
32530 typedef struct swig_varlinkobject {
32531 PyObject_HEAD
32532 swig_globalvar *vars;
32533 } swig_varlinkobject;
32534
32535 static PyObject *
32536 swig_varlink_repr(swig_varlinkobject *v) {
32537 v = v;
32538 return PyString_FromString("<Swig global variables>");
32539 }
32540
32541 static int
32542 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32543 swig_globalvar *var;
32544 flags = flags;
32545 fprintf(fp,"Swig global variables { ");
32546 for (var = v->vars; var; var=var->next) {
32547 fprintf(fp,"%s", var->name);
32548 if (var->next) fprintf(fp,", ");
32549 }
32550 fprintf(fp," }\n");
32551 return 0;
32552 }
32553
32554 static PyObject *
32555 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32556 swig_globalvar *var = v->vars;
32557 while (var) {
32558 if (strcmp(var->name,n) == 0) {
32559 return (*var->get_attr)();
32560 }
32561 var = var->next;
32562 }
32563 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32564 return NULL;
32565 }
32566
32567 static int
32568 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32569 swig_globalvar *var = v->vars;
32570 while (var) {
32571 if (strcmp(var->name,n) == 0) {
32572 return (*var->set_attr)(p);
32573 }
32574 var = var->next;
32575 }
32576 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32577 return 1;
32578 }
32579
32580 static PyTypeObject varlinktype = {
32581 PyObject_HEAD_INIT(0)
32582 0, /* Number of items in variable part (ob_size) */
32583 (char *)"swigvarlink", /* Type name (tp_name) */
32584 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32585 0, /* Itemsize (tp_itemsize) */
32586 0, /* Deallocator (tp_dealloc) */
32587 (printfunc) swig_varlink_print, /* Print (tp_print) */
32588 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32589 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32590 0, /* tp_compare */
32591 (reprfunc) swig_varlink_repr, /* tp_repr */
32592 0, /* tp_as_number */
32593 0, /* tp_as_sequence */
32594 0, /* tp_as_mapping */
32595 0, /* tp_hash */
32596 0, /* tp_call */
32597 0, /* tp_str */
32598 0, /* tp_getattro */
32599 0, /* tp_setattro */
32600 0, /* tp_as_buffer */
32601 0, /* tp_flags */
32602 0, /* tp_doc */
32603 #if PY_VERSION_HEX >= 0x02000000
32604 0, /* tp_traverse */
32605 0, /* tp_clear */
32606 #endif
32607 #if PY_VERSION_HEX >= 0x02010000
32608 0, /* tp_richcompare */
32609 0, /* tp_weaklistoffset */
32610 #endif
32611 #if PY_VERSION_HEX >= 0x02020000
32612 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32613 #endif
32614 #if PY_VERSION_HEX >= 0x02030000
32615 0, /* tp_del */
32616 #endif
32617 #ifdef COUNT_ALLOCS
32618 0,0,0,0 /* tp_alloc -> tp_next */
32619 #endif
32620 };
32621
32622 /* Create a variable linking object for use later */
32623 static PyObject *
32624 SWIG_Python_newvarlink(void) {
32625 swig_varlinkobject *result = 0;
32626 result = PyMem_NEW(swig_varlinkobject,1);
32627 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32628 result->ob_type = &varlinktype;
32629 result->vars = 0;
32630 result->ob_refcnt = 0;
32631 Py_XINCREF((PyObject *) result);
32632 return ((PyObject*) result);
32633 }
32634
32635 static void
32636 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32637 swig_varlinkobject *v;
32638 swig_globalvar *gv;
32639 v= (swig_varlinkobject *) p;
32640 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32641 gv->name = (char *) malloc(strlen(name)+1);
32642 strcpy(gv->name,name);
32643 gv->get_attr = get_attr;
32644 gv->set_attr = set_attr;
32645 gv->next = v->vars;
32646 v->vars = gv;
32647 }
32648
32649 /* -----------------------------------------------------------------------------
32650 * constants/methods manipulation
32651 * ----------------------------------------------------------------------------- */
32652
32653 /* Install Constants */
32654 static void
32655 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32656 PyObject *obj = 0;
32657 size_t i;
32658 for (i = 0; constants[i].type; i++) {
32659 switch(constants[i].type) {
32660 case SWIG_PY_INT:
32661 obj = PyInt_FromLong(constants[i].lvalue);
32662 break;
32663 case SWIG_PY_FLOAT:
32664 obj = PyFloat_FromDouble(constants[i].dvalue);
32665 break;
32666 case SWIG_PY_STRING:
32667 if (constants[i].pvalue) {
32668 obj = PyString_FromString((char *) constants[i].pvalue);
32669 } else {
32670 Py_INCREF(Py_None);
32671 obj = Py_None;
32672 }
32673 break;
32674 case SWIG_PY_POINTER:
32675 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32676 break;
32677 case SWIG_PY_BINARY:
32678 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32679 break;
32680 default:
32681 obj = 0;
32682 break;
32683 }
32684 if (obj) {
32685 PyDict_SetItemString(d,constants[i].name,obj);
32686 Py_DECREF(obj);
32687 }
32688 }
32689 }
32690
32691 /* -----------------------------------------------------------------------------*/
32692 /* Fix SwigMethods to carry the callback ptrs when needed */
32693 /* -----------------------------------------------------------------------------*/
32694
32695 static void
32696 SWIG_Python_FixMethods(PyMethodDef *methods,
32697 swig_const_info *const_table,
32698 swig_type_info **types,
32699 swig_type_info **types_initial) {
32700 size_t i;
32701 for (i = 0; methods[i].ml_name; ++i) {
32702 char *c = methods[i].ml_doc;
32703 if (c && (c = strstr(c, "swig_ptr: "))) {
32704 int j;
32705 swig_const_info *ci = 0;
32706 char *name = c + 10;
32707 for (j = 0; const_table[j].type; j++) {
32708 if (strncmp(const_table[j].name, name,
32709 strlen(const_table[j].name)) == 0) {
32710 ci = &(const_table[j]);
32711 break;
32712 }
32713 }
32714 if (ci) {
32715 size_t shift = (ci->ptype) - types;
32716 swig_type_info *ty = types_initial[shift];
32717 size_t ldoc = (c - methods[i].ml_doc);
32718 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32719 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32720 char *buff = ndoc;
32721 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32722 strncpy(buff, methods[i].ml_doc, ldoc);
32723 buff += ldoc;
32724 strncpy(buff, "swig_ptr: ", 10);
32725 buff += 10;
32726 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32727 methods[i].ml_doc = ndoc;
32728 }
32729 }
32730 }
32731 }
32732
32733 /* -----------------------------------------------------------------------------*
32734 * Initialize type list
32735 * -----------------------------------------------------------------------------*/
32736
32737 #if PY_MAJOR_VERSION < 2
32738 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32739 is copied out of Python/modsupport.c in python version 2.3.4 */
32740 static int
32741 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32742 {
32743 PyObject *dict;
32744 if (!PyModule_Check(m)) {
32745 PyErr_SetString(PyExc_TypeError,
32746 "PyModule_AddObject() needs module as first arg");
32747 return -1;
32748 }
32749 if (!o) {
32750 PyErr_SetString(PyExc_TypeError,
32751 "PyModule_AddObject() needs non-NULL value");
32752 return -1;
32753 }
32754
32755 dict = PyModule_GetDict(m);
32756 if (dict == NULL) {
32757 /* Internal error -- modules must have a dict! */
32758 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32759 PyModule_GetName(m));
32760 return -1;
32761 }
32762 if (PyDict_SetItemString(dict, name, o))
32763 return -1;
32764 Py_DECREF(o);
32765 return 0;
32766 }
32767 #endif
32768
32769 static swig_type_info **
32770 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32771 static PyMethodDef swig_empty_runtime_method_table[] = {
32772 {
32773 NULL, NULL, 0, NULL
32774 }
32775 };/* Sentinel */
32776
32777 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32778 swig_empty_runtime_method_table);
32779 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32780 if (pointer && module) {
32781 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32782 }
32783 return type_list_handle;
32784 }
32785
32786 static swig_type_info **
32787 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32788 swig_type_info **type_pointer;
32789
32790 /* first check if module already created */
32791 type_pointer = SWIG_Python_GetTypeListHandle();
32792 if (type_pointer) {
32793 return type_pointer;
32794 } else {
32795 /* create a new module and variable */
32796 return SWIG_Python_SetTypeListHandle(type_list_handle);
32797 }
32798 }
32799
32800 #ifdef __cplusplus
32801 }
32802 #endif
32803
32804 /* -----------------------------------------------------------------------------*
32805 * Partial Init method
32806 * -----------------------------------------------------------------------------*/
32807
32808 #ifdef SWIG_LINK_RUNTIME
32809 #ifdef __cplusplus
32810 extern "C"
32811 #endif
32812 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32813 #endif
32814
32815 #ifdef __cplusplus
32816 extern "C"
32817 #endif
32818 SWIGEXPORT(void) SWIG_init(void) {
32819 static PyObject *SWIG_globals = 0;
32820 static int typeinit = 0;
32821 PyObject *m, *d;
32822 int i;
32823 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
32824
32825 /* Fix SwigMethods to carry the callback ptrs when needed */
32826 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
32827
32828 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32829 d = PyModule_GetDict(m);
32830
32831 if (!typeinit) {
32832 #ifdef SWIG_LINK_RUNTIME
32833 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
32834 #else
32835 # ifndef SWIG_STATIC_RUNTIME
32836 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
32837 # endif
32838 #endif
32839 for (i = 0; swig_types_initial[i]; i++) {
32840 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
32841 }
32842 typeinit = 1;
32843 }
32844 SWIG_InstallConstants(d,swig_const_table);
32845
32846 {
32847 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
32848 }
32849 {
32850 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
32851 }
32852 {
32853 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
32854 }
32855 {
32856 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
32857 }
32858 {
32859 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
32860 }
32861 {
32862 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
32863 }
32864 {
32865 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
32866 }
32867 {
32868 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
32869 }
32870 {
32871 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
32872 }
32873 {
32874 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
32875 }
32876 {
32877 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
32878 }
32879 {
32880 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
32881 }
32882 {
32883 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
32884 }
32885 {
32886 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
32887 }
32888 {
32889 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
32890 }
32891 {
32892 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
32893 }
32894 {
32895 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
32896 }
32897 {
32898 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
32899 }
32900 {
32901 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
32902 }
32903 {
32904 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
32905 }
32906 {
32907 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
32908 }
32909 {
32910 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
32911 }
32912 {
32913 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
32914 }
32915 {
32916 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
32917 }
32918 {
32919 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
32920 }
32921 {
32922 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
32923 }
32924 {
32925 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
32926 }
32927 {
32928 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
32929 }
32930 {
32931 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
32932 }
32933 {
32934 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
32935 }
32936 {
32937 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
32938 }
32939 {
32940 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
32941 }
32942 {
32943 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
32944 }
32945 {
32946 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
32947 }
32948 {
32949 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
32950 }
32951 {
32952 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
32953 }
32954 {
32955 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
32956 }
32957 {
32958 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
32959 }
32960 {
32961 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
32962 }
32963 {
32964 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
32965 }
32966 {
32967 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
32968 }
32969 {
32970 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
32971 }
32972 {
32973 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
32974 }
32975 {
32976 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
32977 }
32978 {
32979 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
32980 }
32981 {
32982 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
32983 }
32984 {
32985 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
32986 }
32987 {
32988 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
32989 }
32990 {
32991 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
32992 }
32993 {
32994 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
32995 }
32996 {
32997 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
32998 }
32999 {
33000 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33001 }
33002 {
33003 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33004 }
33005 {
33006 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33007 }
33008 {
33009 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33010 }
33011 {
33012 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33013 }
33014 {
33015 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33016 }
33017 {
33018 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33019 }
33020 {
33021 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33022 }
33023 {
33024 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33025 }
33026 {
33027 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33028 }
33029 {
33030 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33031 }
33032 {
33033 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33034 }
33035 {
33036 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33037 }
33038 {
33039 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33040 }
33041 {
33042 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33043 }
33044 {
33045 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33046 }
33047 {
33048 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33049 }
33050 {
33051 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33052 }
33053 {
33054 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33055 }
33056 {
33057 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33058 }
33059 {
33060 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33061 }
33062 {
33063 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33064 }
33065 {
33066 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33067 }
33068 {
33069 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33070 }
33071 {
33072 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33073 }
33074 {
33075 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33076 }
33077 {
33078 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33079 }
33080 {
33081 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33082 }
33083 {
33084 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33085 }
33086 {
33087 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33088 }
33089 {
33090 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33091 }
33092 {
33093 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33094 }
33095 {
33096 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33097 }
33098 {
33099 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33100 }
33101 {
33102 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33103 }
33104 {
33105 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33106 }
33107 {
33108 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33109 }
33110 {
33111 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33112 }
33113 {
33114 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33115 }
33116 {
33117 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33118 }
33119 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33120 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33121 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33122 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33123 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33124 {
33125 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33126 }
33127 {
33128 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33129 }
33130 {
33131 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33132 }
33133 {
33134 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33135 }
33136 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33137
33138 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33139
33140 {
33141 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33142 }
33143 {
33144 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33145 }
33146 {
33147 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33148 }
33149 {
33150 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33151 }
33152 {
33153 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33154 }
33155 {
33156 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33157 }
33158 {
33159 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33160 }
33161 {
33162 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33163 }
33164 {
33165 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33166 }
33167 {
33168 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33169 }
33170 {
33171 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33172 }
33173 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33174 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33175 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33176 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33177 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33178 {
33179 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33180 }
33181 {
33182 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33183 }
33184 {
33185 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33186 }
33187 {
33188 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33189 }
33190 {
33191 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33192 }
33193 {
33194 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33195 }
33196 {
33197 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33198 }
33199 {
33200 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33201 }
33202 {
33203 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33204 }
33205 {
33206 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33207 }
33208 {
33209 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33210 }
33211 {
33212 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33213 }
33214 {
33215 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33216 }
33217 {
33218 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33219 }
33220 {
33221 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33222 }
33223 {
33224 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33225 }
33226 {
33227 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33228 }
33229 {
33230 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33231 }
33232 {
33233 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33234 }
33235 {
33236 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33237 }
33238 {
33239 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33240 }
33241 {
33242 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33243 }
33244 {
33245 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33246 }
33247 {
33248 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33249 }
33250 {
33251 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33252 }
33253 {
33254 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33255 }
33256 {
33257 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33258 }
33259 {
33260 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33261 }
33262 {
33263 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33264 }
33265 {
33266 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33267 }
33268 {
33269 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33270 }
33271 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33272 {
33273 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33277 }
33278 {
33279 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33280 }
33281 {
33282 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33283 }
33284 {
33285 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33286 }
33287
33288 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33289
33290 {
33291 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33292 }
33293 {
33294 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33295 }
33296 {
33297 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33298 }
33299 {
33300 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33301 }
33302 {
33303 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33304 }
33305 {
33306 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33307 }
33308 {
33309 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33310 }
33311 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33312 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33313 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33314 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33315 {
33316 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33317 }
33318 {
33319 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33320 }
33321 {
33322 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33323 }
33324 {
33325 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33326 }
33327 {
33328 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33329 }
33330 {
33331 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33332 }
33333 {
33334 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33335 }
33336 {
33337 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33338 }
33339 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33340 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33341 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33342 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33343 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33344 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33345 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33346 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33347 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33348 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33349 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33350 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33351 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33352 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33353 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33354 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33355 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33356 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33357 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33358 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33359 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33360 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33361 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33362 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33363 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33364 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33365 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33366 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33367 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33368 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33369 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33370 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33371 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33372 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33373 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33374 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33375 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33376 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33377 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33378 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33379 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33380 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33381 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33382 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33383 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33384
33385 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33386
33387 {
33388 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33389 }
33390 {
33391 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33392 }
33393 {
33394 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33413 }
33414 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33415 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33416 {
33417 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
33856 }
33857 {
33858 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
33859 }
33860 {
33861 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
33862 }
33863 {
33864 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
33865 }
33866 {
33867 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
33868 }
33869 {
33870 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
33877 }
33878 {
33879 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
33880 }
33881 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
33882 {
33883 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
33941 }
33942 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
33943 {
33944 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
33978 }
33979
33980 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
33981 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
33982 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
33983 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
33984
33985 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
33986 }
33987
wxWidgets (Impactor)